@scrypted/arlo 0.11.26 → 0.11.27

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

@@ -1,42 +0,0 @@
-# For backwards compatibility, provide imports that used to be here.
-from __future__ import annotations
-
-from .connection import is_connection_dropped
-from .request import SKIP_HEADER, SKIPPABLE_HEADERS, make_headers
-from .response import is_fp_closed
-from .retry import Retry
-from .ssl_ import (
-    ALPN_PROTOCOLS,
-    IS_PYOPENSSL,
-    SSLContext,
-    assert_fingerprint,
-    create_urllib3_context,
-    resolve_cert_reqs,
-    resolve_ssl_version,
-    ssl_wrap_socket,
-)
-from .timeout import Timeout
-from .url import Url, parse_url
-from .wait import wait_for_read, wait_for_write
-
-__all__ = (
-    "IS_PYOPENSSL",
-    "SSLContext",
-    "ALPN_PROTOCOLS",
-    "Retry",
-    "Timeout",
-    "Url",
-    "assert_fingerprint",
-    "create_urllib3_context",
-    "is_connection_dropped",
-    "is_fp_closed",
-    "parse_url",
-    "make_headers",
-    "resolve_cert_reqs",
-    "resolve_ssl_version",
-    "ssl_wrap_socket",
-    "wait_for_read",
-    "wait_for_write",
-    "SKIP_HEADER",
-    "SKIPPABLE_HEADERS",
-)

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

@@ -1,137 +0,0 @@
-from __future__ import annotations
-
-import socket
-import typing
-
-from ..exceptions import LocationParseError
-from .timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT
-
-_TYPE_SOCKET_OPTIONS = list[tuple[int, int, typing.Union[int, bytes]]]
-
-if typing.TYPE_CHECKING:
-    from .._base_connection import BaseHTTPConnection
-
-
-def is_connection_dropped(conn: BaseHTTPConnection) -> bool:  # Platform-specific
-    """
-    Returns True if the connection is dropped and should be closed.
-    :param conn: :class:`urllib3.connection.HTTPConnection` object.
-    """
-    return not conn.is_connected
-
-
-# This function is copied from socket.py in the Python 2.7 standard
-# library test suite. Added to its signature is only `socket_options`.
-# One additional modification is that we avoid binding to IPv6 servers
-# discovered in DNS if the system doesn't have IPv6 functionality.
-def create_connection(
-    address: tuple[str, int],
-    timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
-    source_address: tuple[str, int] | None = None,
-    socket_options: _TYPE_SOCKET_OPTIONS | None = None,
-) -> socket.socket:
-    """Connect to *address* and return the socket object.
-
-    Convenience function.  Connect to *address* (a 2-tuple ``(host,
-    port)``) and return the socket object.  Passing the optional
-    *timeout* parameter will set the timeout on the socket instance
-    before attempting to connect.  If no *timeout* is supplied, the
-    global default timeout setting returned by :func:`socket.getdefaulttimeout`
-    is used.  If *source_address* is set it must be a tuple of (host, port)
-    for the socket to bind as a source address before making the connection.
-    An host of '' or port 0 tells the OS to use the default.
-    """
-
-    host, port = address
-    if host.startswith("["):
-        host = host.strip("[]")
-    err = None
-
-    # Using the value from allowed_gai_family() in the context of getaddrinfo lets
-    # us select whether to work with IPv4 DNS records, IPv6 records, or both.
-    # The original create_connection function always returns all records.
-    family = allowed_gai_family()
-
-    try:
-        host.encode("idna")
-    except UnicodeError:
-        raise LocationParseError(f"'{host}', label empty or too long") from None
-
-    for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM):
-        af, socktype, proto, canonname, sa = res
-        sock = None
-        try:
-            sock = socket.socket(af, socktype, proto)
-
-            # If provided, set socket level options before connecting.
-            _set_socket_options(sock, socket_options)
-
-            if timeout is not _DEFAULT_TIMEOUT:
-                sock.settimeout(timeout)
-            if source_address:
-                sock.bind(source_address)
-            sock.connect(sa)
-            # Break explicitly a reference cycle
-            err = None
-            return sock
-
-        except OSError as _:
-            err = _
-            if sock is not None:
-                sock.close()
-
-    if err is not None:
-        try:
-            raise err
-        finally:
-            # Break explicitly a reference cycle
-            err = None
-    else:
-        raise OSError("getaddrinfo returns an empty list")
-
-
-def _set_socket_options(
-    sock: socket.socket, options: _TYPE_SOCKET_OPTIONS | None
-) -> None:
-    if options is None:
-        return
-
-    for opt in options:
-        sock.setsockopt(*opt)
-
-
-def allowed_gai_family() -> socket.AddressFamily:
-    """This function is designed to work in the context of
-    getaddrinfo, where family=socket.AF_UNSPEC is the default and
-    will perform a DNS search for both IPv6 and IPv4 records."""
-
-    family = socket.AF_INET
-    if HAS_IPV6:
-        family = socket.AF_UNSPEC
-    return family
-
-
-def _has_ipv6(host: str) -> bool:
-    """Returns True if the system can bind an IPv6 address."""
-    sock = None
-    has_ipv6 = False
-
-    if socket.has_ipv6:
-        # has_ipv6 returns true if cPython was compiled with IPv6 support.
-        # It does not tell us if the system has IPv6 support enabled. To
-        # determine that we must bind to an IPv6 address.
-        # https://github.com/urllib3/urllib3/pull/611
-        # https://bugs.python.org/issue658327
-        try:
-            sock = socket.socket(socket.AF_INET6)
-            sock.bind((host, 0))
-            has_ipv6 = True
-        except Exception:
-            pass
-
-    if sock:
-        sock.close()
-    return has_ipv6
-
-
-HAS_IPV6 = _has_ipv6("::1")

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

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .url import Url
-
-if typing.TYPE_CHECKING:
-    from ..connection import ProxyConfig
-
-
-def connection_requires_http_tunnel(
-    proxy_url: Url | None = None,
-    proxy_config: ProxyConfig | None = None,
-    destination_scheme: str | None = None,
-) -> bool:
-    """
-    Returns True if the connection requires an HTTP CONNECT through the proxy.
-
-    :param URL proxy_url:
-        URL of the proxy.
-    :param ProxyConfig proxy_config:
-        Proxy configuration from poolmanager.py
-    :param str destination_scheme:
-        The scheme of the destination. (i.e https, http, etc)
-    """
-    # If we're not using a proxy, no way to use a tunnel.
-    if proxy_url is None:
-        return False
-
-    # HTTP destinations never require tunneling, we always forward.
-    if destination_scheme == "http":
-        return False
-
-    # Support for forwarding with HTTPS proxies and HTTPS destinations.
-    if (
-        proxy_url.scheme == "https"
-        and proxy_config
-        and proxy_config.use_forwarding_for_https
-    ):
-        return False
-
-    # Otherwise always use a tunnel.
-    return True

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

