PyPI - catocli - Versions diffs - 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl - Mend - Supply Chain Defender

catocli 1.0.1py3-none-any.whl → 1.0.3py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of catocli might be problematic. Click here for more details.

Files changed (1630) hide show

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/vendor/urllib3/contrib/socks.py DELETED Viewed

@@ -1,228 +0,0 @@
-"""
-This module contains provisional support for SOCKS proxies from within
-urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and
-SOCKS5. To enable its functionality, either install PySocks or install this
-module with the ``socks`` extra.
-The SOCKS implementation supports the full range of urllib3 features. It also
-supports the following SOCKS features:
-- SOCKS4A (``proxy_url='socks4a://...``)
-- SOCKS4 (``proxy_url='socks4://...``)
-- SOCKS5 with remote DNS (``proxy_url='socks5h://...``)
-- SOCKS5 with local DNS (``proxy_url='socks5://...``)
-- Usernames and passwords for the SOCKS proxy
-.. note::
-   It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in
-   your ``proxy_url`` to ensure that DNS resolution is done from the remote
-   server instead of client-side when connecting to a domain name.
-SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5
-supports IPv4, IPv6, and domain names.
-When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url``
-will be sent as the ``userid`` section of the SOCKS request:
-.. code-block:: python
-    proxy_url="socks4a://<userid>@proxy-host"
-When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion
-of the ``proxy_url`` will be sent as the username/password to authenticate
-with the proxy:
-.. code-block:: python
-    proxy_url="socks5h://<username>:<password>@proxy-host"
-"""
-from __future__ import annotations
-try:
-    import socks  # type: ignore[import-not-found]
-except ImportError:
-    import warnings
-    from ..exceptions import DependencyWarning
-    warnings.warn(
-        (
-            "SOCKS support in urllib3 requires the installation of optional "
-            "dependencies: specifically, PySocks.  For more information, see "
-            "https://urllib3.readthedocs.io/en/latest/advanced-usage.html#socks-proxies"
-        ),
-        DependencyWarning,
-    )
-    raise
-import typing
-from socket import timeout as SocketTimeout
-from ..connection import HTTPConnection, HTTPSConnection
-from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool
-from ..exceptions import ConnectTimeoutError, NewConnectionError
-from ..poolmanager import PoolManager
-from ..util.url import parse_url
-try:
-    import ssl
-except ImportError:
-    ssl = None  # type: ignore[assignment]
-class _TYPE_SOCKS_OPTIONS(typing.TypedDict):
-    socks_version: int
-    proxy_host: str | None
-    proxy_port: str | None
-    username: str | None
-    password: str | None
-    rdns: bool
-class SOCKSConnection(HTTPConnection):
-    """
-    A plain-text HTTP connection that connects via a SOCKS proxy.
-    """
-    def __init__(
-        self,
-        _socks_options: _TYPE_SOCKS_OPTIONS,
-        *args: typing.Any,
-        **kwargs: typing.Any,
-    ) -> None:
-        self._socks_options = _socks_options
-        super().__init__(*args, **kwargs)
-    def _new_conn(self) -> socks.socksocket:
-        """
-        Establish a new connection via the SOCKS proxy.
-        """
-        extra_kw: dict[str, typing.Any] = {}
-        if self.source_address:
-            extra_kw["source_address"] = self.source_address
-        if self.socket_options:
-            extra_kw["socket_options"] = self.socket_options
-        try:
-            conn = socks.create_connection(
-                (self.host, self.port),
-                proxy_type=self._socks_options["socks_version"],
-                proxy_addr=self._socks_options["proxy_host"],
-                proxy_port=self._socks_options["proxy_port"],
-                proxy_username=self._socks_options["username"],
-                proxy_password=self._socks_options["password"],
-                proxy_rdns=self._socks_options["rdns"],
-                timeout=self.timeout,
-                **extra_kw,
-            )
-        except SocketTimeout as e:
-            raise ConnectTimeoutError(
-                self,
-                f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
-            ) from e
-        except socks.ProxyError as e:
-            # This is fragile as hell, but it seems to be the only way to raise
-            # useful errors here.
-            if e.socket_err:
-                error = e.socket_err
-                if isinstance(error, SocketTimeout):
-                    raise ConnectTimeoutError(
-                        self,
-                        f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
-                    ) from e
-                else:
-                    # Adding `from e` messes with coverage somehow, so it's omitted.
-                    # See #2386.
-                    raise NewConnectionError(
-                        self, f"Failed to establish a new connection: {error}"
-                    )
-            else:
-                raise NewConnectionError(
-                    self, f"Failed to establish a new connection: {e}"
-                ) from e
-        except OSError as e:  # Defensive: PySocks should catch all these.
-            raise NewConnectionError(
-                self, f"Failed to establish a new connection: {e}"
-            ) from e
-        return conn
-# We don't need to duplicate the Verified/Unverified distinction from
-# urllib3/connection.py here because the HTTPSConnection will already have been
-# correctly set to either the Verified or Unverified form by that module. This
-# means the SOCKSHTTPSConnection will automatically be the correct type.
-class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection):
-    pass
-class SOCKSHTTPConnectionPool(HTTPConnectionPool):
-    ConnectionCls = SOCKSConnection
-class SOCKSHTTPSConnectionPool(HTTPSConnectionPool):
-    ConnectionCls = SOCKSHTTPSConnection
-class SOCKSProxyManager(PoolManager):
-    """
-    A version of the urllib3 ProxyManager that routes connections via the
-    defined SOCKS proxy.
-    """
-    pool_classes_by_scheme = {
-        "http": SOCKSHTTPConnectionPool,
-        "https": SOCKSHTTPSConnectionPool,
-    }
-    def __init__(
-        self,
-        proxy_url: str,
-        username: str | None = None,
-        password: str | None = None,
-        num_pools: int = 10,
-        headers: typing.Mapping[str, str] | None = None,
-        **connection_pool_kw: typing.Any,
-    ):
-        parsed = parse_url(proxy_url)
-        if username is None and password is None and parsed.auth is not None:
-            split = parsed.auth.split(":")
-            if len(split) == 2:
-                username, password = split
-        if parsed.scheme == "socks5":
-            socks_version = socks.PROXY_TYPE_SOCKS5
-            rdns = False
-        elif parsed.scheme == "socks5h":
-            socks_version = socks.PROXY_TYPE_SOCKS5
-            rdns = True
-        elif parsed.scheme == "socks4":
-            socks_version = socks.PROXY_TYPE_SOCKS4
-            rdns = False
-        elif parsed.scheme == "socks4a":
-            socks_version = socks.PROXY_TYPE_SOCKS4
-            rdns = True
-        else:
-            raise ValueError(f"Unable to determine SOCKS version from {proxy_url}")
-        self.proxy_url = proxy_url
-        socks_options = {
-            "socks_version": socks_version,
-            "proxy_host": parsed.host,
-            "proxy_port": parsed.port,
-            "username": username,
-            "password": password,
-            "rdns": rdns,
-        }
-        connection_pool_kw["_socks_options"] = socks_options
-        super().__init__(num_pools, headers, **connection_pool_kw)
-        self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/vendor/urllib3/exceptions.py DELETED Viewed

