"urlsplit", "urlunsplit", "urlencode", "parse_qs",

"parse_qsl", "quote", "quote_plus", "quote_from_bytes",

"unquote", "unquote_plus", "unquote_to_bytes",

"DefragResult", "ParseResult", "SplitResult",

'imap', 'wais', 'file', 'mms', 'https', 'shttp',

'snews', 'prospero', 'rtsp', 'rtsps', 'rtspu', 'rsync',

'svn', 'svn+ssh', 'sftp', 'nfs', 'git', 'git+ssh',

errors=_implicit_errors):

return tuple(x.decode(encoding, errors) if x

else '' if x is not None

else None

# Invokes decode if necessary to create str args

# and returns the coerced inputs along with

# an appropriate result coercion function

# - noop for str inputs

# - encoding function otherwise

str_input = None

for arg in args:

if arg:

if str_input is None:

str_input = isinstance(arg, str)

else:

if isinstance(arg, str) != str_input:

raise TypeError("Cannot mix str and non-str arguments")

if str_input is None:

for arg in args:

if arg is not None:

str_input = isinstance(arg, str)

break

if str_input is not False:

return args + (_noop,)

"""Standard approach to encoding parsed results from str to bytes"""

__slots__ = ()

def encode(self, encoding='ascii', errors='strict'):

result = self._encoded_counterpart(*(x.encode(encoding, errors)

if x is not None else None

for x in self))

try:

result._keep_empty = self._keep_empty

except AttributeError:

pass

"""Standard approach to decoding parsed results from bytes to str"""

__slots__ = ()

def decode(self, encoding='ascii', errors='strict'):

result = self._decoded_counterpart(*(x.decode(encoding, errors)

if x is not None else None

for x in self))

try:

result._keep_empty = self._keep_empty

except AttributeError:

pass

"""Shared methods for the parsed result objects containing a netloc element"""

__slots__ = ()

@property

def username(self):

return self._userinfo[0]

@property

def password(self):

return self._userinfo[1]

@property

def hostname(self):

hostname = self._hostinfo[0]

if not hostname:

return None

# Scoped IPv6 address may have zone info, which must not be lowercased

# like http://[fe80::822a:a8ff:fe49:470c%tESt]:1234/keys

separator = '%' if isinstance(hostname, str) else b'%'

hostname, percent, zone = hostname.partition(separator)

return hostname.lower() + percent + zone

@property

def port(self):

port = self._hostinfo[1]

if port is not None:

if port.isdigit() and port.isascii():

port = int(port)

else:

raise ValueError(f"Port could not be cast to integer value as {port!r}")

if not (0 <= port <= 65535):

raise ValueError("Port out of range 0-65535")

return port

__slots__ = ()

@property

def _userinfo(self):

netloc = self.netloc

if netloc is None:

return None, None

userinfo, have_info, hostinfo = netloc.rpartition('@')

if have_info:

username, have_password, password = userinfo.partition(':')

if not have_password:

password = None

else:

username = password = None

return username, password

@property

def _hostinfo(self):

netloc = self.netloc

if netloc is None:

return None, None

_, _, hostinfo = netloc.rpartition('@')

_, have_open_br, bracketed = hostinfo.partition('[')

if have_open_br:

hostname, _, port = bracketed.partition(']')

_, _, port = port.partition(':')

else:

hostname, _, port = hostinfo.partition(':')

if not port:

port = None

__slots__ = ()

@property

def _userinfo(self):

netloc = self.netloc

if netloc is None:

return None, None

userinfo, have_info, hostinfo = netloc.rpartition(b'@')

if have_info:

username, have_password, password = userinfo.partition(b':')

if not have_password:

password = None

else:

username = password = None

return username, password

@property

def _hostinfo(self):

netloc = self.netloc

if netloc is None:

return None, None

_, _, hostinfo = netloc.rpartition(b'@')

_, have_open_br, bracketed = hostinfo.partition(b'[')

if have_open_br:

hostname, _, port = bracketed.partition(b']')

_, _, port = port.partition(b':')

else:

hostname, _, port = hostinfo.partition(b':')

if not port:

port = None

__slots__ = ()

def __replace__(self, /, **kwargs):

result = super().__replace__(**kwargs)

try:

result._keep_empty = self._keep_empty

except AttributeError:

pass

return result

def _replace(self, /, **kwargs):

result = super()._replace(**kwargs)

try:

result._keep_empty = self._keep_empty

except AttributeError:

pass

return result

def __copy__(self):

return self

def __deepcopy__(self, memo):

return self

def __getstate__(self):

state = super().__getstate__()

try:

if state[1]['_keep_empty'] == _MISSING_AS_NONE_DEFAULT:

del state[1]['_keep_empty']

if state == (None, {}):

state = None

except LookupError:

pass

__slots__ = ('_keep_empty',)

def geturl(self):

if self.fragment or (self.fragment is not None and

getattr(self, '_keep_empty', _MISSING_AS_NONE_DEFAULT)):

return self.url + self._HASH + self.fragment

else:

'_SplitResultBase', 'scheme netloc path query fragment')):

