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

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

@@ -1,129 +0,0 @@
-# -*- coding: utf-8 -*-
-"""The implementation of the SocketOptionsAdapter."""
-import socket
-import warnings
-import sys
-
-import requests
-from requests import adapters
-
-from .._compat import connection
-from .._compat import poolmanager
-from .. import exceptions as exc
-
-
-class SocketOptionsAdapter(adapters.HTTPAdapter):
-    """An adapter for requests that allows users to specify socket options.
-
-    Since version 2.4.0 of requests, it is possible to specify a custom list
-    of socket options that need to be set before establishing the connection.
-
-    Example usage::
-
-        >>> import socket
-        >>> import requests
-        >>> from requests_toolbelt.adapters import socket_options
-        >>> s = requests.Session()
-        >>> opts = [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 0)]
-        >>> adapter = socket_options.SocketOptionsAdapter(socket_options=opts)
-        >>> s.mount('http://', adapter)
-
-    You can also take advantage of the list of default options on this class
-    to keep using the original options in addition to your custom options. In
-    that case, ``opts`` might look like::
-
-        >>> opts = socket_options.SocketOptionsAdapter.default_options + opts
-
-    """
-
-    if connection is not None:
-        default_options = getattr(
-            connection.HTTPConnection,
-            'default_socket_options',
-            [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]
-        )
-    else:
-        default_options = []
-        warnings.warn(exc.RequestsVersionTooOld,
-                      "This version of Requests is only compatible with a "
-                      "version of urllib3 which is too old to support "
-                      "setting options on a socket. This adapter is "
-                      "functionally useless.")
-
-    def __init__(self, **kwargs):
-        self.socket_options = kwargs.pop('socket_options',
-                                         self.default_options)
-
-        super(SocketOptionsAdapter, self).__init__(**kwargs)
-
-    def init_poolmanager(self, connections, maxsize, block=False):
-        if requests.__build__ >= 0x020400:
-            # NOTE(Ian): Perhaps we should raise a warning
-            self.poolmanager = poolmanager.PoolManager(
-                num_pools=connections,
-                maxsize=maxsize,
-                block=block,
-                socket_options=self.socket_options
-            )
-        else:
-            super(SocketOptionsAdapter, self).init_poolmanager(
-                connections, maxsize, block
-            )
-
-
-class TCPKeepAliveAdapter(SocketOptionsAdapter):
-    """An adapter for requests that turns on TCP Keep-Alive by default.
-
-    The adapter sets 4 socket options:
-
-    - ``SOL_SOCKET`` ``SO_KEEPALIVE`` - This turns on TCP Keep-Alive
-    - ``IPPROTO_TCP`` ``TCP_KEEPINTVL`` 20 - Sets the keep alive interval
-    - ``IPPROTO_TCP`` ``TCP_KEEPCNT`` 5 - Sets the number of keep alive probes
-    - ``IPPROTO_TCP`` ``TCP_KEEPIDLE`` 60 - Sets the keep alive time if the
-      socket library has the ``TCP_KEEPIDLE`` constant
-
-    The latter three can be overridden by keyword arguments (respectively):
-
-    - ``interval``
-    - ``count``
-    - ``idle``
-
-    You can use this adapter like so::
-
-       >>> from requests_toolbelt.adapters import socket_options
-       >>> tcp = socket_options.TCPKeepAliveAdapter(idle=120, interval=10)
-       >>> s = requests.Session()
-       >>> s.mount('http://', tcp)
-
-    """
-
-    def __init__(self, **kwargs):
-        socket_options = kwargs.pop('socket_options',
-                                    SocketOptionsAdapter.default_options)
-        idle = kwargs.pop('idle', 60)
-        interval = kwargs.pop('interval', 20)
-        count = kwargs.pop('count', 5)
-        socket_options = socket_options + [
-            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-        ]
-
-        # NOTE(Ian): OSX does not have these constants defined, so we
-        # set them conditionally.
-        if getattr(socket, 'TCP_KEEPINTVL', None) is not None:
-            socket_options += [(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL,
-                                interval)]
-        elif sys.platform == 'darwin':
-            # On OSX, TCP_KEEPALIVE from netinet/tcp.h is not exported
-            # by python's socket module
-            TCP_KEEPALIVE = getattr(socket, 'TCP_KEEPALIVE', 0x10)
-            socket_options += [(socket.IPPROTO_TCP, TCP_KEEPALIVE, interval)]
-
-        if getattr(socket, 'TCP_KEEPCNT', None) is not None:
-            socket_options += [(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, count)]
-
-        if getattr(socket, 'TCP_KEEPIDLE', None) is not None:
-            socket_options += [(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, idle)]
-
-        super(TCPKeepAliveAdapter, self).__init__(
-            socket_options=socket_options, **kwargs
-        )

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

