@scrypted/server 0.0.141 → 0.0.142

package/.venv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/ssltransport.py

@@ -1,221 +0,0 @@
-import io
-import socket
-import ssl
-
-from pip._vendor.urllib3.exceptions import ProxySchemeUnsupported
-from pip._vendor.urllib3.packages import six
-
-SSL_BLOCKSIZE = 16384
-
-
-class SSLTransport:
-    """
-    The SSLTransport wraps an existing socket and establishes an SSL connection.
-
-    Contrary to Python's implementation of SSLSocket, it allows you to chain
-    multiple TLS connections together. It's particularly useful if you need to
-    implement TLS within TLS.
-
-    The class supports most of the socket API operations.
-    """
-
-    @staticmethod
-    def _validate_ssl_context_for_tls_in_tls(ssl_context):
-        """
-        Raises a ProxySchemeUnsupported if the provided ssl_context can't be used
-        for TLS in TLS.
-
-        The only requirement is that the ssl_context provides the 'wrap_bio'
-        methods.
-        """
-
-        if not hasattr(ssl_context, "wrap_bio"):
-            if six.PY2:
-                raise ProxySchemeUnsupported(
-                    "TLS in TLS requires SSLContext.wrap_bio() which isn't "
-                    "supported on Python 2"
-                )
-            else:
-                raise ProxySchemeUnsupported(
-                    "TLS in TLS requires SSLContext.wrap_bio() which isn't "
-                    "available on non-native SSLContext"
-                )
-
-    def __init__(
-        self, socket, ssl_context, server_hostname=None, suppress_ragged_eofs=True
-    ):
-        """
-        Create an SSLTransport around socket using the provided ssl_context.
-        """
-        self.incoming = ssl.MemoryBIO()
-        self.outgoing = ssl.MemoryBIO()
-
-        self.suppress_ragged_eofs = suppress_ragged_eofs
-        self.socket = socket
-
-        self.sslobj = ssl_context.wrap_bio(
-            self.incoming, self.outgoing, server_hostname=server_hostname
-        )
-
-        # Perform initial handshake.
-        self._ssl_io_loop(self.sslobj.do_handshake)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *_):
-        self.close()
-
-    def fileno(self):
-        return self.socket.fileno()
-
-    def read(self, len=1024, buffer=None):
-        return self._wrap_ssl_read(len, buffer)
-
-    def recv(self, len=1024, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to recv")
-        return self._wrap_ssl_read(len)
-
-    def recv_into(self, buffer, nbytes=None, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to recv_into")
-        if buffer and (nbytes is None):
-            nbytes = len(buffer)
-        elif nbytes is None:
-            nbytes = 1024
-        return self.read(nbytes, buffer)
-
-    def sendall(self, data, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to sendall")
-        count = 0
-        with memoryview(data) as view, view.cast("B") as byte_view:
-            amount = len(byte_view)
-            while count < amount:
-                v = self.send(byte_view[count:])
-                count += v
-
-    def send(self, data, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to send")
-        response = self._ssl_io_loop(self.sslobj.write, data)
-        return response
-
-    def makefile(
-        self, mode="r", buffering=None, encoding=None, errors=None, newline=None
-    ):
-        """
-        Python's httpclient uses makefile and buffered io when reading HTTP
-        messages and we need to support it.
-
-        This is unfortunately a copy and paste of socket.py makefile with small
-        changes to point to the socket directly.
-        """
-        if not set(mode) <= {"r", "w", "b"}:
-            raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,))
-
-        writing = "w" in mode
-        reading = "r" in mode or not writing
-        assert reading or writing
-        binary = "b" in mode
-        rawmode = ""
-        if reading:
-            rawmode += "r"
-        if writing:
-            rawmode += "w"
-        raw = socket.SocketIO(self, rawmode)
-        self.socket._io_refs += 1
-        if buffering is None:
-            buffering = -1
-        if buffering < 0:
-            buffering = io.DEFAULT_BUFFER_SIZE
-        if buffering == 0:
-            if not binary:
-                raise ValueError("unbuffered streams must be binary")
-            return raw
-        if reading and writing:
-            buffer = io.BufferedRWPair(raw, raw, buffering)
-        elif reading:
-            buffer = io.BufferedReader(raw, buffering)
-        else:
-            assert writing
-            buffer = io.BufferedWriter(raw, buffering)
-        if binary:
-            return buffer
-        text = io.TextIOWrapper(buffer, encoding, errors, newline)
-        text.mode = mode
-        return text
-
-    def unwrap(self):
-        self._ssl_io_loop(self.sslobj.unwrap)
-
-    def close(self):
-        self.socket.close()
-
-    def getpeercert(self, binary_form=False):
-        return self.sslobj.getpeercert(binary_form)
-
-    def version(self):
-        return self.sslobj.version()
-
-    def cipher(self):
-        return self.sslobj.cipher()
-
-    def selected_alpn_protocol(self):
-        return self.sslobj.selected_alpn_protocol()
-
-    def selected_npn_protocol(self):
-        return self.sslobj.selected_npn_protocol()
-
-    def shared_ciphers(self):
-        return self.sslobj.shared_ciphers()
-
-    def compression(self):
-        return self.sslobj.compression()
-
-    def settimeout(self, value):
-        self.socket.settimeout(value)
-
-    def gettimeout(self):
-        return self.socket.gettimeout()
-
-    def _decref_socketios(self):
-        self.socket._decref_socketios()
-
-    def _wrap_ssl_read(self, len, buffer=None):
-        try:
-            return self._ssl_io_loop(self.sslobj.read, len, buffer)
-        except ssl.SSLError as e:
-            if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs:
-                return 0  # eof, return 0.
-            else:
-                raise
-
-    def _ssl_io_loop(self, func, *args):
-        """Performs an I/O loop between incoming/outgoing and the socket."""
-        should_loop = True
-        ret = None
-
-        while should_loop:
-            errno = None
-            try:
-                ret = func(*args)
-            except ssl.SSLError as e:
-                if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE):
-                    # WANT_READ, and WANT_WRITE are expected, others are not.
-                    raise e
-                errno = e.errno
-
-            buf = self.outgoing.read()
-            self.socket.sendall(buf)
-
-            if errno is None:
-                should_loop = False
-            elif errno == ssl.SSL_ERROR_WANT_READ:
-                buf = self.socket.recv(SSL_BLOCKSIZE)
-                if buf:
-                    self.incoming.write(buf)
-                else:
-                    self.incoming.write_eof()
-        return ret

package/.venv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/timeout.py

@@ -1,268 +0,0 @@
-from __future__ import absolute_import
-
-import time
-
-# The default socket timeout, used by httplib to indicate that no timeout was
-# specified by the user
-from socket import _GLOBAL_DEFAULT_TIMEOUT
-
-from ..exceptions import TimeoutStateError
-
-# A sentinel value to indicate that no timeout was specified by the user in
-# urllib3
-_Default = object()
-
-
-# Use time.monotonic if available.
-current_time = getattr(time, "monotonic", time.time)
-
-
-class Timeout(object):
-    """Timeout configuration.
-
-    Timeouts can be defined as a default for a pool:
-
-    .. code-block:: python
-
-       timeout = Timeout(connect=2.0, read=7.0)
-       http = PoolManager(timeout=timeout)
-       response = http.request('GET', 'http://example.com/')
-
-    Or per-request (which overrides the default for the pool):
-
-    .. code-block:: python
-
-       response = http.request('GET', 'http://example.com/', timeout=Timeout(10))
-
-    Timeouts can be disabled by setting all the parameters to ``None``:
-
-    .. code-block:: python
-
-       no_timeout = Timeout(connect=None, read=None)
-       response = http.request('GET', 'http://example.com/, timeout=no_timeout)
-
-
-    :param total:
-        This combines the connect and read timeouts into one; the read timeout
-        will be set to the time leftover from the connect attempt. In the
-        event that both a connect timeout and a total are specified, or a read
-        timeout and a total are specified, the shorter timeout will be applied.
-
-        Defaults to None.
-
-    :type total: int, float, or None
-
-    :param connect:
-        The maximum amount of time (in seconds) to wait for a connection
-        attempt to a server to succeed. Omitting the parameter will default the
-        connect timeout to the system default, probably `the global default
-        timeout in socket.py
-        <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.
-        None will set an infinite timeout for connection attempts.
-
-    :type connect: int, float, or None
-
-    :param read:
-        The maximum amount of time (in seconds) to wait between consecutive
-        read operations for a response from the server. Omitting the parameter
-        will default the read timeout to the system default, probably `the
-        global default timeout in socket.py
-        <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.
-        None will set an infinite timeout.
-
-    :type read: int, float, or None
-
-    .. note::
-
-        Many factors can affect the total amount of time for urllib3 to return
-        an HTTP response.
-
-        For example, Python's DNS resolver does not obey the timeout specified
-        on the socket. Other factors that can affect total request time include
-        high CPU load, high swap, the program running at a low priority level,
-        or other behaviors.
-
-        In addition, the read and total timeouts only measure the time between
-        read operations on the socket connecting the client and the server,
-        not the total amount of time for the request to return a complete
-        response. For most requests, the timeout is raised because the server
-        has not sent the first byte in the specified time. This is not always
-        the case; if a server streams one byte every fifteen seconds, a timeout
-        of 20 seconds will not trigger, even though the request will take
-        several minutes to complete.
-
-        If your goal is to cut off any request after a set amount of wall clock
-        time, consider having a second "watcher" thread to cut off a slow
-        request.
-    """
-
-    #: A sentinel object representing the default timeout value
-    DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT
-
-    def __init__(self, total=None, connect=_Default, read=_Default):
-        self._connect = self._validate_timeout(connect, "connect")
-        self._read = self._validate_timeout(read, "read")
-        self.total = self._validate_timeout(total, "total")
-        self._start_connect = None
-
-    def __repr__(self):
-        return "%s(connect=%r, read=%r, total=%r)" % (
-            type(self).__name__,
-            self._connect,
-            self._read,
-            self.total,
-        )
-
-    # __str__ provided for backwards compatibility
-    __str__ = __repr__
-
-    @classmethod
-    def _validate_timeout(cls, value, name):
-        """Check that a timeout attribute is valid.
-
-        :param value: The timeout value to validate
-        :param name: The name of the timeout attribute to validate. This is
-            used to specify in error messages.
-        :return: The validated and casted version of the given value.
-        :raises ValueError: If it is a numeric value less than or equal to
-            zero, or the type is not an integer, float, or None.
-        """
-        if value is _Default:
-            return cls.DEFAULT_TIMEOUT
-
-        if value is None or value is cls.DEFAULT_TIMEOUT:
-            return value
-
-        if isinstance(value, bool):
-            raise ValueError(
-                "Timeout cannot be a boolean value. It must "
-                "be an int, float or None."
-            )
-        try:
-            float(value)
-        except (TypeError, ValueError):
-            raise ValueError(
-                "Timeout value %s was %s, but it must be an "
-                "int, float or None." % (name, value)
-            )
-
-        try:
-            if value <= 0:
-                raise ValueError(
-                    "Attempted to set %s timeout to %s, but the "
-                    "timeout cannot be set to a value less "
-                    "than or equal to 0." % (name, value)
-                )
-        except TypeError:
-            # Python 3
-            raise ValueError(
-                "Timeout value %s was %s, but it must be an "
-                "int, float or None." % (name, value)
-            )
-
-        return value
-
-    @classmethod
-    def from_float(cls, timeout):
-        """Create a new Timeout from a legacy timeout value.
-
-        The timeout value used by httplib.py sets the same timeout on the
-        connect(), and recv() socket requests. This creates a :class:`Timeout`
-        object that sets the individual timeouts to the ``timeout`` value
-        passed to this function.
-
-        :param timeout: The legacy timeout value.
-        :type timeout: integer, float, sentinel default object, or None
-        :return: Timeout object
-        :rtype: :class:`Timeout`
-        """
-        return Timeout(read=timeout, connect=timeout)
-
-    def clone(self):
-        """Create a copy of the timeout object
-
-        Timeout properties are stored per-pool but each request needs a fresh
-        Timeout object to ensure each one has its own start/stop configured.
-
-        :return: a copy of the timeout object
-        :rtype: :class:`Timeout`
-        """
-        # We can't use copy.deepcopy because that will also create a new object
-        # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to
-        # detect the user default.
-        return Timeout(connect=self._connect, read=self._read, total=self.total)
-
-    def start_connect(self):
-        """Start the timeout clock, used during a connect() attempt
-
-        :raises urllib3.exceptions.TimeoutStateError: if you attempt
-            to start a timer that has been started already.
-        """
-        if self._start_connect is not None:
-            raise TimeoutStateError("Timeout timer has already been started.")
-        self._start_connect = current_time()
-        return self._start_connect
-
-    def get_connect_duration(self):
-        """Gets the time elapsed since the call to :meth:`start_connect`.
-
-        :return: Elapsed time in seconds.
-        :rtype: float
-        :raises urllib3.exceptions.TimeoutStateError: if you attempt
-            to get duration for a timer that hasn't been started.
-        """
-        if self._start_connect is None:
-            raise TimeoutStateError(
-                "Can't get connect duration for timer that has not started."
-            )
-        return current_time() - self._start_connect
-
-    @property
-    def connect_timeout(self):
-        """Get the value to use when setting a connection timeout.
-
-        This will be a positive float or integer, the value None
-        (never timeout), or the default system timeout.
-
-        :return: Connect timeout.
-        :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
-        """
-        if self.total is None:
-            return self._connect
-
-        if self._connect is None or self._connect is self.DEFAULT_TIMEOUT:
-            return self.total
-
-        return min(self._connect, self.total)
-
-    @property
-    def read_timeout(self):
-        """Get the value for the read timeout.
-
-        This assumes some time has elapsed in the connection timeout and
-        computes the read timeout appropriately.
-
-        If self.total is set, the read timeout is dependent on the amount of
-        time taken by the connect timeout. If the connection time has not been
-        established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be
-        raised.
-
-        :return: Value to use for the read timeout.
-        :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
-        :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`
-            has not yet been called on this object.
-        """
-        if (
-            self.total is not None
-            and self.total is not self.DEFAULT_TIMEOUT
-            and self._read is not None
-            and self._read is not self.DEFAULT_TIMEOUT
-        ):
-            # In case the connect timeout has not yet been established.
-            if self._start_connect is None:
-                return self._read
-            return max(0, min(self.total - self.get_connect_duration(), self._read))
-        elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT:
-            return max(0, self.total - self.get_connect_duration())
-        else:
-            return self._read