__slots__ = ('_keep_empty',)

def geturl(self):

'_ParseResultBase', 'scheme netloc path params query fragment')):

__slots__ = ('_keep_empty',)

def geturl(self):

_result_pairs = (

(DefragResult, DefragResultBytes),

(SplitResult, SplitResultBytes),

(ParseResult, ParseResultBytes),

)

for _decoded, _encoded in _result_pairs:

_decoded._encoded_counterpart = _encoded

"""Parse a URL into 6 components:

url, scheme, _coerce_result = _coerce_args(url, scheme)

if url is None:

url = ''

scheme, netloc, url, params, query, fragment = _urlparse(url, scheme, allow_fragments)

if not missing_as_none:

if scheme is None: scheme = ''

if netloc is None: netloc = ''

if params is None: params = ''

if query is None: query = ''

if fragment is None: fragment = ''

result = ParseResult(scheme, netloc, url, params, query, fragment)

result = _coerce_result(result)

result._keep_empty = missing_as_none

scheme, netloc, url, query, fragment = _urlsplit(url, scheme, allow_fragments)

if (scheme or '') in uses_params and ';' in url:

url, params = _splitparams(url, missing_as_none=True)

else:

params = None

if '/' in url:

i = url.find(';', url.rfind('/'))

if i < 0:

return url, None if missing_as_none else ''

else:

i = url.find(';')

delim = len(url) # position of end of domain part of url, default is end

for c in '/?#': # look for delimiters; the order is NOT important

wdelim = url.find(c, start) # find first of this delim

if wdelim >= 0: # if found

delim = min(delim, wdelim) # use earliest delim position

if not netloc or netloc.isascii():

return

# looking for characters like \u2100 that expand to 'a/c'

# IDNA uses NFKC equivalence, so normalize for this check

import unicodedata

n = netloc.replace('@', '') # ignore characters already included

n = n.replace(':', '') # but not the surrounding text

n = n.replace('#', '')

n = n.replace('?', '')

netloc2 = unicodedata.normalize('NFKC', n)

if n == netloc2:

return

for c in '/?#@:':

if c in netloc2:

raise ValueError("netloc '" + netloc + "' contains invalid " +

# Note that this function must mirror the splitting

# done in NetlocResultMixins._hostinfo().

hostname_and_port = netloc.rpartition('@')[2]

before_bracket, have_open_br, bracketed = hostname_and_port.partition('[')

if have_open_br:

# No data is allowed before a bracket.

if before_bracket:

raise ValueError("Invalid IPv6 URL")

hostname, _, port = bracketed.partition(']')

# No data is allowed after the bracket but before the port delimiter.

if port and not port.startswith(":"):

raise ValueError("Invalid IPv6 URL")

else:

hostname, _, port = hostname_and_port.partition(':')

if hostname.startswith('v'):

if not re.match(r"\Av[a-fA-F0-9]+\..+\z", hostname):

raise ValueError(f"IPvFuture address is invalid")

else:

ip = ipaddress.ip_address(hostname) # Throws Value Error if not IPv6 or IPv4

if isinstance(ip, ipaddress.IPv4Address):

"""Parse a URL into 5 components:

url, scheme, _coerce_result = _coerce_args(url, scheme)

if url is None:

url = ''

scheme, netloc, url, query, fragment = _urlsplit(url, scheme, allow_fragments)

if not missing_as_none:

if scheme is None: scheme = ''

if netloc is None: netloc = ''

if query is None: query = ''

if fragment is None: fragment = ''

result = SplitResult(scheme, netloc, url, query, fragment)

result = _coerce_result(result)

result._keep_empty = missing_as_none

# Only lstrip url as some applications rely on preserving trailing space.

# (https://url.spec.whatwg.org/#concept-basic-url-parser would strip both)

url = url.lstrip(_WHATWG_C0_CONTROL_OR_SPACE)