@@ -1,258 +0,0 @@
-from __future__ import annotations
-
-import io
-import typing
-from base64 import b64encode
-from enum import Enum
-
-from ..exceptions import UnrewindableBodyError
-from .util import to_bytes
-
-if typing.TYPE_CHECKING:
-    from typing import Final
-
-# Pass as a value within ``headers`` to skip
-# emitting some HTTP headers that are added automatically.
-# The only headers that are supported are ``Accept-Encoding``,
-# ``Host``, and ``User-Agent``.
-SKIP_HEADER = "@@@SKIP_HEADER@@@"
-SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"])
-
-ACCEPT_ENCODING = "gzip,deflate"
-try:
-    try:
-        import brotlicffi as _unused_module_brotli  # type: ignore[import-not-found] # noqa: F401
-    except ImportError:
-        import brotli as _unused_module_brotli  # type: ignore[import-not-found] # noqa: F401
-except ImportError:
-    pass
-else:
-    ACCEPT_ENCODING += ",br"
-try:
-    import zstandard as _unused_module_zstd  # noqa: F401
-except ImportError:
-    pass
-else:
-    ACCEPT_ENCODING += ",zstd"
-
-
-class _TYPE_FAILEDTELL(Enum):
-    token = 0
-
-
-_FAILEDTELL: Final[_TYPE_FAILEDTELL] = _TYPE_FAILEDTELL.token
-
-_TYPE_BODY_POSITION = typing.Union[int, _TYPE_FAILEDTELL]
-
-# When sending a request with these methods we aren't expecting
-# a body so don't need to set an explicit 'Content-Length: 0'
-# The reason we do this in the negative instead of tracking methods
-# which 'should' have a body is because unknown methods should be
-# treated as if they were 'POST' which *does* expect a body.
-_METHODS_NOT_EXPECTING_BODY = {"GET", "HEAD", "DELETE", "TRACE", "OPTIONS", "CONNECT"}
-
-
-def make_headers(
-    keep_alive: bool | None = None,
-    accept_encoding: bool | list[str] | str | None = None,
-    user_agent: str | None = None,
-    basic_auth: str | None = None,
-    proxy_basic_auth: str | None = None,
-    disable_cache: bool | None = None,
-) -> dict[str, str]:
-    """
-    Shortcuts for generating request headers.
-
-    :param keep_alive:
-        If ``True``, adds 'connection: keep-alive' header.
-
-    :param accept_encoding:
-        Can be a boolean, list, or string.
-        ``True`` translates to 'gzip,deflate'.  If the dependencies for
-        Brotli (either the ``brotli`` or ``brotlicffi`` package) and/or Zstandard
-        (the ``zstandard`` package) algorithms are installed, then their encodings are
-        included in the string ('br' and 'zstd', respectively).
-        List will get joined by comma.
-        String will be used as provided.
-
-    :param user_agent:
-        String representing the user-agent you want, such as
-        "python-urllib3/0.6"
-
-    :param basic_auth:
-        Colon-separated username:password string for 'authorization: basic ...'
-        auth header.
-
-    :param proxy_basic_auth:
-        Colon-separated username:password string for 'proxy-authorization: basic ...'
-        auth header.
-
-    :param disable_cache:
-        If ``True``, adds 'cache-control: no-cache' header.
-
-    Example:
-
-    .. code-block:: python
-
-        import urllib3
-
-        print(urllib3.util.make_headers(keep_alive=True, user_agent="Batman/1.0"))
-        # {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
-        print(urllib3.util.make_headers(accept_encoding=True))
-        # {'accept-encoding': 'gzip,deflate'}
-    """
-    headers: dict[str, str] = {}
-    if accept_encoding:
-        if isinstance(accept_encoding, str):
-            pass
-        elif isinstance(accept_encoding, list):
-            accept_encoding = ",".join(accept_encoding)
-        else:
-            accept_encoding = ACCEPT_ENCODING
-        headers["accept-encoding"] = accept_encoding
-
-    if user_agent:
-        headers["user-agent"] = user_agent
-
-    if keep_alive:
-        headers["connection"] = "keep-alive"
-
-    if basic_auth:
-        headers["authorization"] = (
-            f"Basic {b64encode(basic_auth.encode('latin-1')).decode()}"
-        )
-
-    if proxy_basic_auth:
-        headers["proxy-authorization"] = (
-            f"Basic {b64encode(proxy_basic_auth.encode('latin-1')).decode()}"
-        )
-
-    if disable_cache:
-        headers["cache-control"] = "no-cache"
-
-    return headers
-
-
-def set_file_position(
-    body: typing.Any, pos: _TYPE_BODY_POSITION | None
-) -> _TYPE_BODY_POSITION | None:
-    """
-    If a position is provided, move file to that point.
-    Otherwise, we'll attempt to record a position for future use.
-    """
-    if pos is not None:
-        rewind_body(body, pos)
-    elif getattr(body, "tell", None) is not None:
-        try:
-            pos = body.tell()
-        except OSError:
-            # This differentiates from None, allowing us to catch
-            # a failed `tell()` later when trying to rewind the body.
-            pos = _FAILEDTELL
-
-    return pos
-
-
-def rewind_body(body: typing.IO[typing.AnyStr], body_pos: _TYPE_BODY_POSITION) -> None:
-    """
-    Attempt to rewind body to a certain position.
-    Primarily used for request redirects and retries.
-
-    :param body:
-        File-like object that supports seek.
-
-    :param int pos:
-        Position to seek to in file.
-    """
-    body_seek = getattr(body, "seek", None)
-    if body_seek is not None and isinstance(body_pos, int):
-        try:
-            body_seek(body_pos)
-        except OSError as e:
-            raise UnrewindableBodyError(
-                "An error occurred when rewinding request body for redirect/retry."
-            ) from e
-    elif body_pos is _FAILEDTELL:
-        raise UnrewindableBodyError(
-            "Unable to record file position for rewinding "
-            "request body during a redirect/retry."
-        )
-    else:
-        raise ValueError(
-            f"body_pos must be of type integer, instead it was {type(body_pos)}."
-        )
-
-
-class ChunksAndContentLength(typing.NamedTuple):
-    chunks: typing.Iterable[bytes] | None
-    content_length: int | None
-
-
-def body_to_chunks(
-    body: typing.Any | None, method: str, blocksize: int
-) -> ChunksAndContentLength:
-    """Takes the HTTP request method, body, and blocksize and
-    transforms them into an iterable of chunks to pass to
-    socket.sendall() and an optional 'Content-Length' header.
-
-    A 'Content-Length' of 'None' indicates the length of the body
-    can't be determined so should use 'Transfer-Encoding: chunked'
-    for framing instead.
-    """
-
-    chunks: typing.Iterable[bytes] | None
-    content_length: int | None
-
-    # No body, we need to make a recommendation on 'Content-Length'
-    # based on whether that request method is expected to have
-    # a body or not.
-    if body is None:
-        chunks = None
-        if method.upper() not in _METHODS_NOT_EXPECTING_BODY:
-            content_length = 0
-        else:
-            content_length = None
-
-    # Bytes or strings become bytes
-    elif isinstance(body, (str, bytes)):
-        chunks = (to_bytes(body),)
-        content_length = len(chunks[0])
-
-    # File-like object, TODO: use seek() and tell() for length?
-    elif hasattr(body, "read"):
-
-        def chunk_readable() -> typing.Iterable[bytes]:
-            nonlocal body, blocksize
-            encode = isinstance(body, io.TextIOBase)
-            while True:
-                datablock = body.read(blocksize)
-                if not datablock:
-                    break
-                if encode:
-                    datablock = datablock.encode("utf-8")
-                yield datablock
-
-        chunks = chunk_readable()
-        content_length = None
-
-    # Otherwise we need to start checking via duck-typing.
-    else:
-        try:
-            # Check if the body implements the buffer API.
-            mv = memoryview(body)
-        except TypeError:
-            try:
-                # Check if the body is an iterable
-                chunks = iter(body)
-                content_length = None
-            except TypeError:
-                raise TypeError(
-                    f"'body' must be a bytes-like object, file-like "
-                    f"object, or iterable. Instead was {body!r}"
-                ) from None
-        else:
-            # Since it implements the buffer API can be passed directly to socket.sendall()
-            chunks = (body,)
-            content_length = mv.nbytes
-
-    return ChunksAndContentLength(chunks=chunks, content_length=content_length)

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

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-import http.client as httplib
-from email.errors import MultipartInvariantViolationDefect, StartBoundaryNotFoundDefect
-
-from ..exceptions import HeaderParsingError
-
-
-def is_fp_closed(obj: object) -> bool:
-    """
-    Checks whether a given file-like object is closed.
-
-    :param obj:
-        The file-like object to check.
-    """
-
-    try:
-        # Check `isclosed()` first, in case Python3 doesn't set `closed`.
-        # GH Issue #928
-        return obj.isclosed()  # type: ignore[no-any-return, attr-defined]
-    except AttributeError:
-        pass
-
-    try:
-        # Check via the official file-like-object way.
-        return obj.closed  # type: ignore[no-any-return, attr-defined]
-    except AttributeError:
-        pass
-
-    try:
-        # Check if the object is a container for another file-like object that
-        # gets released on exhaustion (e.g. HTTPResponse).
-        return obj.fp is None  # type: ignore[attr-defined]
-    except AttributeError:
-        pass
-
-    raise ValueError("Unable to determine whether fp is closed.")
-
-
-def assert_header_parsing(headers: httplib.HTTPMessage) -> None:
-    """
-    Asserts whether all headers have been successfully parsed.
-    Extracts encountered errors from the result of parsing headers.
-
-    Only works on Python 3.
-
-    :param http.client.HTTPMessage headers: Headers to verify.
-
-    :raises urllib3.exceptions.HeaderParsingError:
-        If parsing errors are found.
-    """
-
-    # This will fail silently if we pass in the wrong kind of parameter.
-    # To make debugging easier add an explicit check.
-    if not isinstance(headers, httplib.HTTPMessage):
-        raise TypeError(f"expected httplib.Message, got {type(headers)}.")
-
-    unparsed_data = None
-
-    # get_payload is actually email.message.Message.get_payload;
-    # we're only interested in the result if it's not a multipart message
-    if not headers.is_multipart():
-        payload = headers.get_payload()
-
-        if isinstance(payload, (bytes, str)):
-            unparsed_data = payload
-
-    # httplib is assuming a response body is available
-    # when parsing headers even when httplib only sends
-    # header data to parse_headers() This results in
-    # defects on multipart responses in particular.
-    # See: https://github.com/urllib3/urllib3/issues/800
-
-    # So we ignore the following defects:
-    # - StartBoundaryNotFoundDefect:
-    #     The claimed start boundary was never found.
-    # - MultipartInvariantViolationDefect:
-    #     A message claimed to be a multipart but no subparts were found.
-    defects = [
-        defect
-        for defect in headers.defects
-        if not isinstance(
-            defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect)
-        )
-    ]
-
-    if defects or unparsed_data:
-        raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)
-
-
-def is_response_to_head(response: httplib.HTTPResponse) -> bool:
-    """
-    Checks whether the request of a response has been a HEAD-request.
-
-    :param http.client.HTTPResponse response:
-        Response to check if the originating request
-        used 'HEAD' as a method.
-    """
-    # FIXME: Can we do this somehow without accessing private httplib _method?
-    method_str = response._method  # type: str  # type: ignore[attr-defined]
-    return method_str.upper() == "HEAD"