@@ -1,67 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-requests_toolbelt.source_adapter
-================================
-
-This file contains an implementation of the SourceAddressAdapter originally
-demonstrated on the Requests GitHub page.
-"""
-from requests.adapters import HTTPAdapter
-
-from .._compat import poolmanager, basestring
-
-
-class SourceAddressAdapter(HTTPAdapter):
-    """
-    A Source Address Adapter for Python Requests that enables you to choose the
-    local address to bind to. This allows you to send your HTTP requests from a
-    specific interface and IP address.
-
-    Two address formats are accepted. The first is a string: this will set the
-    local IP address to the address given in the string, and will also choose a
-    semi-random high port for the local port number.
-
-    The second is a two-tuple of the form (ip address, port): for example,
-    ``('10.10.10.10', 8999)``. This will set the local IP address to the first
-    element, and the local port to the second element. If ``0`` is used as the
-    port number, a semi-random high port will be selected.
-
-    .. warning:: Setting an explicit local port can have negative interactions
-                 with connection-pooling in Requests: in particular, it risks
-                 the possibility of getting "Address in use" errors. The
-                 string-only argument is generally preferred to the tuple-form.
-
-    Example usage:
-
-    .. code-block:: python
-
-        import requests
-        from requests_toolbelt.adapters.source import SourceAddressAdapter
-
-        s = requests.Session()
-        s.mount('http://', SourceAddressAdapter('10.10.10.10'))
-        s.mount('https://', SourceAddressAdapter(('10.10.10.10', 8999)))
-    """
-    def __init__(self, source_address, **kwargs):
-        if isinstance(source_address, basestring):
-            self.source_address = (source_address, 0)
-        elif isinstance(source_address, tuple):
-            self.source_address = source_address
-        else:
-            raise TypeError(
-                "source_address must be IP address string or (ip, port) tuple"
-            )
-
-        super(SourceAddressAdapter, self).__init__(**kwargs)
-
-    def init_poolmanager(self, connections, maxsize, block=False):
-        self.poolmanager = poolmanager.PoolManager(
-            num_pools=connections,
-            maxsize=maxsize,
-            block=block,
-            source_address=self.source_address)
-
-    def proxy_manager_for(self, *args, **kwargs):
-        kwargs['source_address'] = self.source_address
-        return super(SourceAddressAdapter, self).proxy_manager_for(
-            *args, **kwargs)

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

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-
-requests_toolbelt.ssl_adapter
-=============================
-
-This file contains an implementation of the SSLAdapter originally demonstrated
-in this blog post:
-https://lukasa.co.uk/2013/01/Choosing_SSL_Version_In_Requests/
-
-"""
-import requests
-
-from requests.adapters import HTTPAdapter
-
-from .._compat import poolmanager
-
-
-class SSLAdapter(HTTPAdapter):
-    """
-    A HTTPS Adapter for Python Requests that allows the choice of the SSL/TLS
-    version negotiated by Requests. This can be used either to enforce the
-    choice of high-security TLS versions (where supported), or to work around
-    misbehaving servers that fail to correctly negotiate the default TLS
-    version being offered.
-
-    Example usage:
-
-        >>> import requests
-        >>> import ssl
-        >>> from requests_toolbelt import SSLAdapter
-        >>> s = requests.Session()
-        >>> s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
-
-    You can replace the chosen protocol with any that are available in the
-    default Python SSL module. All subsequent requests that match the adapter
-    prefix will use the chosen SSL version instead of the default.
-
-    This adapter will also attempt to change the SSL/TLS version negotiated by
-    Requests when using a proxy. However, this may not always be possible:
-    prior to Requests v2.4.0 the adapter did not have access to the proxy setup
-    code. In earlier versions of Requests, this adapter will not function
-    properly when used with proxies.
-    """
-
-    __attrs__ = HTTPAdapter.__attrs__ + ['ssl_version']
-
-    def __init__(self, ssl_version=None, **kwargs):
-        self.ssl_version = ssl_version
-
-        super(SSLAdapter, self).__init__(**kwargs)
-
-    def init_poolmanager(self, connections, maxsize, block=False):
-        self.poolmanager = poolmanager.PoolManager(
-            num_pools=connections,
-            maxsize=maxsize,
-            block=block,
-            ssl_version=self.ssl_version)
-
-    if requests.__build__ >= 0x020400:
-        # Earlier versions of requests either don't have this method or, worse,
-        # don't allow passing arbitrary keyword arguments. As a result, only
-        # conditionally define this method.
-        def proxy_manager_for(self, *args, **kwargs):
-            kwargs['ssl_version'] = self.ssl_version
-            return super(SSLAdapter, self).proxy_manager_for(*args, **kwargs)

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

@@ -1,196 +0,0 @@
-# -*- coding: utf-8 -*-
-"""A X509Adapter for use with the requests library.
-
-This file contains an implementation of the X509Adapter that will
-allow users to authenticate a request using an arbitrary
-X.509 certificate without needing to convert it to a .pem file
-
-"""
-
-from OpenSSL.crypto import PKey, X509
-from cryptography import x509
-from cryptography.hazmat.primitives.serialization import (load_pem_private_key,
-                                                          load_der_private_key)
-from cryptography.hazmat.primitives.serialization import Encoding
-from cryptography.hazmat.backends import default_backend
-
-from datetime import datetime
-from requests.adapters import HTTPAdapter
-import requests
-
-from .. import exceptions as exc
-
-"""
-importing the protocol constants from _ssl instead of ssl because only the
-constants are needed and to handle issues caused by importing from ssl on
-the 2.7.x line.
-"""
-try:
-    from _ssl import PROTOCOL_TLS as PROTOCOL
-except ImportError:
-    from _ssl import PROTOCOL_SSLv23 as PROTOCOL
-
-
-PyOpenSSLContext = None
-
-
-class X509Adapter(HTTPAdapter):
-    r"""Adapter for use with X.509 certificates.
-
-    Provides an interface for Requests sessions to contact HTTPS urls and
-    authenticate  with an X.509 cert by implementing the Transport Adapter
-    interface. This class will need to be manually instantiated and mounted
-    to the session
-
-    :param pool_connections: The number of urllib3 connection pools to
-           cache.
-    :param pool_maxsize: The maximum number of connections to save in the
-            pool.
-    :param max_retries: The maximum number of retries each connection
-        should attempt. Note, this applies only to failed DNS lookups,
-        socket connections and connection timeouts, never to requests where
-        data has made it to the server. By default, Requests does not retry
-        failed connections. If you need granular control over the
-        conditions under which we retry a request, import urllib3's
-        ``Retry`` class and pass that instead.
-    :param pool_block: Whether the connection pool should block for
-            connections.
-
-    :param bytes cert_bytes:
-        bytes object containing contents of a cryptography.x509Certificate
-        object using the encoding specified by the ``encoding`` parameter.
-    :param bytes pk_bytes:
-        bytes object containing contents of a object that implements
-        ``cryptography.hazmat.primitives.serialization.PrivateFormat``
-        using the encoding specified by the ``encoding`` parameter.
-    :param password:
-        string or utf8 encoded bytes containing the passphrase used for the
-        private key. None if unencrypted. Defaults to None.
-    :param encoding:
-        Enumeration detailing the encoding method used on the ``cert_bytes``
-        parameter. Can be either PEM or DER. Defaults to PEM.
-    :type encoding:
-        :class: `cryptography.hazmat.primitives.serialization.Encoding`
-
-    Usage::
-
-      >>> import requests
-      >>> from requests_toolbelt.adapters.x509 import X509Adapter
-      >>> s = requests.Session()
-      >>> a = X509Adapter(max_retries=3,
-                cert_bytes=b'...', pk_bytes=b'...', encoding='...'
-      >>> s.mount('https://', a)
-    """
-
-    def __init__(self, *args, **kwargs):
-        self._import_pyopensslcontext()
-        self._check_version()
-        cert_bytes = kwargs.pop('cert_bytes', None)
-        pk_bytes = kwargs.pop('pk_bytes', None)
-        password = kwargs.pop('password', None)
-        encoding = kwargs.pop('encoding', Encoding.PEM)
-
-        password_bytes = None
-
-        if cert_bytes is None or not isinstance(cert_bytes, bytes):
-            raise ValueError('Invalid cert content provided. '
-                             'You must provide an X.509 cert '
-                             'formatted as a byte array.')
-        if pk_bytes is None or not isinstance(pk_bytes, bytes):
-            raise ValueError('Invalid private key content provided. '
-                             'You must provide a private key '
-                             'formatted as a byte array.')
-
-        if isinstance(password, bytes):
-            password_bytes = password
-        elif password:
-            password_bytes = password.encode('utf8')
-
-        self.ssl_context = create_ssl_context(cert_bytes, pk_bytes,
-                                              password_bytes, encoding)
-
-        super(X509Adapter, self).__init__(*args, **kwargs)
-
-    def init_poolmanager(self, *args, **kwargs):
-        if self.ssl_context:
-            kwargs['ssl_context'] = self.ssl_context
-        return super(X509Adapter, self).init_poolmanager(*args, **kwargs)
-
-    def proxy_manager_for(self, *args, **kwargs):
-        if self.ssl_context:
-            kwargs['ssl_context'] = self.ssl_context
-        return super(X509Adapter, self).proxy_manager_for(*args, **kwargs)
-
-    def _import_pyopensslcontext(self):
-        global PyOpenSSLContext
-
-        if requests.__build__ < 0x021200:
-            PyOpenSSLContext = None
-        else:
-            try:
-                from requests.packages.urllib3.contrib.pyopenssl \
-                        import PyOpenSSLContext
-            except ImportError:
-                try:
-                    from urllib3.contrib.pyopenssl import PyOpenSSLContext
-                except ImportError:
-                    PyOpenSSLContext = None
-
-    def _check_version(self):
-        if PyOpenSSLContext is None:
-            raise exc.VersionMismatchError(
-                "The X509Adapter requires at least Requests 2.12.0 to be "
-                "installed. Version {} was found instead.".format(
-                    requests.__version__
-                )
-            )
-
-
-def check_cert_dates(cert):
-    """Verify that the supplied client cert is not invalid."""
-
-    now = datetime.utcnow()
-    if cert.not_valid_after < now or cert.not_valid_before > now:
-        raise ValueError('Client certificate expired: Not After: '
-                         '{:%Y-%m-%d %H:%M:%SZ} '
-                         'Not Before: {:%Y-%m-%d %H:%M:%SZ}'
-                         .format(cert.not_valid_after, cert.not_valid_before))
-
-
-def create_ssl_context(cert_byes, pk_bytes, password=None,
-                       encoding=Encoding.PEM):
-    """Create an SSL Context with the supplied cert/password.
-
-    :param cert_bytes array of bytes containing the cert encoded
-           using the method supplied in the ``encoding`` parameter
-    :param pk_bytes array of bytes containing the private key encoded
-           using the method supplied in the ``encoding`` parameter
-    :param password array of bytes containing the passphrase to be used
-           with the supplied private key. None if unencrypted.
-           Defaults to None.
-    :param encoding ``cryptography.hazmat.primitives.serialization.Encoding``
-            details the encoding method used on the ``cert_bytes``  and
-            ``pk_bytes`` parameters. Can be either PEM or DER.
-            Defaults to PEM.
-    """
-    backend = default_backend()
-
-    cert = None
-    key = None
-    if encoding == Encoding.PEM:
-        cert = x509.load_pem_x509_certificate(cert_byes, backend)
-        key = load_pem_private_key(pk_bytes, password, backend)
-    elif encoding == Encoding.DER:
-        cert = x509.load_der_x509_certificate(cert_byes, backend)
-        key = load_der_private_key(pk_bytes, password, backend)
-    else:
-        raise ValueError('Invalid encoding provided: Must be PEM or DER')
-
-    if not (cert and key):
-        raise ValueError('Cert and key could not be parsed from '
-                         'provided data')
-    check_cert_dates(cert)
-    ssl_context = PyOpenSSLContext(PROTOCOL)
-    ssl_context._ctx.use_certificate(X509.from_cryptography(cert))
-    ssl_context._ctx.use_privatekey(PKey.from_cryptography_key(key))
-    return ssl_context

venv/Lib/site-packages/requests_toolbelt/auth/_digest_auth_compat.py

@@ -1,29 +0,0 @@
-"""Provide a compatibility layer for requests.auth.HTTPDigestAuth."""
-import requests
-
-
-class _ThreadingDescriptor(object):
-    def __init__(self, prop, default):
-        self.prop = prop
-        self.default = default
-
-    def __get__(self, obj, objtype=None):
-        return getattr(obj._thread_local, self.prop, self.default)
-
-    def __set__(self, obj, value):
-        setattr(obj._thread_local, self.prop, value)
-
-
-class _HTTPDigestAuth(requests.auth.HTTPDigestAuth):
-    init = _ThreadingDescriptor('init', True)
-    last_nonce = _ThreadingDescriptor('last_nonce', '')
-    nonce_count = _ThreadingDescriptor('nonce_count', 0)
-    chal = _ThreadingDescriptor('chal', {})
-    pos = _ThreadingDescriptor('pos', None)
-    num_401_calls = _ThreadingDescriptor('num_401_calls', 1)
-
-
-if requests.__build__ < 0x020800:
-    HTTPDigestAuth = requests.auth.HTTPDigestAuth
-else:
-    HTTPDigestAuth = _HTTPDigestAuth

venv/Lib/site-packages/requests_toolbelt/auth/guess.py