for b in _UNSAFE_URL_BYTES_TO_REMOVE:

url = url.replace(b, "")

if scheme is not None:

scheme = scheme.strip(_WHATWG_C0_CONTROL_OR_SPACE)

for b in _UNSAFE_URL_BYTES_TO_REMOVE:

scheme = scheme.replace(b, "")

allow_fragments = bool(allow_fragments)

netloc = query = fragment = None

i = url.find(':')

if i > 0 and url[0].isascii() and url[0].isalpha():

for c in url[:i]:

if c not in scheme_chars:

break

else:

scheme, url = url[:i].lower(), url[i+1:]

if url[:2] == '//':

netloc, url = _splitnetloc(url, 2)

if (('[' in netloc and ']' not in netloc) or

(']' in netloc and '[' not in netloc)):

raise ValueError("Invalid IPv6 URL")

if '[' in netloc and ']' in netloc:

_check_bracketed_netloc(netloc)

if allow_fragments and '#' in url:

url, fragment = url.split('#', 1)

if '?' in url:

url, query = url.split('?', 1)

_checknetloc(netloc)

"""Put a parsed URL back together again. This may result in a

scheme, netloc, url, params, query, fragment, _coerce_result = (

_coerce_args(*components))

if keep_empty is _UNSPECIFIED:

keep_empty = getattr(components, '_keep_empty', _MISSING_AS_NONE_DEFAULT)

elif keep_empty and not getattr(components, '_keep_empty', True):

raise ValueError('Cannot distinguish between empty and not defined '

'URI components in the result of parsing URL with '

'missing_as_none=False')

if not keep_empty:

if not netloc:

if scheme and scheme in uses_netloc and (not url or url[:1] == '/'):

netloc = ''

else:

netloc = None

if not scheme: scheme = None

if not params: params = None

if not query: query = None

if not fragment: fragment = None

if params is not None:

url = "%s;%s" % (url, params)

"""Combine the elements of a tuple as returned by urlsplit() into a

scheme, netloc, url, query, fragment, _coerce_result = (

_coerce_args(*components))

if keep_empty is _UNSPECIFIED:

keep_empty = getattr(components, '_keep_empty', _MISSING_AS_NONE_DEFAULT)

elif keep_empty and not getattr(components, '_keep_empty', True):

raise ValueError('Cannot distinguish between empty and not defined '

'URI components in the result of parsing URL with '

'missing_as_none=False')

if not keep_empty:

if not netloc:

if scheme and scheme in uses_netloc and (not url or url[:1] == '/'):

netloc = ''

else:

netloc = None

if not scheme: scheme = None

if not query: query = None

if not fragment: fragment = None

if netloc is not None:

if url and url[:1] != '/': url = '/' + url

url = '//' + netloc + url

elif url[:2] == '//':

url = '//' + url

if scheme:

url = scheme + ':' + url

if query is not None:

url = url + '?' + query

if fragment is not None:

url = url + '#' + fragment

"""Join a base URL and a possibly relative URL to form an absolute

if not base:

return url

if not url:

return base

base, url, _coerce_result = _coerce_args(base, url)

bscheme, bnetloc, bpath, bquery, bfragment = \

_urlsplit(base, None, allow_fragments)

scheme, netloc, path, query, fragment = \

_urlsplit(url, None, allow_fragments)

if scheme is None:

scheme = bscheme

if scheme != bscheme or (scheme and scheme not in uses_relative):

return _coerce_result(url)

if not scheme or scheme in uses_netloc:

if netloc:

return _coerce_result(_urlunsplit(scheme, netloc, path,

query, fragment))

netloc = bnetloc

if not path:

path = bpath

if query is None:

query = bquery

if fragment is None:

fragment = bfragment

return _coerce_result(_urlunsplit(scheme, netloc, path,

query, fragment))

base_parts = bpath.split('/')

if base_parts[-1] != '':

# the last item is not a directory, so will not be taken into account

# in resolving the relative path

del base_parts[-1]

# for rfc3986, ignore all base path should the first character be root.

if path[:1] == '/':

segments = path.split('/')

else:

segments = base_parts + path.split('/')

# filter out elements that would cause redundant slashes on re-joining

# the resolved_path

segments[1:-1] = filter(None, segments[1:-1])

resolved_path = []

for seg in segments:

if seg == '..':

try:

resolved_path.pop()

except IndexError:

# ignore any .. segments that would otherwise cause an IndexError

# when popped from resolved_path if resolving for rfc3986

pass

elif seg == '.':

continue

else:

resolved_path.append(seg)

if segments[-1] in ('.', '..'):

# do some post-processing here. if the last segment was a relative dir,

# then we need to append the trailing '/'

resolved_path.append('')

return _coerce_result(_urlunsplit(scheme, netloc, '/'.join(

"""Removes any existing fragment from URL.

