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

venv/Lib/site-packages/requests_toolbelt/__init__.py

@@ -1,34 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-requests-toolbelt
-=================
-
-See https://toolbelt.readthedocs.io/ for documentation
-
-:copyright: (c) 2014 by Ian Cordasco and Cory Benfield
-:license: Apache v2.0, see LICENSE for more details
-"""
-
-from .adapters import SSLAdapter, SourceAddressAdapter
-from .auth.guess import GuessAuth
-from .multipart import (
-    MultipartEncoder, MultipartEncoderMonitor, MultipartDecoder,
-    ImproperBodyPartContentException, NonMultipartContentTypeException
-    )
-from .streaming_iterator import StreamingIterator
-from .utils.user_agent import user_agent
-
-__title__ = 'requests-toolbelt'
-__authors__ = 'Ian Cordasco, Cory Benfield'
-__license__ = 'Apache v2.0'
-__copyright__ = 'Copyright 2014 Ian Cordasco, Cory Benfield'
-__version__ = '1.0.0'
-__version_info__ = tuple(int(i) for i in __version__.split('.'))
-
-__all__ = [
-    'GuessAuth', 'MultipartEncoder', 'MultipartEncoderMonitor',
-    'MultipartDecoder', 'SSLAdapter', 'SourceAddressAdapter',
-    'StreamingIterator', 'user_agent', 'ImproperBodyPartContentException',
-    'NonMultipartContentTypeException', '__title__', '__authors__',
-    '__license__', '__copyright__', '__version__', '__version_info__',
-]

venv/Lib/site-packages/requests_toolbelt/_compat.py

@@ -1,302 +0,0 @@
-"""Private module full of compatibility hacks.
-
-Primarily this is for downstream redistributions of requests that unvendor
-urllib3 without providing a shim.
-
-.. warning::
-
-    This module is private. If you use it, and something breaks, you were
-    warned
-"""
-import sys
-
-import requests
-
-try:
-    from requests.packages.urllib3 import fields
-    from requests.packages.urllib3 import filepost
-    from requests.packages.urllib3 import poolmanager
-except ImportError:
-    from urllib3 import fields
-    from urllib3 import filepost
-    from urllib3 import poolmanager
-
-try:
-    from requests.packages.urllib3.connection import HTTPConnection
-    from requests.packages.urllib3 import connection
-except ImportError:
-    try:
-        from urllib3.connection import HTTPConnection
-        from urllib3 import connection
-    except ImportError:
-        HTTPConnection = None
-        connection = None
-
-
-if requests.__build__ < 0x020300:
-    timeout = None
-else:
-    try:
-        from requests.packages.urllib3.util import timeout
-    except ImportError:
-        from urllib3.util import timeout
-
-PY3 = sys.version_info > (3, 0)
-
-if PY3:
-    from collections.abc import Mapping, MutableMapping
-    import queue
-    from urllib.parse import urlencode, urljoin
-else:
-    from collections import Mapping, MutableMapping
-    import Queue as queue
-    from urllib import urlencode
-    from urlparse import urljoin
-
-try:
-    basestring = basestring
-except NameError:
-    basestring = (str, bytes)
-
-
-class HTTPHeaderDict(MutableMapping):
-    """
-    :param headers:
-        An iterable of field-value pairs. Must not contain multiple field names
-        when compared case-insensitively.
-
-    :param kwargs:
-        Additional field-value pairs to pass in to ``dict.update``.
-
-    A ``dict`` like container for storing HTTP Headers.
-
-    Field names are stored and compared case-insensitively in compliance with
-    RFC 7230. Iteration provides the first case-sensitive key seen for each
-    case-insensitive pair.
-
-    Using ``__setitem__`` syntax overwrites fields that compare equal
-    case-insensitively in order to maintain ``dict``'s api. For fields that
-    compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``
-    in a loop.
-
-    If multiple fields that are equal case-insensitively are passed to the
-    constructor or ``.update``, the behavior is undefined and some will be
-    lost.
-
-    >>> headers = HTTPHeaderDict()
-    >>> headers.add('Set-Cookie', 'foo=bar')
-    >>> headers.add('set-cookie', 'baz=quxx')
-    >>> headers['content-length'] = '7'
-    >>> headers['SET-cookie']
-    'foo=bar, baz=quxx'
-    >>> headers['Content-Length']
-    '7'
-    """
-
-    def __init__(self, headers=None, **kwargs):
-        super(HTTPHeaderDict, self).__init__()
-        self._container = {}
-        if headers is not None:
-            if isinstance(headers, HTTPHeaderDict):
-                self._copy_from(headers)
-            else:
-                self.extend(headers)
-        if kwargs:
-            self.extend(kwargs)
-
-    def __setitem__(self, key, val):
-        self._container[key.lower()] = (key, val)
-        return self._container[key.lower()]
-
-    def __getitem__(self, key):
-        val = self._container[key.lower()]
-        return ', '.join(val[1:])
-
-    def __delitem__(self, key):
-        del self._container[key.lower()]
-
-    def __contains__(self, key):
-        return key.lower() in self._container
-
-    def __eq__(self, other):
-        if not isinstance(other, Mapping) and not hasattr(other, 'keys'):
-            return False
-        if not isinstance(other, type(self)):
-            other = type(self)(other)
-        return ({k.lower(): v for k, v in self.itermerged()} ==
-                {k.lower(): v for k, v in other.itermerged()})
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    if not PY3:  # Python 2
-        iterkeys = MutableMapping.iterkeys
-        itervalues = MutableMapping.itervalues
-
-    __marker = object()
-
-    def __len__(self):
-        return len(self._container)
-
-    def __iter__(self):
-        # Only provide the originally cased names
-        for vals in self._container.values():
-            yield vals[0]
-
-    def pop(self, key, default=__marker):
-        """D.pop(k[,d]) -> v, remove specified key and return its value.
-
-        If key is not found, d is returned if given, otherwise KeyError is
-        raised.
-        """
-        # Using the MutableMapping function directly fails due to the private
-        # marker.
-        # Using ordinary dict.pop would expose the internal structures.
-        # So let's reinvent the wheel.
-        try:
-            value = self[key]
-        except KeyError:
-            if default is self.__marker:
-                raise
-            return default
-        else:
-            del self[key]
-            return value
-
-    def discard(self, key):
-        try:
-            del self[key]
-        except KeyError:
-            pass
-
-    def add(self, key, val):
-        """Adds a (name, value) pair, doesn't overwrite the value if it already
-        exists.
-
-        >>> headers = HTTPHeaderDict(foo='bar')
-        >>> headers.add('Foo', 'baz')
-        >>> headers['foo']
-        'bar, baz'
-        """
-        key_lower = key.lower()
-        new_vals = key, val
-        # Keep the common case aka no item present as fast as possible
-        vals = self._container.setdefault(key_lower, new_vals)
-        if new_vals is not vals:
-            # new_vals was not inserted, as there was a previous one
-            if isinstance(vals, list):
-                # If already several items got inserted, we have a list
-                vals.append(val)
-            else:
-                # vals should be a tuple then, i.e. only one item so far
-                # Need to convert the tuple to list for further extension
-                self._container[key_lower] = [vals[0], vals[1], val]
-
-    def extend(self, *args, **kwargs):
-        """Generic import function for any type of header-like object.
-        Adapted version of MutableMapping.update in order to insert items
-        with self.add instead of self.__setitem__
-        """
-        if len(args) > 1:
-            raise TypeError("extend() takes at most 1 positional "
-                            "arguments ({} given)".format(len(args)))
-        other = args[0] if len(args) >= 1 else ()
-
-        if isinstance(other, HTTPHeaderDict):
-            for key, val in other.iteritems():
-                self.add(key, val)
-        elif isinstance(other, Mapping):
-            for key in other:
-                self.add(key, other[key])
-        elif hasattr(other, "keys"):
-            for key in other.keys():
-                self.add(key, other[key])
-        else:
-            for key, value in other:
-                self.add(key, value)
-
-        for key, value in kwargs.items():
-            self.add(key, value)
-
-    def getlist(self, key):
-        """Returns a list of all the values for the named field. Returns an
-        empty list if the key doesn't exist."""
-        try:
-            vals = self._container[key.lower()]
-        except KeyError:
-            return []
-        else:
-            if isinstance(vals, tuple):
-                return [vals[1]]
-            else:
-                return vals[1:]
-
-    # Backwards compatibility for httplib
-    getheaders = getlist
-    getallmatchingheaders = getlist
-    iget = getlist
-
-    def __repr__(self):
-        return "%s(%s)" % (type(self).__name__, dict(self.itermerged()))
-
-    def _copy_from(self, other):
-        for key in other:
-            val = other.getlist(key)
-            if isinstance(val, list):
-                # Don't need to convert tuples
-                val = list(val)
-            self._container[key.lower()] = [key] + val
-
-    def copy(self):
-        clone = type(self)()
-        clone._copy_from(self)
-        return clone
-
-    def iteritems(self):
-        """Iterate over all header lines, including duplicate ones."""
-        for key in self:
-            vals = self._container[key.lower()]
-            for val in vals[1:]:
-                yield vals[0], val
-
-    def itermerged(self):
-        """Iterate over all headers, merging duplicate ones together."""
-        for key in self:
-            val = self._container[key.lower()]
-            yield val[0], ', '.join(val[1:])
-
-    def items(self):
-        return list(self.iteritems())
-
-    @classmethod
-    def from_httplib(cls, message):  # Python 2
-        """Read headers from a Python 2 httplib message object."""
-        # python2.7 does not expose a proper API for exporting multiheaders
-        # efficiently. This function re-reads raw lines from the message
-        # object and extracts the multiheaders properly.
-        headers = []
-
-        for line in message.headers:
-            if line.startswith((' ', '\t')):
-                key, value = headers[-1]
-                headers[-1] = (key, value + '\r\n' + line.rstrip())
-                continue
-
-            key, value = line.split(':', 1)
-            headers.append((key, value.strip()))
-
-        return cls(headers)
-
-
-__all__ = (
-    'basestring',
-    'connection',
-    'fields',
-    'filepost',
-    'poolmanager',
-    'timeout',
-    'HTTPHeaderDict',
-    'queue',
-    'urlencode',
-    'urljoin',
-)

venv/Lib/site-packages/requests_toolbelt/adapters/__init__.py

@@ -1,15 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-requests-toolbelt.adapters
-==========================
-
-See https://toolbelt.readthedocs.io/ for documentation
-
-:copyright: (c) 2014 by Ian Cordasco and Cory Benfield
-:license: Apache v2.0, see LICENSE for more details
-"""
-
-from .ssl import SSLAdapter
-from .source import SourceAddressAdapter
-
-__all__ = ['SSLAdapter', 'SourceAddressAdapter']

venv/Lib/site-packages/requests_toolbelt/adapters/appengine.py

@@ -1,206 +0,0 @@
-# -*- coding: utf-8 -*-
-"""The App Engine Transport Adapter for requests.
-
-.. versionadded:: 0.6.0
-
-This requires a version of requests >= 2.10.0 and Python 2.
-
-There are two ways to use this library:
-
-#. If you're using requests directly, you can use code like:
-
-   .. code-block:: python
-
-       >>> import requests
-       >>> import ssl
-       >>> import requests.packages.urllib3.contrib.appengine as ul_appengine
-       >>> from requests_toolbelt.adapters import appengine
-       >>> s = requests.Session()
-       >>> if ul_appengine.is_appengine_sandbox():
-       ...    s.mount('http://', appengine.AppEngineAdapter())
-       ...    s.mount('https://', appengine.AppEngineAdapter())
-
-#. If you depend on external libraries which use requests, you can use code
-   like:
-
-   .. code-block:: python
-
-       >>> from requests_toolbelt.adapters import appengine
-       >>> appengine.monkeypatch()
-
-which will ensure all requests.Session objects use AppEngineAdapter properly.
-
-You are also able to :ref:`disable certificate validation <insecure_appengine>`
-when monkey-patching.
-"""
-import requests
-import warnings
-from requests import adapters
-from requests import sessions
-
-from .. import exceptions as exc
-from .._compat import gaecontrib
-from .._compat import timeout
-
-
-class AppEngineMROHack(adapters.HTTPAdapter):
-    """Resolves infinite recursion when monkeypatching.
-
-    This works by injecting itself as the base class of both the
-    :class:`AppEngineAdapter` and Requests' default HTTPAdapter, which needs to
-    be done because default HTTPAdapter's MRO is recompiled when we
-    monkeypatch, at which point this class becomes HTTPAdapter's base class.
-    In addition, we use an instantiation flag to avoid infinite recursion.
-    """
-    _initialized = False
-
-    def __init__(self, *args, **kwargs):
-        if not self._initialized:
-            self._initialized = True
-            super(AppEngineMROHack, self).__init__(*args, **kwargs)
-
-
-class AppEngineAdapter(AppEngineMROHack, adapters.HTTPAdapter):
-    """The transport adapter for Requests to use urllib3's GAE support.
-
-    Implements Requests's HTTPAdapter API.
-
-    When deploying to Google's App Engine service, some of Requests'
-    functionality is broken. There is underlying support for GAE in urllib3.
-    This functionality, however, is opt-in and needs to be enabled explicitly
-    for Requests to be able to use it.
-    """
-
-    __attrs__ = adapters.HTTPAdapter.__attrs__ + ['_validate_certificate']
-
-    def __init__(self, validate_certificate=True, *args, **kwargs):
-        _check_version()
-        self._validate_certificate = validate_certificate
-        super(AppEngineAdapter, self).__init__(*args, **kwargs)
-
-    def init_poolmanager(self, connections, maxsize, block=False):
-        self.poolmanager = _AppEnginePoolManager(self._validate_certificate)
-
-
-class InsecureAppEngineAdapter(AppEngineAdapter):
-    """An always-insecure GAE adapter for Requests.
-
-    This is a variant of the the transport adapter for Requests to use
-    urllib3's GAE support that does not validate certificates. Use with
-    caution!
-
-    .. note::
-        The ``validate_certificate`` keyword argument will not be honored here
-        and is not part of the signature because we always force it to
-        ``False``.
-
-    See :class:`AppEngineAdapter` for further details.
-    """
-
-    def __init__(self, *args, **kwargs):
-        if kwargs.pop("validate_certificate", False):
-            warnings.warn("Certificate validation cannot be specified on the "
-                          "InsecureAppEngineAdapter, but was present. This "
-                          "will be ignored and certificate validation will "
-                          "remain off.", exc.IgnoringGAECertificateValidation)
-
-        super(InsecureAppEngineAdapter, self).__init__(
-            validate_certificate=False, *args, **kwargs)
-
-
-class _AppEnginePoolManager(object):
-    """Implements urllib3's PoolManager API expected by requests.
-
-    While a real PoolManager map hostnames to reusable Connections,
-    AppEngine has no concept of a reusable connection to a host.
-    So instead, this class constructs a small Connection per request,
-    that is returned to the Adapter and used to access the URL.
-    """
-
-    def __init__(self, validate_certificate=True):
-        self.appengine_manager = gaecontrib.AppEngineManager(
-            validate_certificate=validate_certificate)
-
-    def connection_from_url(self, url):
-        return _AppEngineConnection(self.appengine_manager, url)
-
-    def clear(self):
-        pass
-
-
-class _AppEngineConnection(object):
-    """Implements urllib3's HTTPConnectionPool API's urlopen().
-
-    This Connection's urlopen() is called with a host-relative path,
-    so in order to properly support opening the URL, we need to store
-    the full URL when this Connection is constructed from the PoolManager.
-
-    This code wraps AppEngineManager.urlopen(), which exposes a different
-    API than in the original urllib3 urlopen(), and thus needs this adapter.
-    """
-
-    def __init__(self, appengine_manager, url):
-        self.appengine_manager = appengine_manager
-        self.url = url
-
-    def urlopen(self, method, url, body=None, headers=None, retries=None,
-                redirect=True, assert_same_host=True,
-                timeout=timeout.Timeout.DEFAULT_TIMEOUT,
-                pool_timeout=None, release_conn=None, **response_kw):
-        # This function's url argument is a host-relative URL,
-        # but the AppEngineManager expects an absolute URL.
-        # So we saved out the self.url when the AppEngineConnection
-        # was constructed, which we then can use down below instead.
-
-        # We once tried to verify our assumptions here, but sometimes the
-        # passed-in URL differs on url fragments, or "http://a.com" vs "/".
-
-        # urllib3's App Engine adapter only uses Timeout.total, not read or
-        # connect.
-        if not timeout.total:
-            timeout.total = timeout._read or timeout._connect
-
-        # Jump through the hoops necessary to call AppEngineManager's API.
-        return self.appengine_manager.urlopen(
-            method,
-            self.url,
-            body=body,
-            headers=headers,
-            retries=retries,
-            redirect=redirect,
-            timeout=timeout,
-            **response_kw)
-
-
-def monkeypatch(validate_certificate=True):
-    """Sets up all Sessions to use AppEngineAdapter by default.
-
-    If you don't want to deal with configuring your own Sessions,
-    or if you use libraries that use requests directly (ie requests.post),
-    then you may prefer to monkeypatch and auto-configure all Sessions.
-
-    .. warning: :
-
-        If ``validate_certificate`` is ``False``, certification validation will
-        effectively be disabled for all requests.
-    """
-    _check_version()
-    # HACK: We should consider modifying urllib3 to support this cleanly,
-    # so that we can set a module-level variable in the sessions module,
-    # instead of overriding an imported HTTPAdapter as is done here.
-    adapter = AppEngineAdapter
-    if not validate_certificate:
-        adapter = InsecureAppEngineAdapter
-
-    sessions.HTTPAdapter = adapter
-    adapters.HTTPAdapter = adapter
-
-
-def _check_version():
-    if gaecontrib is None:
-        raise exc.VersionMismatchError(
-            "The toolbelt requires at least Requests 2.10.0 to be "
-            "installed. Version {} was found instead.".format(
-                requests.__version__
-            )
-        )

venv/Lib/site-packages/requests_toolbelt/adapters/fingerprint.py

@@ -1,48 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Submodule containing the implementation for the FingerprintAdapter.
-
-This file contains an implementation of a Transport Adapter that validates
-the fingerprints of SSL certificates presented upon connection.
-"""
-from requests.adapters import HTTPAdapter
-
-from .._compat import poolmanager
-
-
-class FingerprintAdapter(HTTPAdapter):
-    """
-    A HTTPS Adapter for Python Requests that verifies certificate fingerprints,
-    instead of certificate hostnames.
-
-    Example usage:
-
-    .. code-block:: python
-
-        import requests
-        import ssl
-        from requests_toolbelt.adapters.fingerprint import FingerprintAdapter
-
-        twitter_fingerprint = '...'
-        s = requests.Session()
-        s.mount(
-            'https://twitter.com',
-            FingerprintAdapter(twitter_fingerprint)
-        )
-
-    The fingerprint should be provided as a hexadecimal string, optionally
-    containing colons.
-    """
-
-    __attrs__ = HTTPAdapter.__attrs__ + ['fingerprint']
-
-    def __init__(self, fingerprint, **kwargs):
-        self.fingerprint = fingerprint
-
-        super(FingerprintAdapter, self).__init__(**kwargs)
-
-    def init_poolmanager(self, connections, maxsize, block=False):
-        self.poolmanager = poolmanager.PoolManager(
-            num_pools=connections,
-            maxsize=maxsize,
-            block=block,
-            assert_fingerprint=self.fingerprint)

