"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',

# 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 = isinstance(args[0], str)

for arg in args[1:]:

# We special-case the empty string to support the

# "scheme=''" default argument to some functions

if arg and isinstance(arg, str) != str_input:

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

if str_input:

return args + (_noop,)

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

__slots__ = ()

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

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

__slots__ = ()

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

"""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

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

_, _, 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

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

_, _, 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 geturl(self):

if self.fragment:

return self.url + '#' + self.fragment

else:

__slots__ = ()

def geturl(self):

if self.fragment:

return self.url + b'#' + self.fragment

else:

_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)

splitresult = urlsplit(url, scheme, allow_fragments)

scheme, netloc, url, query, fragment = splitresult

if scheme in uses_params and ';' in url:

url, params = _splitparams(url)

else:

params = ''

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

if '/' in url:

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

if i < 0:

return url, ''

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 " +

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)

# 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)

scheme = scheme.strip(_WHATWG_C0_CONTROL_OR_SPACE)

for b in _UNSAFE_URL_BYTES_TO_REMOVE:

url = url.replace(b, "")

scheme = scheme.replace(b, "")

allow_fragments = bool(allow_fragments)

netloc = query = fragment = ''

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:

bracketed_host = netloc.partition('[')[2].partition(']')[0]

_check_bracketed_host(bracketed_host)

if allow_fragments and '#' in url:

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

if '?' in url:

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

_checknetloc(netloc)

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

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

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

_coerce_args(*components))

if params:

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 netloc or (scheme and scheme in uses_netloc and url[:2] != '//'):

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

url = '//' + (netloc or '') + url

if scheme:

url = scheme + ':' + url

if query:

url = url + '?' + query

if fragment:

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, bparams, bquery, bfragment = \

urlparse(base, '', allow_fragments)

scheme, netloc, path, params, query, fragment = \

urlparse(url, bscheme, allow_fragments)

if scheme != bscheme or scheme not in uses_relative:

return _coerce_result(url)

if scheme in uses_netloc:

if netloc:

return _coerce_result(urlunparse((scheme, netloc, path,

params, query, fragment)))

netloc = bnetloc

if not path and not params:

path = bpath

params = bparams

if not query:

query = bquery

return _coerce_result(urlunparse((scheme, netloc, path,

params, 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(urlunparse((scheme, netloc, '/'.join(

"""Removes any existing fragment from URL.

url, _coerce_result = _coerce_args(url)

if '#' in url:

s, n, p, a, q, frag = urlparse(url)

defrag = urlunparse((s, n, p, a, q, ''))

else:

frag = ''

defrag = url

# 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)

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='&'):

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

qs, _coerce_result = _coerce_args(qs)

separator, _ = _coerce_args(separator)

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

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

# 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 qs else 0

if max_num_fields < num_fields:

raise ValueError('Max number of fields exceeded')

r = []

query_args = qs.split(separator) if qs else []

for name_value in query_args:

if not name_value and not strict_parsing:

continue

nv = name_value.split('=', 1)

if len(nv) != 2:

if strict_parsing:

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

# Handle case of a control-name with no equal sign

if keep_blank_values:

nv.append('')

else:

continue

if len(nv[1]) or keep_blank_values:

name = nv[0].replace('+', ' ')

name = unquote(name, encoding=encoding, errors=errors)

name = _coerce_result(name)

value = nv[1].replace('+', ' ')

value = unquote(value, encoding=encoding, errors=errors)

value = _coerce_result(value)

r.append((name, value))

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

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

if name == 'Quoter':

warnings.warn('Deprecated in 3.11. '

'urllib.parse.Quoter will be removed in Python 3.14. '

'It was not intended to be a public API.',

DeprecationWarning, stacklevel=2)

return _Quoter

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

# Keeps a cache internally, via __missing__, for efficiency (lookups

# of cached keys don't call Python code at all).

def __init__(self, safe):

"""safe: bytes object."""

self.safe = _ALWAYS_SAFE.union(safe)

def __repr__(self):

return f"<Quoter {dict(self)!r}>"

def __missing__(self, b):

# Handle a cache miss. Store quoted string in cache and return.

res = chr(b) if b in self.safe else '%{:02X}'.format(b)

self[b] = res

"""quote('abc def') -> 'abc%20def'

if isinstance(string, str):

if not string:

return string

if encoding is None:

encoding = 'utf-8'

if errors is None:

errors = 'strict'

string = string.encode(encoding, errors)

else:

if encoding is not None:

raise TypeError("quote() doesn't support 'encoding' for bytes")

if errors is not None:

raise TypeError("quote() doesn't support 'errors' for bytes")

"""Like quote(), but also replace ' ' with '+', as required for quoting

# Check if ' ' in string, where string may either be a str or bytes. If

# there are no spaces, the regular quote will produce the right answer.

if ((isinstance(string, str) and ' ' not in string) or

(isinstance(string, bytes) and b' ' not in string)):

return quote(string, safe, encoding, errors)

if isinstance(safe, str):

space = ' '

else:

space = b' '

string = quote(string, safe + space, encoding, errors)

"""Like quote(), but accepts a bytes object rather than a str, and does

if not isinstance(bs, (bytes, bytearray)):

raise TypeError("quote_from_bytes() expected bytes")

if not bs:

return ''

if isinstance(safe, str):

# Normalize 'safe' by converting to bytes and removing non-ASCII chars

safe = safe.encode('ascii', 'ignore')

else:

# List comprehensions are faster than generator expressions.

safe = bytes([c for c in safe if c < 128])

if not bs.rstrip(_ALWAYS_SAFE_BYTES + safe):

return bs.decode()

quoter = _byte_quoter_factory(safe)

if (bs_len := len(bs)) < 200_000:

return ''.join(map(quoter, bs))

else:

# This saves memory - https://github.com/python/cpython/issues/95865

chunk_size = math.isqrt(bs_len)

chunks = [''.join(map(quoter, bs[i:i+chunk_size]))

for i in range(0, bs_len, chunk_size)]

quote_via=quote_plus):

"""Encode a dict or sequence of two-element tuples into a URL query string.

if hasattr(query, "items"):

query = query.items()

else:

# It's a bother at times that strings and string-like objects are

# sequences.

try:

# non-sequence items should not work with len()

# non-empty strings will fail this

if len(query) and not isinstance(query[0], tuple):

raise TypeError

# Zero-length sequences of all types will get here and succeed,

# but that's a minor nit. Since the original implementation

# allowed empty dicts that type of behavior probably should be

# preserved for consistency

except TypeError as err:

raise TypeError("not a valid non-string sequence "

"or mapping object") from err

l = []

if not doseq:

for k, v in query:

if isinstance(k, bytes):

k = quote_via(k, safe)

else:

k = quote_via(str(k), safe, encoding, errors)

if isinstance(v, bytes):

v = quote_via(v, safe)

else:

v = quote_via(str(v), safe, encoding, errors)

l.append(k + '=' + v)

else: