@scrypted/arlo 0.11.26 → 0.11.27

package/venv/lib/python3.10/site-packages/urllib3/__init__.py

@@ -1,211 +0,0 @@
-"""
-Python HTTP library with thread-safe connection pooling, file post support, user friendly, and more
-"""
-
-from __future__ import annotations
-
-# Set default logging handler to avoid "No handler found" warnings.
-import logging
-import sys
-import typing
-import warnings
-from logging import NullHandler
-
-from . import exceptions
-from ._base_connection import _TYPE_BODY
-from ._collections import HTTPHeaderDict
-from ._version import __version__
-from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url
-from .filepost import _TYPE_FIELDS, encode_multipart_formdata
-from .poolmanager import PoolManager, ProxyManager, proxy_from_url
-from .response import BaseHTTPResponse, HTTPResponse
-from .util.request import make_headers
-from .util.retry import Retry
-from .util.timeout import Timeout
-
-# Ensure that Python is compiled with OpenSSL 1.1.1+
-# If the 'ssl' module isn't available at all that's
-# fine, we only care if the module is available.
-try:
-    import ssl
-except ImportError:
-    pass
-else:
-    if not ssl.OPENSSL_VERSION.startswith("OpenSSL "):  # Defensive:
-        warnings.warn(
-            "urllib3 v2 only supports OpenSSL 1.1.1+, currently "
-            f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. "
-            "See: https://github.com/urllib3/urllib3/issues/3020",
-            exceptions.NotOpenSSLWarning,
-        )
-    elif ssl.OPENSSL_VERSION_INFO < (1, 1, 1):  # Defensive:
-        raise ImportError(
-            "urllib3 v2 only supports OpenSSL 1.1.1+, currently "
-            f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. "
-            "See: https://github.com/urllib3/urllib3/issues/2168"
-        )
-
-__author__ = "Andrey Petrov (andrey.petrov@shazow.net)"
-__license__ = "MIT"
-__version__ = __version__
-
-__all__ = (
-    "HTTPConnectionPool",
-    "HTTPHeaderDict",
-    "HTTPSConnectionPool",
-    "PoolManager",
-    "ProxyManager",
-    "HTTPResponse",
-    "Retry",
-    "Timeout",
-    "add_stderr_logger",
-    "connection_from_url",
-    "disable_warnings",
-    "encode_multipart_formdata",
-    "make_headers",
-    "proxy_from_url",
-    "request",
-    "BaseHTTPResponse",
-)
-
-logging.getLogger(__name__).addHandler(NullHandler())
-
-
-def add_stderr_logger(
-    level: int = logging.DEBUG,
-) -> logging.StreamHandler[typing.TextIO]:
-    """
-    Helper for quickly adding a StreamHandler to the logger. Useful for
-    debugging.
-
-    Returns the handler after adding it.
-    """
-    # This method needs to be in this __init__.py to get the __name__ correct
-    # even if urllib3 is vendored within another package.
-    logger = logging.getLogger(__name__)
-    handler = logging.StreamHandler()
-    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
-    logger.addHandler(handler)
-    logger.setLevel(level)
-    logger.debug("Added a stderr logging handler to logger: %s", __name__)
-    return handler
-
-
-# ... Clean up.
-del NullHandler
-
-
-# All warning filters *must* be appended unless you're really certain that they
-# shouldn't be: otherwise, it's very hard for users to use most Python
-# mechanisms to silence them.
-# SecurityWarning's always go off by default.
-warnings.simplefilter("always", exceptions.SecurityWarning, append=True)
-# InsecurePlatformWarning's don't vary between requests, so we keep it default.
-warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True)
-
-
-def disable_warnings(category: type[Warning] = exceptions.HTTPWarning) -> None:
-    """
-    Helper for quickly disabling all urllib3 warnings.
-    """
-    warnings.simplefilter("ignore", category)
-
-
-_DEFAULT_POOL = PoolManager()
-
-
-def request(
-    method: str,
-    url: str,
-    *,
-    body: _TYPE_BODY | None = None,
-    fields: _TYPE_FIELDS | None = None,
-    headers: typing.Mapping[str, str] | None = None,
-    preload_content: bool | None = True,
-    decode_content: bool | None = True,
-    redirect: bool | None = True,
-    retries: Retry | bool | int | None = None,
-    timeout: Timeout | float | int | None = 3,
-    json: typing.Any | None = None,
-) -> BaseHTTPResponse:
-    """
-    A convenience, top-level request method. It uses a module-global ``PoolManager`` instance.
-    Therefore, its side effects could be shared across dependencies relying on it.
-    To avoid side effects create a new ``PoolManager`` instance and use it instead.
-    The method does not accept low-level ``**urlopen_kw`` keyword arguments.
-
-    :param method:
-        HTTP request method (such as GET, POST, PUT, etc.)
-
-    :param url:
-        The URL to perform the request on.
-
-    :param body:
-        Data to send in the request body, either :class:`str`, :class:`bytes`,
-        an iterable of :class:`str`/:class:`bytes`, or a file-like object.
-
-    :param fields:
-        Data to encode and send in the request body.
-
-    :param headers:
-        Dictionary of custom headers to send, such as User-Agent,
-        If-None-Match, etc.
-
-    :param bool preload_content:
-        If True, the response's body will be preloaded into memory.
-
-    :param bool decode_content:
-        If True, will attempt to decode the body based on the
-        'content-encoding' header.
-
-    :param redirect:
-        If True, automatically handle redirects (status codes 301, 302,
-        303, 307, 308). Each redirect counts as a retry. Disabling retries
-        will disable redirect, too.
-
-    :param retries:
-        Configure the number of retries to allow before raising a
-        :class:`~urllib3.exceptions.MaxRetryError` exception.
-
-        If ``None`` (default) will retry 3 times, see ``Retry.DEFAULT``. Pass a
-        :class:`~urllib3.util.retry.Retry` object for fine-grained control
-        over different types of retries.
-        Pass an integer number to retry connection errors that many times,
-        but no other types of errors. Pass zero to never retry.
-
-        If ``False``, then retries are disabled and any exception is raised
-        immediately. Also, instead of raising a MaxRetryError on redirects,
-        the redirect response will be returned.
-
-    :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.
-
-    :param timeout:
-        If specified, overrides the default timeout for this one
-        request. It may be a float (in seconds) or an instance of
-        :class:`urllib3.util.Timeout`.
-
-    :param json:
-        Data to encode and send as JSON with UTF-encoded in the request body.
-        The ``"Content-Type"`` header will be set to ``"application/json"``
-        unless specified otherwise.
-    """
-
-    return _DEFAULT_POOL.request(
-        method,
-        url,
-        body=body,
-        fields=fields,
-        headers=headers,
-        preload_content=preload_content,
-        decode_content=decode_content,
-        redirect=redirect,
-        retries=retries,
-        timeout=timeout,
-        json=json,
-    )
-
-
-if sys.platform == "emscripten":
-    from .contrib.emscripten import inject_into_urllib3  # noqa: 401
-
-    inject_into_urllib3()