@@ -1,321 +0,0 @@
-from __future__ import annotations
-import socket
-import typing
-import warnings
-from email.errors import MessageDefect
-from http.client import IncompleteRead as httplib_IncompleteRead
-if typing.TYPE_CHECKING:
-    from .connection import HTTPConnection
-    from .connectionpool import ConnectionPool
-    from .response import HTTPResponse
-    from .util.retry import Retry
-# Base Exceptions
-class HTTPError(Exception):
-    """Base exception used by this module."""
-class HTTPWarning(Warning):
-    """Base warning used by this module."""
-_TYPE_REDUCE_RESULT = typing.Tuple[
-    typing.Callable[..., object], typing.Tuple[object, ...]
-]
-class PoolError(HTTPError):
-    """Base exception for errors caused within a pool."""
-    def __init__(self, pool: ConnectionPool, message: str) -> None:
-        self.pool = pool
-        super().__init__(f"{pool}: {message}")
-    def __reduce__(self) -> _TYPE_REDUCE_RESULT:
-        # For pickling purposes.
-        return self.__class__, (None, None)
-class RequestError(PoolError):
-    """Base exception for PoolErrors that have associated URLs."""
-    def __init__(self, pool: ConnectionPool, url: str, message: str) -> None:
-        self.url = url
-        super().__init__(pool, message)
-    def __reduce__(self) -> _TYPE_REDUCE_RESULT:
-        # For pickling purposes.
-        return self.__class__, (None, self.url, None)
-class SSLError(HTTPError):
-    """Raised when SSL certificate fails in an HTTPS connection."""
-class ProxyError(HTTPError):
-    """Raised when the connection to a proxy fails."""
-    # The original error is also available as __cause__.
-    original_error: Exception
-    def __init__(self, message: str, error: Exception) -> None:
-        super().__init__(message, error)
-        self.original_error = error
-class DecodeError(HTTPError):
-    """Raised when automatic decoding based on Content-Type fails."""
-class ProtocolError(HTTPError):
-    """Raised when something unexpected happens mid-request/response."""
-#: Renamed to ProtocolError but aliased for backwards compatibility.
-ConnectionError = ProtocolError
-# Leaf Exceptions
-class MaxRetryError(RequestError):
-    """Raised when the maximum number of retries is exceeded.
-    :param pool: The connection pool
-    :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool`
-    :param str url: The requested Url
-    :param reason: The underlying error
-    :type reason: :class:`Exception`
-    """
-    def __init__(
-        self, pool: ConnectionPool, url: str, reason: Exception | None = None
-    ) -> None:
-        self.reason = reason
-        message = f"Max retries exceeded with url: {url} (Caused by {reason!r})"
-        super().__init__(pool, url, message)
-class HostChangedError(RequestError):
-    """Raised when an existing pool gets a request for a foreign host."""
-    def __init__(
-        self, pool: ConnectionPool, url: str, retries: Retry | int = 3
-    ) -> None:
-        message = f"Tried to open a foreign host with url: {url}"
-        super().__init__(pool, url, message)
-        self.retries = retries
-class TimeoutStateError(HTTPError):
-    """Raised when passing an invalid state to a timeout"""
-class TimeoutError(HTTPError):
-    """Raised when a socket timeout error occurs.
-    Catching this error will catch both :exc:`ReadTimeoutErrors
-    <ReadTimeoutError>` and :exc:`ConnectTimeoutErrors <ConnectTimeoutError>`.
-    """
-class ReadTimeoutError(TimeoutError, RequestError):
-    """Raised when a socket timeout occurs while receiving data from a server"""
-# This timeout error does not have a URL attached and needs to inherit from the
-# base HTTPError
-class ConnectTimeoutError(TimeoutError):
-    """Raised when a socket timeout occurs while connecting to a server"""
-class NewConnectionError(ConnectTimeoutError, HTTPError):
-    """Raised when we fail to establish a new connection. Usually ECONNREFUSED."""
-    def __init__(self, conn: HTTPConnection, message: str) -> None:
-        self.conn = conn
-        super().__init__(f"{conn}: {message}")
-    @property
-    def pool(self) -> HTTPConnection:
-        warnings.warn(
-            "The 'pool' property is deprecated and will be removed "
-            "in urllib3 v2.1.0. Use 'conn' instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.conn
-class NameResolutionError(NewConnectionError):
-    """Raised when host name resolution fails."""
-    def __init__(self, host: str, conn: HTTPConnection, reason: socket.gaierror):
-        message = f"Failed to resolve '{host}' ({reason})"
-        super().__init__(conn, message)
-class EmptyPoolError(PoolError):
-    """Raised when a pool runs out of connections and no more are allowed."""
-class FullPoolError(PoolError):
-    """Raised when we try to add a connection to a full pool in blocking mode."""
-class ClosedPoolError(PoolError):
-    """Raised when a request enters a pool after the pool has been closed."""
-class LocationValueError(ValueError, HTTPError):
-    """Raised when there is something wrong with a given URL input."""
-class LocationParseError(LocationValueError):
-    """Raised when get_host or similar fails to parse the URL input."""
-    def __init__(self, location: str) -> None:
-        message = f"Failed to parse: {location}"
-        super().__init__(message)
-        self.location = location
-class URLSchemeUnknown(LocationValueError):
-    """Raised when a URL input has an unsupported scheme."""
-    def __init__(self, scheme: str):
-        message = f"Not supported URL scheme {scheme}"
-        super().__init__(message)
-        self.scheme = scheme
-class ResponseError(HTTPError):
-    """Used as a container for an error reason supplied in a MaxRetryError."""
-    GENERIC_ERROR = "too many error responses"
-    SPECIFIC_ERROR = "too many {status_code} error responses"
-class SecurityWarning(HTTPWarning):
-    """Warned when performing security reducing actions"""
-class InsecureRequestWarning(SecurityWarning):
-    """Warned when making an unverified HTTPS request."""
-class NotOpenSSLWarning(SecurityWarning):
-    """Warned when using unsupported SSL library"""
-class SystemTimeWarning(SecurityWarning):
-    """Warned when system time is suspected to be wrong"""
-class InsecurePlatformWarning(SecurityWarning):
-    """Warned when certain TLS/SSL configuration is not available on a platform."""
-class DependencyWarning(HTTPWarning):
-    """
-    Warned when an attempt is made to import a module with missing optional
-    dependencies.
-    """
-class ResponseNotChunked(ProtocolError, ValueError):
-    """Response needs to be chunked in order to read it as chunks."""
-class BodyNotHttplibCompatible(HTTPError):
-    """
-    Body should be :class:`http.client.HTTPResponse` like
-    (have an fp attribute which returns raw chunks) for read_chunked().
-    """
-class IncompleteRead(HTTPError, httplib_IncompleteRead):
-    """
-    Response length doesn't match expected Content-Length
-    Subclass of :class:`http.client.IncompleteRead` to allow int value
-    for ``partial`` to avoid creating large objects on streamed reads.
-    """
-    partial: int  # type: ignore[assignment]
-    expected: int
-    def __init__(self, partial: int, expected: int) -> None:
-        self.partial = partial
-        self.expected = expected
-    def __repr__(self) -> str:
-        return "IncompleteRead(%i bytes read, %i more expected)" % (
-            self.partial,
-            self.expected,
-        )
-class InvalidChunkLength(HTTPError, httplib_IncompleteRead):
-    """Invalid chunk length in a chunked response."""
-    def __init__(self, response: HTTPResponse, length: bytes) -> None:
-        self.partial: int = response.tell()  # type: ignore[assignment]
-        self.expected: int | None = response.length_remaining
-        self.response = response
-        self.length = length
-    def __repr__(self) -> str:
-        return "InvalidChunkLength(got length %r, %i bytes read)" % (
-            self.length,
-            self.partial,
-        )
-class InvalidHeader(HTTPError):
-    """The header provided was somehow invalid."""
-class ProxySchemeUnknown(AssertionError, URLSchemeUnknown):
-    """ProxyManager does not support the supplied scheme"""
-    # TODO(t-8ch): Stop inheriting from AssertionError in v2.0.
-    def __init__(self, scheme: str | None) -> None:
-        # 'localhost' is here because our URL parser parses
-        # localhost:8080 -> scheme=localhost, remove if we fix this.
-        if scheme == "localhost":
-            scheme = None
-        if scheme is None:
-            message = "Proxy URL had no scheme, should start with http:// or https://"
-        else:
-            message = f"Proxy URL had unsupported scheme {scheme}, should use http:// or https://"
-        super().__init__(message)
-class ProxySchemeUnsupported(ValueError):
-    """Fetching HTTPS resources through HTTPS proxies is unsupported"""
-class HeaderParsingError(HTTPError):
-    """Raised by assert_header_parsing, but we convert it to a log.warning statement."""
-    def __init__(
-        self, defects: list[MessageDefect], unparsed_data: bytes | str | None
-    ) -> None:
-        message = f"{defects or 'Unknown'}, unparsed data: {unparsed_data!r}"
-        super().__init__(message)
-class UnrewindableBodyError(HTTPError):
-    """urllib3 encountered an error when trying to rewind a body"""