+++ /dev/null
-"""Parse (absolute and relative) URLs.\r
-\r
-urlparse module is based upon the following RFC specifications.\r
-\r
-RFC 3986 (STD66): "Uniform Resource Identifiers" by T. Berners-Lee, R. Fielding\r
-and L. Masinter, January 2005.\r
-\r
-RFC 2732 : "Format for Literal IPv6 Addresses in URL's by R.Hinden, B.Carpenter\r
-and L.Masinter, December 1999.\r
-\r
-RFC 2396: "Uniform Resource Identifiers (URI)": Generic Syntax by T.\r
-Berners-Lee, R. Fielding, and L. Masinter, August 1998.\r
-\r
-RFC 2368: "The mailto URL scheme", by P.Hoffman , L Masinter, J. Zwinski, July 1998.\r
-\r
-RFC 1808: "Relative Uniform Resource Locators", by R. Fielding, UC Irvine, June\r
-1995.\r
-\r
-RFC 1738: "Uniform Resource Locators (URL)" by T. Berners-Lee, L. Masinter, M.\r
-McCahill, December 1994\r
-\r
-RFC 3986 is considered the current standard and any future changes to\r
-urlparse module should conform with it. The urlparse module is\r
-currently not entirely compliant with this RFC due to defacto\r
-scenarios for parsing, and for backward compatibility purposes, some\r
-parsing quirks from older RFCs are retained. The testcases in\r
-test_urlparse.py provides a good indicator of parsing behavior.\r
-\r
-"""\r
-\r
-import re\r
-\r
-__all__ = ["urlparse", "urlunparse", "urljoin", "urldefrag",\r
- "urlsplit", "urlunsplit", "parse_qs", "parse_qsl"]\r
-\r
-# A classification of schemes ('' means apply by default)\r
-uses_relative = ['ftp', 'http', 'gopher', 'nntp', 'imap',\r
- 'wais', 'file', 'https', 'shttp', 'mms',\r
- 'prospero', 'rtsp', 'rtspu', '', 'sftp',\r
- 'svn', 'svn+ssh']\r
-uses_netloc = ['ftp', 'http', 'gopher', 'nntp', 'telnet',\r
- 'imap', 'wais', 'file', 'mms', 'https', 'shttp',\r
- 'snews', 'prospero', 'rtsp', 'rtspu', 'rsync', '',\r
- 'svn', 'svn+ssh', 'sftp','nfs','git', 'git+ssh']\r
-uses_params = ['ftp', 'hdl', 'prospero', 'http', 'imap',\r
- 'https', 'shttp', 'rtsp', 'rtspu', 'sip', 'sips',\r
- 'mms', '', 'sftp', 'tel']\r
-\r
-# These are not actually used anymore, but should stay for backwards\r
-# compatibility. (They are undocumented, but have a public-looking name.)\r
-non_hierarchical = ['gopher', 'hdl', 'mailto', 'news',\r
- 'telnet', 'wais', 'imap', 'snews', 'sip', 'sips']\r
-uses_query = ['http', 'wais', 'imap', 'https', 'shttp', 'mms',\r
- 'gopher', 'rtsp', 'rtspu', 'sip', 'sips', '']\r
-uses_fragment = ['ftp', 'hdl', 'http', 'gopher', 'news',\r
- 'nntp', 'wais', 'https', 'shttp', 'snews',\r
- 'file', 'prospero', '']\r
-\r
-# Characters valid in scheme names\r
-scheme_chars = ('abcdefghijklmnopqrstuvwxyz'\r
- 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\r
- '0123456789'\r
- '+-.')\r
-\r
-MAX_CACHE_SIZE = 20\r
-_parse_cache = {}\r
-\r
-def clear_cache():\r
- """Clear the parse cache."""\r
- _parse_cache.clear()\r
-\r
-\r
-class ResultMixin(object):\r
- """Shared methods for the parsed result objects."""\r
-\r
- @property\r
- def username(self):\r
- netloc = self.netloc\r
- if "@" in netloc:\r
- userinfo = netloc.rsplit("@", 1)[0]\r
- if ":" in userinfo:\r
- userinfo = userinfo.split(":", 1)[0]\r
- return userinfo\r
- return None\r
-\r
- @property\r
- def password(self):\r
- netloc = self.netloc\r
- if "@" in netloc:\r
- userinfo = netloc.rsplit("@", 1)[0]\r
- if ":" in userinfo:\r
- return userinfo.split(":", 1)[1]\r
- return None\r
-\r
- @property\r
- def hostname(self):\r
- netloc = self.netloc.split('@')[-1]\r
- if '[' in netloc and ']' in netloc:\r
- return netloc.split(']')[0][1:].lower()\r
- elif ':' in netloc:\r
- return netloc.split(':')[0].lower()\r
- elif netloc == '':\r
- return None\r
- else:\r
- return netloc.lower()\r
-\r
- @property\r
- def port(self):\r
- netloc = self.netloc.split('@')[-1].split(']')[-1]\r
- if ':' in netloc:\r
- port = netloc.split(':')[1]\r
- if port:\r
- port = int(port, 10)\r
- # verify legal port\r
- if (0 <= port <= 65535):\r
- return port\r
- return None\r
-\r
-from collections import namedtuple\r
-\r
-class SplitResult(namedtuple('SplitResult', 'scheme netloc path query fragment'), ResultMixin):\r
-\r
- __slots__ = ()\r
-\r
- def geturl(self):\r
- return urlunsplit(self)\r
-\r
-\r
-class ParseResult(namedtuple('ParseResult', 'scheme netloc path params query fragment'), ResultMixin):\r
-\r
- __slots__ = ()\r
-\r
- def geturl(self):\r
- return urlunparse(self)\r
-\r
-\r
-def urlparse(url, scheme='', allow_fragments=True):\r
- """Parse a URL into 6 components:\r
- <scheme>://<netloc>/<path>;<params>?<query>#<fragment>\r
- Return a 6-tuple: (scheme, netloc, path, params, query, fragment).\r
- Note that we don't break the components up in smaller bits\r
- (e.g. netloc is a single string) and we don't expand % escapes."""\r
- tuple = urlsplit(url, scheme, allow_fragments)\r
- scheme, netloc, url, query, fragment = tuple\r
- if scheme in uses_params and ';' in url:\r
- url, params = _splitparams(url)\r
- else:\r
- params = ''\r
- return ParseResult(scheme, netloc, url, params, query, fragment)\r
-\r
-def _splitparams(url):\r
- if '/' in url:\r
- i = url.find(';', url.rfind('/'))\r
- if i < 0:\r
- return url, ''\r
- else:\r
- i = url.find(';')\r
- return url[:i], url[i+1:]\r
-\r
-def _splitnetloc(url, start=0):\r
- delim = len(url) # position of end of domain part of url, default is end\r
- for c in '/?#': # look for delimiters; the order is NOT important\r
- wdelim = url.find(c, start) # find first of this delim\r
- if wdelim >= 0: # if found\r
- delim = min(delim, wdelim) # use earliest delim position\r
- return url[start:delim], url[delim:] # return (domain, rest)\r
-\r
-def urlsplit(url, scheme='', allow_fragments=True):\r
- """Parse a URL into 5 components:\r
- <scheme>://<netloc>/<path>?<query>#<fragment>\r
- Return a 5-tuple: (scheme, netloc, path, query, fragment).\r
- Note that we don't break the components up in smaller bits\r
- (e.g. netloc is a single string) and we don't expand % escapes."""\r
- allow_fragments = bool(allow_fragments)\r
- key = url, scheme, allow_fragments, type(url), type(scheme)\r
- cached = _parse_cache.get(key, None)\r
- if cached:\r
- return cached\r
- if len(_parse_cache) >= MAX_CACHE_SIZE: # avoid runaway growth\r
- clear_cache()\r
- netloc = query = fragment = ''\r
- i = url.find(':')\r
- if i > 0:\r
- if url[:i] == 'http': # optimize the common case\r
- scheme = url[:i].lower()\r
- url = url[i+1:]\r
- if url[:2] == '//':\r
- netloc, url = _splitnetloc(url, 2)\r
- if (('[' in netloc and ']' not in netloc) or\r
- (']' in netloc and '[' not in netloc)):\r
- raise ValueError("Invalid IPv6 URL")\r
- if allow_fragments and '#' in url:\r
- url, fragment = url.split('#', 1)\r
- if '?' in url:\r
- url, query = url.split('?', 1)\r
- v = SplitResult(scheme, netloc, url, query, fragment)\r
- _parse_cache[key] = v\r
- return v\r
- for c in url[:i]:\r
- if c not in scheme_chars:\r
- break\r
- else:\r
- # make sure "url" is not actually a port number (in which case\r
- # "scheme" is really part of the path)\r
- rest = url[i+1:]\r
- if not rest or any(c not in '0123456789' for c in rest):\r
- # not a port number\r
- scheme, url = url[:i].lower(), rest\r
-\r
- if url[:2] == '//':\r
- netloc, url = _splitnetloc(url, 2)\r
- if (('[' in netloc and ']' not in netloc) or\r
- (']' in netloc and '[' not in netloc)):\r
- raise ValueError("Invalid IPv6 URL")\r
- if allow_fragments and '#' in url:\r
- url, fragment = url.split('#', 1)\r
- if '?' in url:\r
- url, query = url.split('?', 1)\r
- v = SplitResult(scheme, netloc, url, query, fragment)\r
- _parse_cache[key] = v\r
- return v\r
-\r
-def urlunparse(data):\r
- """Put a parsed URL back together again. This may result in a\r
- slightly different, but equivalent URL, if the URL that was parsed\r
- originally had redundant delimiters, e.g. a ? with an empty query\r
- (the draft states that these are equivalent)."""\r
- scheme, netloc, url, params, query, fragment = data\r
- if params:\r
- url = "%s;%s" % (url, params)\r
- return urlunsplit((scheme, netloc, url, query, fragment))\r
-\r
-def urlunsplit(data):\r
- """Combine the elements of a tuple as returned by urlsplit() into a\r
- complete URL as a string. The data argument can be any five-item iterable.\r
- This may result in a slightly different, but equivalent URL, if the URL that\r
- was parsed originally had unnecessary delimiters (for example, a ? with an\r
- empty query; the RFC states that these are equivalent)."""\r
- scheme, netloc, url, query, fragment = data\r
- if netloc or (scheme and scheme in uses_netloc and url[:2] != '//'):\r
- if url and url[:1] != '/': url = '/' + url\r
- url = '//' + (netloc or '') + url\r
- if scheme:\r
- url = scheme + ':' + url\r
- if query:\r
- url = url + '?' + query\r
- if fragment:\r
- url = url + '#' + fragment\r
- return url\r
-\r
-def urljoin(base, url, allow_fragments=True):\r
- """Join a base URL and a possibly relative URL to form an absolute\r
- interpretation of the latter."""\r
- if not base:\r
- return url\r
- if not url:\r
- return base\r
- bscheme, bnetloc, bpath, bparams, bquery, bfragment = \\r
- urlparse(base, '', allow_fragments)\r
- scheme, netloc, path, params, query, fragment = \\r
- urlparse(url, bscheme, allow_fragments)\r
- if scheme != bscheme or scheme not in uses_relative:\r
- return url\r
- if scheme in uses_netloc:\r
- if netloc:\r
- return urlunparse((scheme, netloc, path,\r
- params, query, fragment))\r
- netloc = bnetloc\r
- if path[:1] == '/':\r
- return urlunparse((scheme, netloc, path,\r
- params, query, fragment))\r
- if not path and not params:\r
- path = bpath\r
- params = bparams\r
- if not query:\r
- query = bquery\r
- return urlunparse((scheme, netloc, path,\r
- params, query, fragment))\r
- segments = bpath.split('/')[:-1] + path.split('/')\r
- # XXX The stuff below is bogus in various ways...\r
- if segments[-1] == '.':\r
- segments[-1] = ''\r
- while '.' in segments:\r
- segments.remove('.')\r
- while 1:\r
- i = 1\r
- n = len(segments) - 1\r
- while i < n:\r
- if (segments[i] == '..'\r
- and segments[i-1] not in ('', '..')):\r
- del segments[i-1:i+1]\r
- break\r
- i = i+1\r
- else:\r
- break\r
- if segments == ['', '..']:\r
- segments[-1] = ''\r
- elif len(segments) >= 2 and segments[-1] == '..':\r
- segments[-2:] = ['']\r
- return urlunparse((scheme, netloc, '/'.join(segments),\r
- params, query, fragment))\r
-\r
-def urldefrag(url):\r
- """Removes any existing fragment from URL.\r
-\r
- Returns a tuple of the defragmented URL and the fragment. If\r
- the URL contained no fragments, the second element is the\r
- empty string.\r
- """\r
- if '#' in url:\r
- s, n, p, a, q, frag = urlparse(url)\r
- defrag = urlunparse((s, n, p, a, q, ''))\r
- return defrag, frag\r
- else:\r
- return url, ''\r
-\r
-try:\r
- unicode\r
-except NameError:\r
- def _is_unicode(x):\r
- return 0\r
-else:\r
- def _is_unicode(x):\r
- return isinstance(x, unicode)\r
-\r
-# unquote method for parse_qs and parse_qsl\r
-# Cannot use directly from urllib as it would create a circular reference\r
-# because urllib uses urlparse methods (urljoin). If you update this function,\r
-# update it also in urllib. This code duplication does not existin in Python3.\r
-\r
-_hexdig = '0123456789ABCDEFabcdef'\r
-_hextochr = dict((a+b, chr(int(a+b,16)))\r
- for a in _hexdig for b in _hexdig)\r
-_asciire = re.compile('([\x00-\x7f]+)')\r
-\r
-def unquote(s):\r
- """unquote('abc%20def') -> 'abc def'."""\r
- if _is_unicode(s):\r
- if '%' not in s:\r
- return s\r
- bits = _asciire.split(s)\r
- res = [bits[0]]\r
- append = res.append\r
- for i in range(1, len(bits), 2):\r
- append(unquote(str(bits[i])).decode('latin1'))\r
- append(bits[i + 1])\r
- return ''.join(res)\r
-\r
- bits = s.split('%')\r
- # fastpath\r
- if len(bits) == 1:\r
- return s\r
- res = [bits[0]]\r
- append = res.append\r
- for item in bits[1:]:\r
- try:\r
- append(_hextochr[item[:2]])\r
- append(item[2:])\r
- except KeyError:\r
- append('%')\r
- append(item)\r
- return ''.join(res)\r
-\r
-def parse_qs(qs, keep_blank_values=0, strict_parsing=0):\r
- """Parse a query given as a string argument.\r
-\r
- Arguments:\r
-\r
- qs: percent-encoded query string to be parsed\r
-\r
- keep_blank_values: flag indicating whether blank values in\r
- percent-encoded queries should be treated as blank strings.\r
- A true value indicates that blanks should be retained as\r
- blank strings. The default false value indicates that\r
- blank values are to be ignored and treated as if they were\r
- not included.\r
-\r
- strict_parsing: flag indicating what to do with parsing errors.\r
- If false (the default), errors are silently ignored.\r
- If true, errors raise a ValueError exception.\r
- """\r
- dict = {}\r
- for name, value in parse_qsl(qs, keep_blank_values, strict_parsing):\r
- if name in dict:\r
- dict[name].append(value)\r
- else:\r
- dict[name] = [value]\r
- return dict\r
-\r
-def parse_qsl(qs, keep_blank_values=0, strict_parsing=0):\r
- """Parse a query given as a string argument.\r
-\r
- Arguments:\r
-\r
- qs: percent-encoded query string to be parsed\r
-\r
- keep_blank_values: flag indicating whether blank values in\r
- percent-encoded queries should be treated as blank strings. A\r
- true value indicates that blanks should be retained as blank\r
- strings. The default false value indicates that blank values\r
- are to be ignored and treated as if they were not included.\r
-\r
- strict_parsing: flag indicating what to do with parsing errors. If\r
- false (the default), errors are silently ignored. If true,\r
- errors raise a ValueError exception.\r
-\r
- Returns a list, as G-d intended.\r
- """\r
- pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]\r
- r = []\r
- for name_value in pairs:\r
- if not name_value and not strict_parsing:\r
- continue\r
- nv = name_value.split('=', 1)\r
- if len(nv) != 2:\r
- if strict_parsing:\r
- raise ValueError, "bad query field: %r" % (name_value,)\r
- # Handle case of a control-name with no equal sign\r
- if keep_blank_values:\r
- nv.append('')\r
- else:\r
- continue\r
- if len(nv[1]) or keep_blank_values:\r
- name = unquote(nv[0].replace('+', ' '))\r
- value = unquote(nv[1].replace('+', ' '))\r
- r.append((name, value))\r
-\r
- return r\r
projects / mirror_edk2.git / blobdiff