venv/Lib/site-packages/requests_toolbelt/adapters/host_header_ssl.py

@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-requests_toolbelt.adapters.host_header_ssl
-==========================================
-
-This file contains an implementation of the HostHeaderSSLAdapter.
-"""
-
-from requests.adapters import HTTPAdapter
-
-
-class HostHeaderSSLAdapter(HTTPAdapter):
-    """
-    A HTTPS Adapter for Python Requests that sets the hostname for certificate
-    verification based on the Host header.
-
-    This allows requesting the IP address directly via HTTPS without getting
-    a "hostname doesn't match" exception.
-
-    Example usage:
-
-        >>> s.mount('https://', HostHeaderSSLAdapter())
-        >>> s.get("https://93.184.216.34", headers={"Host": "example.org"})
-
-    """
-
-    def send(self, request, **kwargs):
-        # HTTP headers are case-insensitive (RFC 7230)
-        host_header = None
-        for header in request.headers:
-            if header.lower() == "host":
-                host_header = request.headers[header]
-                break
-
-        connection_pool_kwargs = self.poolmanager.connection_pool_kw
-
-        if host_header:
-            connection_pool_kwargs["assert_hostname"] = host_header
-        elif "assert_hostname" in connection_pool_kwargs:
-            # an assert_hostname from a previous request may have been left
-            connection_pool_kwargs.pop("assert_hostname", None)
-
-        return super(HostHeaderSSLAdapter, self).send(request, **kwargs)