package/venv/lib/python3.10/site-packages/urllib3/_base_connection.py

@@ -1,165 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .util.connection import _TYPE_SOCKET_OPTIONS
-from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT
-from .util.url import Url
-
-_TYPE_BODY = typing.Union[bytes, typing.IO[typing.Any], typing.Iterable[bytes], str]
-
-
-class ProxyConfig(typing.NamedTuple):
-    ssl_context: ssl.SSLContext | None
-    use_forwarding_for_https: bool
-    assert_hostname: None | str | typing.Literal[False]
-    assert_fingerprint: str | None
-
-
-class _ResponseOptions(typing.NamedTuple):
-    # TODO: Remove this in favor of a better
-    # HTTP request/response lifecycle tracking.
-    request_method: str
-    request_url: str
-    preload_content: bool
-    decode_content: bool
-    enforce_content_length: bool
-
-
-if typing.TYPE_CHECKING:
-    import ssl
-    from typing import Protocol
-
-    from .response import BaseHTTPResponse
-
-    class BaseHTTPConnection(Protocol):
-        default_port: typing.ClassVar[int]
-        default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS]
-
-        host: str
-        port: int
-        timeout: None | (
-            float
-        )  # Instance doesn't store _DEFAULT_TIMEOUT, must be resolved.
-        blocksize: int
-        source_address: tuple[str, int] | None
-        socket_options: _TYPE_SOCKET_OPTIONS | None
-
-        proxy: Url | None
-        proxy_config: ProxyConfig | None
-
-        is_verified: bool
-        proxy_is_verified: bool | None
-
-        def __init__(
-            self,
-            host: str,
-            port: int | None = None,
-            *,
-            timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
-            source_address: tuple[str, int] | None = None,
-            blocksize: int = 8192,
-            socket_options: _TYPE_SOCKET_OPTIONS | None = ...,
-            proxy: Url | None = None,
-            proxy_config: ProxyConfig | None = None,
-        ) -> None: ...
-
-        def set_tunnel(
-            self,
-            host: str,
-            port: int | None = None,
-            headers: typing.Mapping[str, str] | None = None,
-            scheme: str = "http",
-        ) -> None: ...
-
-        def connect(self) -> None: ...
-
-        def request(
-            self,
-            method: str,
-            url: str,
-            body: _TYPE_BODY | None = None,
-            headers: typing.Mapping[str, str] | None = None,
-            # We know *at least* botocore is depending on the order of the
-            # first 3 parameters so to be safe we only mark the later ones
-            # as keyword-only to ensure we have space to extend.
-            *,
-            chunked: bool = False,
-            preload_content: bool = True,
-            decode_content: bool = True,
-            enforce_content_length: bool = True,
-        ) -> None: ...
-
-        def getresponse(self) -> BaseHTTPResponse: ...
-
-        def close(self) -> None: ...
-
-        @property
-        def is_closed(self) -> bool:
-            """Whether the connection either is brand new or has been previously closed.
-            If this property is True then both ``is_connected`` and ``has_connected_to_proxy``
-            properties must be False.
-            """
-
-        @property
-        def is_connected(self) -> bool:
-            """Whether the connection is actively connected to any origin (proxy or target)"""
-
-        @property
-        def has_connected_to_proxy(self) -> bool:
-            """Whether the connection has successfully connected to its proxy.
-            This returns False if no proxy is in use. Used to determine whether
-            errors are coming from the proxy layer or from tunnelling to the target origin.
-            """
-
-    class BaseHTTPSConnection(BaseHTTPConnection, Protocol):
-        default_port: typing.ClassVar[int]
-        default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS]
-
-        # Certificate verification methods
-        cert_reqs: int | str | None
-        assert_hostname: None | str | typing.Literal[False]
-        assert_fingerprint: str | None
-        ssl_context: ssl.SSLContext | None
-
-        # Trusted CAs
-        ca_certs: str | None
-        ca_cert_dir: str | None
-        ca_cert_data: None | str | bytes
-
-        # TLS version
-        ssl_minimum_version: int | None
-        ssl_maximum_version: int | None
-        ssl_version: int | str | None  # Deprecated
-
-        # Client certificates
-        cert_file: str | None
-        key_file: str | None
-        key_password: str | None
-
-        def __init__(
-            self,
-            host: str,
-            port: int | None = None,
-            *,
-            timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
-            source_address: tuple[str, int] | None = None,
-            blocksize: int = 16384,
-            socket_options: _TYPE_SOCKET_OPTIONS | None = ...,
-            proxy: Url | None = None,
-            proxy_config: ProxyConfig | None = None,
-            cert_reqs: int | str | None = None,
-            assert_hostname: None | str | typing.Literal[False] = None,
-            assert_fingerprint: str | None = None,
-            server_hostname: str | None = None,
-            ssl_context: ssl.SSLContext | None = None,
-            ca_certs: str | None = None,
-            ca_cert_dir: str | None = None,
-            ca_cert_data: None | str | bytes = None,
-            ssl_minimum_version: int | None = None,
-            ssl_maximum_version: int | None = None,
-            ssl_version: int | str | None = None,  # Deprecated
-            cert_file: str | None = None,
-            key_file: str | None = None,
-            key_password: str | None = None,
-        ) -> None: ...