android-notify 1.60.0__py3-none-any.whl → 1.60.1__py3-none-any.whl

venv/Lib/site-packages/rfc3986/api.py

@@ -1,104 +0,0 @@
-# Copyright (c) 2014 Rackspace
-# 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 simple and functional API for rfc3986.
-
-This module defines functions and provides access to the public attributes
-and classes of rfc3986.
-"""
-from .iri import IRIReference
-from .parseresult import ParseResult
-from .uri import URIReference
-
-
-def uri_reference(uri, encoding="utf-8"):
-    """Parse a URI string into a URIReference.
-
-    This is a convenience function. You could achieve the same end by using
-    ``URIReference.from_string(uri)``.
-
-    :param str uri: The URI which needs to be parsed into a reference.
-    :param str encoding: The encoding of the string provided
-    :returns: A parsed URI
-    :rtype: :class:`URIReference`
-    """
-    return URIReference.from_string(uri, encoding)
-
-
-def iri_reference(iri, encoding="utf-8"):
-    """Parse a IRI string into an IRIReference.
-
-    This is a convenience function. You could achieve the same end by using
-    ``IRIReference.from_string(iri)``.
-
-    :param str iri: The IRI which needs to be parsed into a reference.
-    :param str encoding: The encoding of the string provided
-    :returns: A parsed IRI
-    :rtype: :class:`IRIReference`
-    """
-    return IRIReference.from_string(iri, encoding)
-
-
-def is_valid_uri(uri, encoding="utf-8", **kwargs):
-    """Determine if the URI given is valid.
-
-    This is a convenience function. You could use either
-    ``uri_reference(uri).is_valid()`` or
-    ``URIReference.from_string(uri).is_valid()`` to achieve the same result.
-
-    :param str uri: The URI to be validated.
-    :param str encoding: The encoding of the string provided
-    :param bool require_scheme: Set to ``True`` if you wish to require the
-        presence of the scheme component.
-    :param bool require_authority: Set to ``True`` if you wish to require the
-        presence of the authority component.
-    :param bool require_path: Set to ``True`` if you wish to require the
-        presence of the path component.
-    :param bool require_query: Set to ``True`` if you wish to require the
-        presence of the query component.
-    :param bool require_fragment: Set to ``True`` if you wish to require the
-        presence of the fragment component.
-    :returns: ``True`` if the URI is valid, ``False`` otherwise.
-    :rtype: bool
-    """
-    return URIReference.from_string(uri, encoding).is_valid(**kwargs)
-
-
-def normalize_uri(uri, encoding="utf-8"):
-    """Normalize the given URI.
-
-    This is a convenience function. You could use either
-    ``uri_reference(uri).normalize().unsplit()`` or
-    ``URIReference.from_string(uri).normalize().unsplit()`` instead.
-
-    :param str uri: The URI to be normalized.
-    :param str encoding: The encoding of the string provided
-    :returns: The normalized URI.
-    :rtype: str
-    """
-    normalized_reference = URIReference.from_string(uri, encoding).normalize()
-    return normalized_reference.unsplit()
-
-
-def urlparse(uri, encoding="utf-8"):
-    """Parse a given URI and return a ParseResult.
-
-    This is a partial replacement of the standard library's urlparse function.
-
-    :param str uri: The URI to be parsed.
-    :param str encoding: The encoding of the string provided.
-    :returns: A parsed URI
-    :rtype: :class:`~rfc3986.parseresult.ParseResult`
-    """
-    return ParseResult.from_string(uri, encoding, strict=False)

venv/Lib/site-packages/rfc3986/builder.py

@@ -1,388 +0,0 @@
-# Copyright (c) 2017 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 logic for the URIBuilder object."""
-from . import compat
-from . import normalizers
-from . import uri
-from . import uri_reference
-
-
-class URIBuilder:
-    """Object to aid in building up a URI Reference from parts.
-
-    .. note::
-
-        This object should be instantiated by the user, but it's recommended
-        that it is not provided with arguments. Instead, use the available
-        method to populate the fields.
-
-    """
-
-    def __init__(
-        self,
-        scheme=None,
-        userinfo=None,
-        host=None,
-        port=None,
-        path=None,
-        query=None,
-        fragment=None,
-    ):
-        """Initialize our URI builder.
-
-        :param str scheme:
-            (optional)
-        :param str userinfo:
-            (optional)
-        :param str host:
-            (optional)
-        :param int port:
-            (optional)
-        :param str path:
-            (optional)
-        :param str query:
-            (optional)
-        :param str fragment:
-            (optional)
-        """
-        self.scheme = scheme
-        self.userinfo = userinfo
-        self.host = host
-        self.port = port
-        self.path = path
-        self.query = query
-        self.fragment = fragment
-
-    def __repr__(self):
-        """Provide a convenient view of our builder object."""
-        formatstr = (
-            "URIBuilder(scheme={b.scheme}, userinfo={b.userinfo}, "
-            "host={b.host}, port={b.port}, path={b.path}, "
-            "query={b.query}, fragment={b.fragment})"
-        )
-        return formatstr.format(b=self)
-
-    @classmethod
-    def from_uri(cls, reference):
-        """Initialize the URI builder from another URI.
-
-        Takes the given URI reference and creates a new URI builder instance
-        populated with the values from the reference. If given a string it will
-        try to convert it to a reference before constructing the builder.
-        """
-        if not isinstance(reference, uri.URIReference):
-            reference = uri_reference(reference)
-        return cls(
-            scheme=reference.scheme,
-            userinfo=reference.userinfo,
-            host=reference.host,
-            port=reference.port,
-            path=reference.path,
-            query=reference.query,
-            fragment=reference.fragment,
-        )
-
-    def add_scheme(self, scheme):
-        """Add a scheme to our builder object.
-
-        After normalizing, this will generate a new URIBuilder instance with
-        the specified scheme and all other attributes the same.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_scheme('HTTPS')
-            URIBuilder(scheme='https', userinfo=None, host=None, port=None,
-                    path=None, query=None, fragment=None)
-
-        """
-        scheme = normalizers.normalize_scheme(scheme)
-        return URIBuilder(
-            scheme=scheme,
-            userinfo=self.userinfo,
-            host=self.host,
-            port=self.port,
-            path=self.path,
-            query=self.query,
-            fragment=self.fragment,
-        )
-
-    def add_credentials(self, username, password):
-        """Add credentials as the userinfo portion of the URI.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_credentials('root', 's3crete')
-            URIBuilder(scheme=None, userinfo='root:s3crete', host=None,
-                    port=None, path=None, query=None, fragment=None)
-
-            >>> URIBuilder().add_credentials('root', None)
-            URIBuilder(scheme=None, userinfo='root', host=None,
-                    port=None, path=None, query=None, fragment=None)
-        """
-        if username is None:
-            raise ValueError("Username cannot be None")
-        userinfo = normalizers.normalize_username(username)
-
-        if password is not None:
-            userinfo = "{}:{}".format(
-                userinfo,
-                normalizers.normalize_password(password),
-            )
-
-        return URIBuilder(
-            scheme=self.scheme,
-            userinfo=userinfo,
-            host=self.host,
-            port=self.port,
-            path=self.path,
-            query=self.query,
-            fragment=self.fragment,
-        )
-
-    def add_host(self, host):
-        """Add hostname to the URI.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_host('google.com')
-            URIBuilder(scheme=None, userinfo=None, host='google.com',
-                    port=None, path=None, query=None, fragment=None)
-
-        """
-        return URIBuilder(
-            scheme=self.scheme,
-            userinfo=self.userinfo,
-            host=normalizers.normalize_host(host),
-            port=self.port,
-            path=self.path,
-            query=self.query,
-            fragment=self.fragment,
-        )
-
-    def add_port(self, port):
-        """Add port to the URI.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_port(80)
-            URIBuilder(scheme=None, userinfo=None, host=None, port='80',
-                    path=None, query=None, fragment=None)
-
-            >>> URIBuilder().add_port(443)
-            URIBuilder(scheme=None, userinfo=None, host=None, port='443',
-                    path=None, query=None, fragment=None)
-
-        """
-        port_int = int(port)
-        if port_int < 0:
-            raise ValueError(
-                "ports are not allowed to be negative. You provided {}".format(
-                    port_int,
-                )
-            )
-        if port_int > 65535:
-            raise ValueError(
-                "ports are not allowed to be larger than 65535. "
-                "You provided {}".format(
-                    port_int,
-                )
-            )
-
-        return URIBuilder(
-            scheme=self.scheme,
-            userinfo=self.userinfo,
-            host=self.host,
-            port=f"{port_int}",
-            path=self.path,
-            query=self.query,
-            fragment=self.fragment,
-        )
-
-    def add_path(self, path):
-        """Add a path to the URI.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_path('sigmavirus24/rfc3985')
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path='/sigmavirus24/rfc3986', query=None, fragment=None)
-
-            >>> URIBuilder().add_path('/checkout.php')
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path='/checkout.php', query=None, fragment=None)
-
-        """
-        if not path.startswith("/"):
-            path = f"/{path}"
-
-        return URIBuilder(
-            scheme=self.scheme,
-            userinfo=self.userinfo,
-            host=self.host,
-            port=self.port,
-            path=normalizers.normalize_path(path),
-            query=self.query,
-            fragment=self.fragment,
-        )
-
-    def extend_path(self, path):
-        """Extend the existing path value with the provided value.
-
-        .. versionadded:: 1.5.0
-
-        .. code-block:: python
-
-            >>> URIBuilder(path="/users").extend_path("/sigmavirus24")
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path='/users/sigmavirus24', query=None, fragment=None)
-
-            >>> URIBuilder(path="/users/").extend_path("/sigmavirus24")
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path='/users/sigmavirus24', query=None, fragment=None)
-
-            >>> URIBuilder(path="/users/").extend_path("sigmavirus24")
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path='/users/sigmavirus24', query=None, fragment=None)
-
-            >>> URIBuilder(path="/users").extend_path("sigmavirus24")
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path='/users/sigmavirus24', query=None, fragment=None)
-
-        """
-        existing_path = self.path or ""
-        path = "{}/{}".format(existing_path.rstrip("/"), path.lstrip("/"))
-
-        return self.add_path(path)
-
-    def add_query_from(self, query_items):
-        """Generate and add a query a dictionary or list of tuples.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_query_from({'a': 'b c'})
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path=None, query='a=b+c', fragment=None)
-
-            >>> URIBuilder().add_query_from([('a', 'b c')])
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path=None, query='a=b+c', fragment=None)
-
-        """
-        query = normalizers.normalize_query(compat.urlencode(query_items))
-
-        return URIBuilder(
-            scheme=self.scheme,
-            userinfo=self.userinfo,
-            host=self.host,
-            port=self.port,
-            path=self.path,
-            query=query,
-            fragment=self.fragment,
-        )
-
-    def extend_query_with(self, query_items):
-        """Extend the existing query string with the new query items.
-
-        .. versionadded:: 1.5.0
-
-        .. code-block:: python
-
-            >>> URIBuilder(query='a=b+c').extend_query_with({'a': 'b c'})
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path=None, query='a=b+c&a=b+c', fragment=None)
-
-            >>> URIBuilder(query='a=b+c').extend_query_with([('a', 'b c')])
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path=None, query='a=b+c&a=b+c', fragment=None)
-        """
-        original_query_items = compat.parse_qsl(self.query or "")
-        if not isinstance(query_items, list):
-            query_items = list(query_items.items())
-
-        return self.add_query_from(original_query_items + query_items)
-
-    def add_query(self, query):
-        """Add a pre-formated query string to the URI.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_query('a=b&c=d')
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path=None, query='a=b&c=d', fragment=None)
-
-        """
-        return URIBuilder(
-            scheme=self.scheme,
-            userinfo=self.userinfo,
-            host=self.host,
-            port=self.port,
-            path=self.path,
-            query=normalizers.normalize_query(query),
-            fragment=self.fragment,
-        )
-
-    def add_fragment(self, fragment):
-        """Add a fragment to the URI.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_fragment('section-2.6.1')
-            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
-                    path=None, query=None, fragment='section-2.6.1')
-
-        """
-        return URIBuilder(
-            scheme=self.scheme,
-            userinfo=self.userinfo,
-            host=self.host,
-            port=self.port,
-            path=self.path,
-            query=self.query,
-            fragment=normalizers.normalize_fragment(fragment),
-        )
-
-    def finalize(self):
-        """Create a URIReference from our builder.
-
-        .. code-block:: python
-
-            >>> URIBuilder().add_scheme('https').add_host('github.com'
-            ...     ).add_path('sigmavirus24/rfc3986').finalize().unsplit()
-            'https://github.com/sigmavirus24/rfc3986'
-
-            >>> URIBuilder().add_scheme('https').add_host('github.com'
-            ...     ).add_path('sigmavirus24/rfc3986').add_credentials(
-            ...     'sigmavirus24', 'not-re@l').finalize().unsplit()
-            'https://sigmavirus24:not-re%40l@github.com/sigmavirus24/rfc3986'
-
-        """
-        return uri.URIReference(
-            self.scheme,
-            normalizers.normalize_authority(
-                (self.userinfo, self.host, self.port)
-            ),
-            self.path,
-            self.query,
-            self.fragment,
-        )
-
-    def geturl(self):
-        """Generate the URL from this builder.
-
-        .. versionadded:: 1.5.0
-
-        This is an alternative to calling :meth:`finalize` and keeping the
-        :class:`rfc3986.uri.URIReference` around.
-        """
-        return self.finalize().unsplit()

