Server IP : 85.214.239.14 / Your IP : 3.21.244.34 Web Server : Apache/2.4.62 (Debian) System : Linux h2886529.stratoserver.net 4.9.0 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.18 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, MySQL : OFF | cURL : OFF | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /proc/3/cwd/proc/3/cwd/usr/lib/python3/dist-packages/rfc3986/ |
Upload File : |
# -*- coding: utf-8 -*- # Copyright (c) 2015 Ian Stapleton Cordasco # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or # implied. # See the License for the specific language governing permissions and # limitations under the License. """Module containing the urlparse compatibility logic.""" from collections import namedtuple from . import compat from . import exceptions from . import misc from . import normalizers from . import uri __all__ = ("ParseResult", "ParseResultBytes") PARSED_COMPONENTS = ( "scheme", "userinfo", "host", "port", "path", "query", "fragment", ) class ParseResultMixin(object): def _generate_authority(self, attributes): # I swear I did not align the comparisons below. That's just how they # happened to align based on pep8 and attribute lengths. userinfo, host, port = ( attributes[p] for p in ("userinfo", "host", "port") ) if ( self.userinfo != userinfo or self.host != host or self.port != port ): if port: port = "{0}".format(port) return normalizers.normalize_authority( ( compat.to_str(userinfo, self.encoding), compat.to_str(host, self.encoding), port, ) ) if isinstance(self.authority, bytes): return self.authority.decode("utf-8") return self.authority def geturl(self): """Shim to match the standard library method.""" return self.unsplit() @property def hostname(self): """Shim to match the standard library.""" return self.host @property def netloc(self): """Shim to match the standard library.""" return self.authority @property def params(self): """Shim to match the standard library.""" return self.query class ParseResult( namedtuple("ParseResult", PARSED_COMPONENTS), ParseResultMixin ): """Implementation of urlparse compatibility class. This uses the URIReference logic to handle compatibility with the urlparse.ParseResult class. """ slots = () def __new__( cls, scheme, userinfo, host, port, path, query, fragment, uri_ref, encoding="utf-8", ): """Create a new ParseResult.""" parse_result = super(ParseResult, cls).__new__( cls, scheme or None, userinfo or None, host, port or None, path or None, query, fragment, ) parse_result.encoding = encoding parse_result.reference = uri_ref return parse_result @classmethod def from_parts( cls, scheme=None, userinfo=None, host=None, port=None, path=None, query=None, fragment=None, encoding="utf-8", ): """Create a ParseResult instance from its parts.""" authority = "" if userinfo is not None: authority += userinfo + "@" if host is not None: authority += host if port is not None: authority += ":{0}".format(port) uri_ref = uri.URIReference( scheme=scheme, authority=authority, path=path, query=query, fragment=fragment, encoding=encoding, ).normalize() userinfo, host, port = authority_from(uri_ref, strict=True) return cls( scheme=uri_ref.scheme, userinfo=userinfo, host=host, port=port, path=uri_ref.path, query=uri_ref.query, fragment=uri_ref.fragment, uri_ref=uri_ref, encoding=encoding, ) @classmethod def from_string( cls, uri_string, encoding="utf-8", strict=True, lazy_normalize=True ): """Parse a URI from the given unicode URI string. :param str uri_string: Unicode URI to be parsed into a reference. :param str encoding: The encoding of the string provided :param bool strict: Parse strictly according to :rfc:`3986` if True. If False, parse similarly to the standard library's urlparse function. :returns: :class:`ParseResult` or subclass thereof """ reference = uri.URIReference.from_string(uri_string, encoding) if not lazy_normalize: reference = reference.normalize() userinfo, host, port = authority_from(reference, strict) return cls( scheme=reference.scheme, userinfo=userinfo, host=host, port=port, path=reference.path, query=reference.query, fragment=reference.fragment, uri_ref=reference, encoding=encoding, ) @property def authority(self): """Return the normalized authority.""" return self.reference.authority def copy_with( self, scheme=misc.UseExisting, userinfo=misc.UseExisting, host=misc.UseExisting, port=misc.UseExisting, path=misc.UseExisting, query=misc.UseExisting, fragment=misc.UseExisting, ): """Create a copy of this instance replacing with specified parts.""" attributes = zip( PARSED_COMPONENTS, (scheme, userinfo, host, port, path, query, fragment), ) attrs_dict = {} for name, value in attributes: if value is misc.UseExisting: value = getattr(self, name) attrs_dict[name] = value authority = self._generate_authority(attrs_dict) ref = self.reference.copy_with( scheme=attrs_dict["scheme"], authority=authority, path=attrs_dict["path"], query=attrs_dict["query"], fragment=attrs_dict["fragment"], ) return ParseResult(uri_ref=ref, encoding=self.encoding, **attrs_dict) def encode(self, encoding=None): """Convert to an instance of ParseResultBytes.""" encoding = encoding or self.encoding attrs = dict( zip( PARSED_COMPONENTS, ( attr.encode(encoding) if hasattr(attr, "encode") else attr for attr in self ), ) ) return ParseResultBytes( uri_ref=self.reference, encoding=encoding, **attrs ) def unsplit(self, use_idna=False): """Create a URI string from the components. :returns: The parsed URI reconstituted as a string. :rtype: str """ parse_result = self if use_idna and self.host: hostbytes = self.host.encode("idna") host = hostbytes.decode(self.encoding) parse_result = self.copy_with(host=host) return parse_result.reference.unsplit() class ParseResultBytes( namedtuple("ParseResultBytes", PARSED_COMPONENTS), ParseResultMixin ): """Compatibility shim for the urlparse.ParseResultBytes object.""" def __new__( cls, scheme, userinfo, host, port, path, query, fragment, uri_ref, encoding="utf-8", lazy_normalize=True, ): """Create a new ParseResultBytes instance.""" parse_result = super(ParseResultBytes, cls).__new__( cls, scheme or None, userinfo or None, host, port or None, path or None, query or None, fragment or None, ) parse_result.encoding = encoding parse_result.reference = uri_ref parse_result.lazy_normalize = lazy_normalize return parse_result @classmethod def from_parts( cls, scheme=None, userinfo=None, host=None, port=None, path=None, query=None, fragment=None, encoding="utf-8", lazy_normalize=True, ): """Create a ParseResult instance from its parts.""" authority = "" if userinfo is not None: authority += userinfo + "@" if host is not None: authority += host if port is not None: authority += ":{0}".format(int(port)) uri_ref = uri.URIReference( scheme=scheme, authority=authority, path=path, query=query, fragment=fragment, encoding=encoding, ) if not lazy_normalize: uri_ref = uri_ref.normalize() to_bytes = compat.to_bytes userinfo, host, port = authority_from(uri_ref, strict=True) return cls( scheme=to_bytes(scheme, encoding), userinfo=to_bytes(userinfo, encoding), host=to_bytes(host, encoding), port=port, path=to_bytes(path, encoding), query=to_bytes(query, encoding), fragment=to_bytes(fragment, encoding), uri_ref=uri_ref, encoding=encoding, lazy_normalize=lazy_normalize, ) @classmethod def from_string( cls, uri_string, encoding="utf-8", strict=True, lazy_normalize=True ): """Parse a URI from the given unicode URI string. :param str uri_string: Unicode URI to be parsed into a reference. :param str encoding: The encoding of the string provided :param bool strict: Parse strictly according to :rfc:`3986` if True. If False, parse similarly to the standard library's urlparse function. :returns: :class:`ParseResultBytes` or subclass thereof """ reference = uri.URIReference.from_string(uri_string, encoding) if not lazy_normalize: reference = reference.normalize() userinfo, host, port = authority_from(reference, strict) to_bytes = compat.to_bytes return cls( scheme=to_bytes(reference.scheme, encoding), userinfo=to_bytes(userinfo, encoding), host=to_bytes(host, encoding), port=port, path=to_bytes(reference.path, encoding), query=to_bytes(reference.query, encoding), fragment=to_bytes(reference.fragment, encoding), uri_ref=reference, encoding=encoding, lazy_normalize=lazy_normalize, ) @property def authority(self): """Return the normalized authority.""" return self.reference.authority.encode(self.encoding) def copy_with( self, scheme=misc.UseExisting, userinfo=misc.UseExisting, host=misc.UseExisting, port=misc.UseExisting, path=misc.UseExisting, query=misc.UseExisting, fragment=misc.UseExisting, lazy_normalize=True, ): """Create a copy of this instance replacing with specified parts.""" attributes = zip( PARSED_COMPONENTS, (scheme, userinfo, host, port, path, query, fragment), ) attrs_dict = {} for name, value in attributes: if value is misc.UseExisting: value = getattr(self, name) if not isinstance(value, bytes) and hasattr(value, "encode"): value = value.encode(self.encoding) attrs_dict[name] = value authority = self._generate_authority(attrs_dict) to_str = compat.to_str ref = self.reference.copy_with( scheme=to_str(attrs_dict["scheme"], self.encoding), authority=to_str(authority, self.encoding), path=to_str(attrs_dict["path"], self.encoding), query=to_str(attrs_dict["query"], self.encoding), fragment=to_str(attrs_dict["fragment"], self.encoding), ) if not lazy_normalize: ref = ref.normalize() return ParseResultBytes( uri_ref=ref, encoding=self.encoding, lazy_normalize=lazy_normalize, **attrs_dict ) def unsplit(self, use_idna=False): """Create a URI bytes object from the components. :returns: The parsed URI reconstituted as a string. :rtype: bytes """ parse_result = self if use_idna and self.host: # self.host is bytes, to encode to idna, we need to decode it # first host = self.host.decode(self.encoding) hostbytes = host.encode("idna") parse_result = self.copy_with(host=hostbytes) if self.lazy_normalize: parse_result = parse_result.copy_with(lazy_normalize=False) uri = parse_result.reference.unsplit() return uri.encode(self.encoding) def split_authority(authority): # Initialize our expected return values userinfo = host = port = None # Initialize an extra var we may need to use extra_host = None # Set-up rest in case there is no userinfo portion rest = authority if "@" in authority: userinfo, rest = authority.rsplit("@", 1) # Handle IPv6 host addresses if rest.startswith("["): host, rest = rest.split("]", 1) host += "]" if ":" in rest: extra_host, port = rest.split(":", 1) elif not host and rest: host = rest if extra_host and not host: host = extra_host return userinfo, host, port def authority_from(reference, strict): try: subauthority = reference.authority_info() except exceptions.InvalidAuthority: if strict: raise userinfo, host, port = split_authority(reference.authority) else: # Thanks to Richard Barrell for this idea: # https://twitter.com/0x2ba22e11/status/617338811975139328 userinfo, host, port = ( subauthority.get(p) for p in ("userinfo", "host", "port") ) if port: try: port = int(port) except ValueError: raise exceptions.InvalidPort(port) return userinfo, host, port