hmdev-cli 1.0.0 → 1.0.2

package/python/.venv/Lib/site-packages/httpcore/_backends/mock.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-import ssl
-import typing
-
-from .._exceptions import ReadError
-from .base import (
-    SOCKET_OPTION,
-    AsyncNetworkBackend,
-    AsyncNetworkStream,
-    NetworkBackend,
-    NetworkStream,
-)
-
-
-class MockSSLObject:
-    def __init__(self, http2: bool):
-        self._http2 = http2
-
-    def selected_alpn_protocol(self) -> str:
-        return "h2" if self._http2 else "http/1.1"
-
-
-class MockStream(NetworkStream):
-    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
-        self._buffer = buffer
-        self._http2 = http2
-        self._closed = False
-
-    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        if self._closed:
-            raise ReadError("Connection closed")
-        if not self._buffer:
-            return b""
-        return self._buffer.pop(0)
-
-    def write(self, buffer: bytes, timeout: float | None = None) -> None:
-        pass
-
-    def close(self) -> None:
-        self._closed = True
-
-    def start_tls(
-        self,
-        ssl_context: ssl.SSLContext,
-        server_hostname: str | None = None,
-        timeout: float | None = None,
-    ) -> NetworkStream:
-        return self
-
-    def get_extra_info(self, info: str) -> typing.Any:
-        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
-
-    def __repr__(self) -> str:
-        return "<httpcore.MockStream>"
-
-
-class MockBackend(NetworkBackend):
-    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
-        self._buffer = buffer
-        self._http2 = http2
-
-    def connect_tcp(
-        self,
-        host: str,
-        port: int,
-        timeout: float | None = None,
-        local_address: str | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> NetworkStream:
-        return MockStream(list(self._buffer), http2=self._http2)
-
-    def connect_unix_socket(
-        self,
-        path: str,
-        timeout: float | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> NetworkStream:
-        return MockStream(list(self._buffer), http2=self._http2)
-
-    def sleep(self, seconds: float) -> None:
-        pass
-
-
-class AsyncMockStream(AsyncNetworkStream):
-    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
-        self._buffer = buffer
-        self._http2 = http2
-        self._closed = False
-
-    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        if self._closed:
-            raise ReadError("Connection closed")
-        if not self._buffer:
-            return b""
-        return self._buffer.pop(0)
-
-    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
-        pass
-
-    async def aclose(self) -> None:
-        self._closed = True
-
-    async def start_tls(
-        self,
-        ssl_context: ssl.SSLContext,
-        server_hostname: str | None = None,
-        timeout: float | None = None,
-    ) -> AsyncNetworkStream:
-        return self
-
-    def get_extra_info(self, info: str) -> typing.Any:
-        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
-
-    def __repr__(self) -> str:
-        return "<httpcore.AsyncMockStream>"
-
-
-class AsyncMockBackend(AsyncNetworkBackend):
-    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
-        self._buffer = buffer
-        self._http2 = http2
-
-    async def connect_tcp(
-        self,
-        host: str,
-        port: int,
-        timeout: float | None = None,
-        local_address: str | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> AsyncNetworkStream:
-        return AsyncMockStream(list(self._buffer), http2=self._http2)
-
-    async def connect_unix_socket(
-        self,
-        path: str,
-        timeout: float | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> AsyncNetworkStream:
-        return AsyncMockStream(list(self._buffer), http2=self._http2)
-
-    async def sleep(self, seconds: float) -> None:
-        pass

package/python/.venv/Lib/site-packages/httpcore/_backends/sync.py

@@ -1,241 +0,0 @@
-from __future__ import annotations
-
-import functools
-import socket
-import ssl
-import sys
-import typing
-
-from .._exceptions import (
-    ConnectError,
-    ConnectTimeout,
-    ExceptionMapping,
-    ReadError,
-    ReadTimeout,
-    WriteError,
-    WriteTimeout,
-    map_exceptions,
-)
-from .._utils import is_socket_readable
-from .base import SOCKET_OPTION, NetworkBackend, NetworkStream
-
-
-class TLSinTLSStream(NetworkStream):  # pragma: no cover
-    """
-    Because the standard `SSLContext.wrap_socket` method does
-    not work for `SSLSocket` objects, we need this class
-    to implement TLS stream using an underlying `SSLObject`
-    instance in order to support TLS on top of TLS.
-    """
-
-    # Defined in RFC 8449
-    TLS_RECORD_SIZE = 16384
-
-    def __init__(
-        self,
-        sock: socket.socket,
-        ssl_context: ssl.SSLContext,
-        server_hostname: str | None = None,
-        timeout: float | None = None,
-    ):
-        self._sock = sock
-        self._incoming = ssl.MemoryBIO()
-        self._outgoing = ssl.MemoryBIO()
-
-        self.ssl_obj = ssl_context.wrap_bio(
-            incoming=self._incoming,
-            outgoing=self._outgoing,
-            server_hostname=server_hostname,
-        )
-
-        self._sock.settimeout(timeout)
-        self._perform_io(self.ssl_obj.do_handshake)
-
-    def _perform_io(
-        self,
-        func: typing.Callable[..., typing.Any],
-    ) -> typing.Any:
-        ret = None
-
-        while True:
-            errno = None
-            try:
-                ret = func()
-            except (ssl.SSLWantReadError, ssl.SSLWantWriteError) as e:
-                errno = e.errno
-
-            self._sock.sendall(self._outgoing.read())
-
-            if errno == ssl.SSL_ERROR_WANT_READ:
-                buf = self._sock.recv(self.TLS_RECORD_SIZE)
-
-                if buf:
-                    self._incoming.write(buf)
-                else:
-                    self._incoming.write_eof()
-            if errno is None:
-                return ret
-
-    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
-        with map_exceptions(exc_map):
-            self._sock.settimeout(timeout)
-            return typing.cast(
-                bytes, self._perform_io(functools.partial(self.ssl_obj.read, max_bytes))
-            )
-
-    def write(self, buffer: bytes, timeout: float | None = None) -> None:
-        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
-        with map_exceptions(exc_map):
-            self._sock.settimeout(timeout)
-            while buffer:
-                nsent = self._perform_io(functools.partial(self.ssl_obj.write, buffer))
-                buffer = buffer[nsent:]
-
-    def close(self) -> None:
-        self._sock.close()
-
-    def start_tls(
-        self,
-        ssl_context: ssl.SSLContext,
-        server_hostname: str | None = None,
-        timeout: float | None = None,
-    ) -> NetworkStream:
-        raise NotImplementedError()
-
-    def get_extra_info(self, info: str) -> typing.Any:
-        if info == "ssl_object":
-            return self.ssl_obj
-        if info == "client_addr":
-            return self._sock.getsockname()
-        if info == "server_addr":
-            return self._sock.getpeername()
-        if info == "socket":
-            return self._sock
-        if info == "is_readable":
-            return is_socket_readable(self._sock)
-        return None
-
-
-class SyncStream(NetworkStream):
-    def __init__(self, sock: socket.socket) -> None:
-        self._sock = sock
-
-    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
-        with map_exceptions(exc_map):
-            self._sock.settimeout(timeout)
-            return self._sock.recv(max_bytes)
-
-    def write(self, buffer: bytes, timeout: float | None = None) -> None:
-        if not buffer:
-            return
-
-        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
-        with map_exceptions(exc_map):
-            while buffer:
-                self._sock.settimeout(timeout)
-                n = self._sock.send(buffer)
-                buffer = buffer[n:]
-
-    def close(self) -> None:
-        self._sock.close()
-
-    def start_tls(
-        self,
-        ssl_context: ssl.SSLContext,
-        server_hostname: str | None = None,
-        timeout: float | None = None,
-    ) -> NetworkStream:
-        exc_map: ExceptionMapping = {
-            socket.timeout: ConnectTimeout,
-            OSError: ConnectError,
-        }
-        with map_exceptions(exc_map):
-            try:
-                if isinstance(self._sock, ssl.SSLSocket):  # pragma: no cover
-                    # If the underlying socket has already been upgraded
-                    # to the TLS layer (i.e. is an instance of SSLSocket),
-                    # we need some additional smarts to support TLS-in-TLS.
-                    return TLSinTLSStream(
-                        self._sock, ssl_context, server_hostname, timeout
-                    )
-                else:
-                    self._sock.settimeout(timeout)
-                    sock = ssl_context.wrap_socket(
-                        self._sock, server_hostname=server_hostname
-                    )
-            except Exception as exc:  # pragma: nocover
-                self.close()
-                raise exc
-        return SyncStream(sock)
-
-    def get_extra_info(self, info: str) -> typing.Any:
-        if info == "ssl_object" and isinstance(self._sock, ssl.SSLSocket):
-            return self._sock._sslobj  # type: ignore
-        if info == "client_addr":
-            return self._sock.getsockname()
-        if info == "server_addr":
-            return self._sock.getpeername()
-        if info == "socket":
-            return self._sock
-        if info == "is_readable":
-            return is_socket_readable(self._sock)
-        return None
-
-
-class SyncBackend(NetworkBackend):
-    def connect_tcp(
-        self,
-        host: str,
-        port: int,
-        timeout: float | None = None,
-        local_address: str | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> NetworkStream:
-        # Note that we automatically include `TCP_NODELAY`
-        # in addition to any other custom socket options.
-        if socket_options is None:
-            socket_options = []  # pragma: no cover
-        address = (host, port)
-        source_address = None if local_address is None else (local_address, 0)
-        exc_map: ExceptionMapping = {
-            socket.timeout: ConnectTimeout,
-            OSError: ConnectError,
-        }
-
-        with map_exceptions(exc_map):
-            sock = socket.create_connection(
-                address,
-                timeout,
-                source_address=source_address,
-            )
-            for option in socket_options:
-                sock.setsockopt(*option)  # pragma: no cover
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        return SyncStream(sock)
-
-    def connect_unix_socket(
-        self,
-        path: str,
-        timeout: float | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> NetworkStream:  # pragma: nocover
-        if sys.platform == "win32":
-            raise RuntimeError(
-                "Attempted to connect to a UNIX socket on a Windows system."
-            )
-        if socket_options is None:
-            socket_options = []
-
-        exc_map: ExceptionMapping = {
-            socket.timeout: ConnectTimeout,
-            OSError: ConnectError,
-        }
-        with map_exceptions(exc_map):
-            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            for option in socket_options:
-                sock.setsockopt(*option)
-            sock.settimeout(timeout)
-            sock.connect(path)
-        return SyncStream(sock)

package/python/.venv/Lib/site-packages/httpcore/_backends/trio.py

@@ -1,159 +0,0 @@
-from __future__ import annotations
-
-import ssl
-import typing
-
-import trio
-
-from .._exceptions import (
-    ConnectError,
-    ConnectTimeout,
-    ExceptionMapping,
-    ReadError,
-    ReadTimeout,
-    WriteError,
-    WriteTimeout,
-    map_exceptions,
-)
-from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
-
-
-class TrioStream(AsyncNetworkStream):
-    def __init__(self, stream: trio.abc.Stream) -> None:
-        self._stream = stream
-
-    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        timeout_or_inf = float("inf") if timeout is None else timeout
-        exc_map: ExceptionMapping = {
-            trio.TooSlowError: ReadTimeout,
-            trio.BrokenResourceError: ReadError,
-            trio.ClosedResourceError: ReadError,
-        }
-        with map_exceptions(exc_map):
-            with trio.fail_after(timeout_or_inf):
-                data: bytes = await self._stream.receive_some(max_bytes=max_bytes)
-                return data
-
-    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
-        if not buffer:
-            return
-
-        timeout_or_inf = float("inf") if timeout is None else timeout
-        exc_map: ExceptionMapping = {
-            trio.TooSlowError: WriteTimeout,
-            trio.BrokenResourceError: WriteError,
-            trio.ClosedResourceError: WriteError,
-        }
-        with map_exceptions(exc_map):
-            with trio.fail_after(timeout_or_inf):
-                await self._stream.send_all(data=buffer)
-
-    async def aclose(self) -> None:
-        await self._stream.aclose()
-
-    async def start_tls(
-        self,
-        ssl_context: ssl.SSLContext,
-        server_hostname: str | None = None,
-        timeout: float | None = None,
-    ) -> AsyncNetworkStream:
-        timeout_or_inf = float("inf") if timeout is None else timeout
-        exc_map: ExceptionMapping = {
-            trio.TooSlowError: ConnectTimeout,
-            trio.BrokenResourceError: ConnectError,
-        }
-        ssl_stream = trio.SSLStream(
-            self._stream,
-            ssl_context=ssl_context,
-            server_hostname=server_hostname,
-            https_compatible=True,
-            server_side=False,
-        )
-        with map_exceptions(exc_map):
-            try:
-                with trio.fail_after(timeout_or_inf):
-                    await ssl_stream.do_handshake()
-            except Exception as exc:  # pragma: nocover
-                await self.aclose()
-                raise exc
-        return TrioStream(ssl_stream)
-
-    def get_extra_info(self, info: str) -> typing.Any:
-        if info == "ssl_object" and isinstance(self._stream, trio.SSLStream):
-            # Type checkers cannot see `_ssl_object` attribute because trio._ssl.SSLStream uses __getattr__/__setattr__.
-            # Tracked at https://github.com/python-trio/trio/issues/542
-            return self._stream._ssl_object  # type: ignore[attr-defined]
-        if info == "client_addr":
-            return self._get_socket_stream().socket.getsockname()
-        if info == "server_addr":
-            return self._get_socket_stream().socket.getpeername()
-        if info == "socket":
-            stream = self._stream
-            while isinstance(stream, trio.SSLStream):
-                stream = stream.transport_stream
-            assert isinstance(stream, trio.SocketStream)
-            return stream.socket
-        if info == "is_readable":
-            socket = self.get_extra_info("socket")
-            return socket.is_readable()
-        return None
-
-    def _get_socket_stream(self) -> trio.SocketStream:
-        stream = self._stream
-        while isinstance(stream, trio.SSLStream):
-            stream = stream.transport_stream
-        assert isinstance(stream, trio.SocketStream)
-        return stream
-
-
-class TrioBackend(AsyncNetworkBackend):
-    async def connect_tcp(
-        self,
-        host: str,
-        port: int,
-        timeout: float | None = None,
-        local_address: str | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> AsyncNetworkStream:
-        # By default for TCP sockets, trio enables TCP_NODELAY.
-        # https://trio.readthedocs.io/en/stable/reference-io.html#trio.SocketStream
-        if socket_options is None:
-            socket_options = []  # pragma: no cover
-        timeout_or_inf = float("inf") if timeout is None else timeout
-        exc_map: ExceptionMapping = {
-            trio.TooSlowError: ConnectTimeout,
-            trio.BrokenResourceError: ConnectError,
-            OSError: ConnectError,
-        }
-        with map_exceptions(exc_map):
-            with trio.fail_after(timeout_or_inf):
-                stream: trio.abc.Stream = await trio.open_tcp_stream(
-                    host=host, port=port, local_address=local_address
-                )
-                for option in socket_options:
-                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
-        return TrioStream(stream)
-
-    async def connect_unix_socket(
-        self,
-        path: str,
-        timeout: float | None = None,
-        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> AsyncNetworkStream:  # pragma: nocover
-        if socket_options is None:
-            socket_options = []
-        timeout_or_inf = float("inf") if timeout is None else timeout
-        exc_map: ExceptionMapping = {
-            trio.TooSlowError: ConnectTimeout,
-            trio.BrokenResourceError: ConnectError,
-            OSError: ConnectError,
-        }
-        with map_exceptions(exc_map):
-            with trio.fail_after(timeout_or_inf):
-                stream: trio.abc.Stream = await trio.open_unix_socket(path)
-                for option in socket_options:
-                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
-        return TrioStream(stream)
-
-    async def sleep(self, seconds: float) -> None:
-        await trio.sleep(seconds)  # pragma: nocover

package/python/.venv/Lib/site-packages/httpcore/_exceptions.py

@@ -1,81 +0,0 @@
-import contextlib
-import typing
-
-ExceptionMapping = typing.Mapping[typing.Type[Exception], typing.Type[Exception]]
-
-
-@contextlib.contextmanager
-def map_exceptions(map: ExceptionMapping) -> typing.Iterator[None]:
-    try:
-        yield
-    except Exception as exc:  # noqa: PIE786
-        for from_exc, to_exc in map.items():
-            if isinstance(exc, from_exc):
-                raise to_exc(exc) from exc
-        raise  # pragma: nocover
-
-
-class ConnectionNotAvailable(Exception):
-    pass
-
-
-class ProxyError(Exception):
-    pass
-
-
-class UnsupportedProtocol(Exception):
-    pass
-
-
-class ProtocolError(Exception):
-    pass
-
-
-class RemoteProtocolError(ProtocolError):
-    pass
-
-
-class LocalProtocolError(ProtocolError):
-    pass
-
-
-# Timeout errors
-
-
-class TimeoutException(Exception):
-    pass
-
-
-class PoolTimeout(TimeoutException):
-    pass
-
-
-class ConnectTimeout(TimeoutException):
-    pass
-
-
-class ReadTimeout(TimeoutException):
-    pass
-
-
-class WriteTimeout(TimeoutException):
-    pass
-
-
-# Network errors
-
-
-class NetworkError(Exception):
-    pass
-
-
-class ConnectError(NetworkError):
-    pass
-
-
-class ReadError(NetworkError):
-    pass
-
-
-class WriteError(NetworkError):
-    pass