url, _coerce_result = _coerce_args(url)

if '#' in url:

s, n, p, q, frag = _urlsplit(url)

defrag = _urlunsplit(s, n, p, q, None)

else:

frag = None

defrag = url

if not missing_as_none and frag is None: frag = ''

result = _coerce_result(DefragResult(defrag, frag))

result._keep_empty = missing_as_none

# Note: strings are encoded as UTF-8. This is only an issue if it contains

# unescaped non-ASCII characters, which URIs should not.

if not string:

# Is it a string-like object?

string.split

return b''

if isinstance(string, str):

string = string.encode('utf-8')

bits = string.split(b'%')

if len(bits) == 1:

return string

res = bytearray(bits[0])

append = res.extend

# Delay the initialization of the table to not waste memory

# if the function is never called

global _hextobyte

if _hextobyte is None:

_hextobyte = {(a + b).encode(): bytes.fromhex(a + b)

for a in _hexdig for b in _hexdig}

for item in bits[1:]:

try:

append(_hextobyte[item[:2]])

append(item[2:])

except KeyError:

append(b'%')

append(item)

previous_match_end = 0

for ascii_match in _asciire.finditer(string):

start, end = ascii_match.span()

yield string[previous_match_end:start] # Non-ASCII

# The ascii_match[1] group == string[start:end].

yield _unquote_impl(ascii_match[1]).decode(encoding, errors)

previous_match_end = end

"""Replace %xx escapes by their single-character equivalent. The optional

if isinstance(string, bytes):

return _unquote_impl(string).decode(encoding, errors)

if '%' not in string:

# Is it a string-like object?

string.split

return string

if encoding is None:

encoding = 'utf-8'

if errors is None:

errors = 'replace'

encoding='utf-8', errors='replace', max_num_fields=None, separator='&'):

"""Parse a query given as a string argument.

parsed_result = {}

pairs = parse_qsl(qs, keep_blank_values, strict_parsing,

encoding=encoding, errors=errors,

max_num_fields=max_num_fields, separator=separator,

_stacklevel=2)

for name, value in pairs:

if name in parsed_result:

parsed_result[name].append(value)

else:

parsed_result[name] = [value]

encoding='utf-8', errors='replace', max_num_fields=None, separator='&', *, _stacklevel=1):

"""Parse a query given as a string argument.

if not separator or not isinstance(separator, (str, bytes)):

raise ValueError("Separator must be of type string or bytes.")

if isinstance(qs, str):

if not isinstance(separator, str):

separator = str(separator, 'ascii')

eq = '='

def _unquote(s):

return unquote_plus(s, encoding=encoding, errors=errors)

elif qs is None:

return []

else:

try:

# Use memoryview() to reject integers and iterables,

# acceptable by the bytes constructor.

qs = bytes(memoryview(qs))

except TypeError:

if not qs:

warnings.warn(f"Accepting {type(qs).__name__} objects with "

f"false value in urllib.parse.parse_qsl() is "

f"deprecated as of 3.14",

DeprecationWarning, stacklevel=_stacklevel + 1)

return []

raise

if isinstance(separator, str):

separator = bytes(separator, 'ascii')

eq = b'='

def _unquote(s):

return unquote_to_bytes(s.replace(b'+', b' '))

if not qs:

return []

# If max_num_fields is defined then check that the number of fields

# is less than max_num_fields. This prevents a memory exhaustion DOS

# attack via post bodies with many fields.

if max_num_fields is not None:

num_fields = 1 + qs.count(separator)

if max_num_fields < num_fields:

raise ValueError('Max number of fields exceeded')

r = []

for name_value in qs.split(separator):

if name_value or strict_parsing:

name, has_eq, value = name_value.partition(eq)

if not has_eq and strict_parsing:

raise ValueError("bad query field: %r" % (name_value,))

if value or keep_blank_values:

name = _unquote(name)

value = _unquote(value)

r.append((name, value))

"""Like unquote(), but also replace plus signs by spaces, as required for

string = string.replace('+', ' ')

"""A mapping from bytes numbers (in range(0,256)) to strings.