venv/Lib/site-packages/rfc3986/compat.py

@@ -1,59 +0,0 @@
-# Copyright (c) 2014 Rackspace
-# 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.
-"""Compatibility module for Python 2 and 3 support."""
-import sys
-
-try:
-    from urllib.parse import quote as urlquote
-except ImportError:  # Python 2.x
-    from urllib import quote as urlquote
-
-try:
-    from urllib.parse import parse_qsl
-except ImportError:  # Python 2.x
-    from urlparse import parse_qsl
-
-try:
-    from urllib.parse import urlencode
-except ImportError:  # Python 2.x
-    from urllib import urlencode
-
-__all__ = (
-    "to_bytes",
-    "to_str",
-    "urlquote",
-    "urlencode",
-    "parse_qsl",
-)
-
-PY3 = (3, 0) <= sys.version_info < (4, 0)
-PY2 = (2, 6) <= sys.version_info < (2, 8)
-
-
-if PY3:
-    unicode = str  # Python 3.x
-
-
-def to_str(b, encoding="utf-8"):
-    """Ensure that b is text in the specified encoding."""
-    if hasattr(b, "decode") and not isinstance(b, unicode):
-        b = b.decode(encoding)
-    return b
-
-
-def to_bytes(s, encoding="utf-8"):
-    """Ensure that s is converted to bytes from the encoding."""
-    if hasattr(s, "encode") and not isinstance(s, bytes):
-        s = s.encode(encoding)
-    return s