@@ -1,146 +0,0 @@
-# -*- coding: utf-8 -*-
-"""The module containing the code for GuessAuth."""
-from requests import auth
-from requests import cookies
-
-from . import _digest_auth_compat as auth_compat, http_proxy_digest
-
-
-class GuessAuth(auth.AuthBase):
-    """Guesses the auth type by the WWW-Authentication header."""
-    def __init__(self, username, password):
-        self.username = username
-        self.password = password
-        self.auth = None
-        self.pos = None
-
-    def _handle_basic_auth_401(self, r, kwargs):
-        if self.pos is not None:
-            r.request.body.seek(self.pos)
-
-        # Consume content and release the original connection
-        # to allow our new request to reuse the same one.
-        r.content
-        r.raw.release_conn()
-        prep = r.request.copy()
-        if not hasattr(prep, '_cookies'):
-            prep._cookies = cookies.RequestsCookieJar()
-        cookies.extract_cookies_to_jar(prep._cookies, r.request, r.raw)
-        prep.prepare_cookies(prep._cookies)
-
-        self.auth = auth.HTTPBasicAuth(self.username, self.password)
-        prep = self.auth(prep)
-        _r = r.connection.send(prep, **kwargs)
-        _r.history.append(r)
-        _r.request = prep
-
-        return _r
-
-    def _handle_digest_auth_401(self, r, kwargs):
-        self.auth = auth_compat.HTTPDigestAuth(self.username, self.password)
-        try:
-            self.auth.init_per_thread_state()
-        except AttributeError:
-            # If we're not on requests 2.8.0+ this method does not exist and
-            # is not relevant.
-            pass
-
-        # Check that the attr exists because much older versions of requests
-        # set this attribute lazily. For example:
-        # https://github.com/kennethreitz/requests/blob/33735480f77891754304e7f13e3cdf83aaaa76aa/requests/auth.py#L59
-        if (hasattr(self.auth, 'num_401_calls') and
-                self.auth.num_401_calls is None):
-            self.auth.num_401_calls = 1
-        # Digest auth would resend the request by itself. We can take a
-        # shortcut here.
-        return self.auth.handle_401(r, **kwargs)
-
-    def handle_401(self, r, **kwargs):
-        """Resends a request with auth headers, if needed."""
-
-        www_authenticate = r.headers.get('www-authenticate', '').lower()
-
-        if 'basic' in www_authenticate:
-            return self._handle_basic_auth_401(r, kwargs)
-
-        if 'digest' in www_authenticate:
-            return self._handle_digest_auth_401(r, kwargs)
-
-    def __call__(self, request):
-        if self.auth is not None:
-            return self.auth(request)
-
-        try:
-            self.pos = request.body.tell()
-        except AttributeError:
-            pass
-
-        request.register_hook('response', self.handle_401)
-        return request
-
-
-class GuessProxyAuth(GuessAuth):
-    """
-    Guesses the auth type by WWW-Authentication and Proxy-Authentication
-    headers
-    """
-    def __init__(self, username=None, password=None,
-                 proxy_username=None, proxy_password=None):
-        super(GuessProxyAuth, self).__init__(username, password)
-        self.proxy_username = proxy_username
-        self.proxy_password = proxy_password
-        self.proxy_auth = None
-
-    def _handle_basic_auth_407(self, r, kwargs):
-        if self.pos is not None:
-            r.request.body.seek(self.pos)
-
-        r.content
-        r.raw.release_conn()
-        prep = r.request.copy()
-        if not hasattr(prep, '_cookies'):
-            prep._cookies = cookies.RequestsCookieJar()
-        cookies.extract_cookies_to_jar(prep._cookies, r.request, r.raw)
-        prep.prepare_cookies(prep._cookies)
-
-        self.proxy_auth = auth.HTTPProxyAuth(self.proxy_username,
-                                             self.proxy_password)
-        prep = self.proxy_auth(prep)
-        _r = r.connection.send(prep, **kwargs)
-        _r.history.append(r)
-        _r.request = prep
-
-        return _r
-
-    def _handle_digest_auth_407(self, r, kwargs):
-        self.proxy_auth = http_proxy_digest.HTTPProxyDigestAuth(
-            username=self.proxy_username,
-            password=self.proxy_password)
-
-        try:
-            self.auth.init_per_thread_state()
-        except AttributeError:
-            pass
-
-        return self.proxy_auth.handle_407(r, **kwargs)
-
-    def handle_407(self, r, **kwargs):
-        proxy_authenticate = r.headers.get('Proxy-Authenticate', '').lower()
-
-        if 'basic' in proxy_authenticate:
-            return self._handle_basic_auth_407(r, kwargs)
-
-        if 'digest' in proxy_authenticate:
-            return self._handle_digest_auth_407(r, kwargs)
-
-    def __call__(self, request):
-        if self.proxy_auth is not None:
-            request = self.proxy_auth(request)
-
-        try:
-            self.pos = request.body.tell()
-        except AttributeError:
-            pass
-
-        request.register_hook('response', self.handle_407)
-        return super(GuessProxyAuth, self).__call__(request)