venv/Lib/site-packages/rfc3986/exceptions.py

@@ -1,120 +0,0 @@
-"""Exceptions module for rfc3986."""
-from . import compat
-
-
-class RFC3986Exception(Exception):
-    """Base class for all rfc3986 exception classes."""
-
-    pass
-
-
-class InvalidAuthority(RFC3986Exception):
-    """Exception when the authority string is invalid."""
-
-    def __init__(self, authority):
-        """Initialize the exception with the invalid authority."""
-        super().__init__(
-            f"The authority ({compat.to_str(authority)}) is not valid."
-        )
-
-
-class InvalidPort(RFC3986Exception):
-    """Exception when the port is invalid."""
-
-    def __init__(self, port):
-        """Initialize the exception with the invalid port."""
-        super().__init__(f'The port ("{port}") is not valid.')
-
-
-class ResolutionError(RFC3986Exception):
-    """Exception to indicate a failure to resolve a URI."""
-
-    def __init__(self, uri):
-        """Initialize the error with the failed URI."""
-        super().__init__(
-            "{} does not meet the requirements for resolution.".format(
-                uri.unsplit()
-            )
-        )
-
-
-class ValidationError(RFC3986Exception):
-    """Exception raised during Validation of a URI."""
-
-    pass
-
-
-class MissingComponentError(ValidationError):
-    """Exception raised when a required component is missing."""
-
-    def __init__(self, uri, *component_names):
-        """Initialize the error with the missing component name."""
-        verb = "was"
-        if len(component_names) > 1:
-            verb = "were"
-
-        self.uri = uri
-        self.components = sorted(component_names)
-        components = ", ".join(self.components)
-        super().__init__(
-            f"{components} {verb} required but missing",
-            uri,
-            self.components,
-        )
-
-
-class UnpermittedComponentError(ValidationError):
-    """Exception raised when a component has an unpermitted value."""
-
-    def __init__(self, component_name, component_value, allowed_values):
-        """Initialize the error with the unpermitted component."""
-        super().__init__(
-            "{} was required to be one of {!r} but was {!r}".format(
-                component_name,
-                list(sorted(allowed_values)),
-                component_value,
-            ),
-            component_name,
-            component_value,
-            allowed_values,
-        )
-        self.component_name = component_name
-        self.component_value = component_value
-        self.allowed_values = allowed_values
-
-
-class PasswordForbidden(ValidationError):
-    """Exception raised when a URL has a password in the userinfo section."""
-
-    def __init__(self, uri):
-        """Initialize the error with the URI that failed validation."""
-        unsplit = getattr(uri, "unsplit", lambda: uri)
-        super().__init__(
-            '"{}" contained a password when validation forbade it'.format(
-                unsplit()
-            )
-        )
-        self.uri = uri
-
-
-class InvalidComponentsError(ValidationError):
-    """Exception raised when one or more components are invalid."""
-
-    def __init__(self, uri, *component_names):
-        """Initialize the error with the invalid component name(s)."""
-        verb = "was"
-        if len(component_names) > 1:
-            verb = "were"
-
-        self.uri = uri
-        self.components = sorted(component_names)
-        components = ", ".join(self.components)
-        super().__init__(
-            f"{components} {verb} found to be invalid",
-            uri,
-            self.components,
-        )
-
-
-class MissingDependencyError(RFC3986Exception):
-    """Exception raised when an IRI is encoded without the 'idna' module."""