hmdev-cli 1.0.0 → 1.0.2

package/python/.venv/Lib/site-packages/httpx/_multipart.py

@@ -1,300 +0,0 @@
-from __future__ import annotations
-
-import io
-import mimetypes
-import os
-import re
-import typing
-from pathlib import Path
-
-from ._types import (
-    AsyncByteStream,
-    FileContent,
-    FileTypes,
-    RequestData,
-    RequestFiles,
-    SyncByteStream,
-)
-from ._utils import (
-    peek_filelike_length,
-    primitive_value_to_str,
-    to_bytes,
-)
-
-_HTML5_FORM_ENCODING_REPLACEMENTS = {'"': "%22", "\\": "\\\\"}
-_HTML5_FORM_ENCODING_REPLACEMENTS.update(
-    {chr(c): "%{:02X}".format(c) for c in range(0x1F + 1) if c != 0x1B}
-)
-_HTML5_FORM_ENCODING_RE = re.compile(
-    r"|".join([re.escape(c) for c in _HTML5_FORM_ENCODING_REPLACEMENTS.keys()])
-)
-
-
-def _format_form_param(name: str, value: str) -> bytes:
-    """
-    Encode a name/value pair within a multipart form.
-    """
-
-    def replacer(match: typing.Match[str]) -> str:
-        return _HTML5_FORM_ENCODING_REPLACEMENTS[match.group(0)]
-
-    value = _HTML5_FORM_ENCODING_RE.sub(replacer, value)
-    return f'{name}="{value}"'.encode()
-
-
-def _guess_content_type(filename: str | None) -> str | None:
-    """
-    Guesses the mimetype based on a filename. Defaults to `application/octet-stream`.
-
-    Returns `None` if `filename` is `None` or empty.
-    """
-    if filename:
-        return mimetypes.guess_type(filename)[0] or "application/octet-stream"
-    return None
-
-
-def get_multipart_boundary_from_content_type(
-    content_type: bytes | None,
-) -> bytes | None:
-    if not content_type or not content_type.startswith(b"multipart/form-data"):
-        return None
-    # parse boundary according to
-    # https://www.rfc-editor.org/rfc/rfc2046#section-5.1.1
-    if b";" in content_type:
-        for section in content_type.split(b";"):
-            if section.strip().lower().startswith(b"boundary="):
-                return section.strip()[len(b"boundary=") :].strip(b'"')
-    return None
-
-
-class DataField:
-    """
-    A single form field item, within a multipart form field.
-    """
-
-    def __init__(self, name: str, value: str | bytes | int | float | None) -> None:
-        if not isinstance(name, str):
-            raise TypeError(
-                f"Invalid type for name. Expected str, got {type(name)}: {name!r}"
-            )
-        if value is not None and not isinstance(value, (str, bytes, int, float)):
-            raise TypeError(
-                "Invalid type for value. Expected primitive type,"
-                f" got {type(value)}: {value!r}"
-            )
-        self.name = name
-        self.value: str | bytes = (
-            value if isinstance(value, bytes) else primitive_value_to_str(value)
-        )
-
-    def render_headers(self) -> bytes:
-        if not hasattr(self, "_headers"):
-            name = _format_form_param("name", self.name)
-            self._headers = b"".join(
-                [b"Content-Disposition: form-data; ", name, b"\r\n\r\n"]
-            )
-
-        return self._headers
-
-    def render_data(self) -> bytes:
-        if not hasattr(self, "_data"):
-            self._data = to_bytes(self.value)
-
-        return self._data
-
-    def get_length(self) -> int:
-        headers = self.render_headers()
-        data = self.render_data()
-        return len(headers) + len(data)
-
-    def render(self) -> typing.Iterator[bytes]:
-        yield self.render_headers()
-        yield self.render_data()
-
-
-class FileField:
-    """
-    A single file field item, within a multipart form field.
-    """
-
-    CHUNK_SIZE = 64 * 1024
-
-    def __init__(self, name: str, value: FileTypes) -> None:
-        self.name = name
-
-        fileobj: FileContent
-
-        headers: dict[str, str] = {}
-        content_type: str | None = None
-
-        # This large tuple based API largely mirror's requests' API
-        # It would be good to think of better APIs for this that we could
-        # include in httpx 2.0 since variable length tuples(especially of 4 elements)
-        # are quite unwieldly
-        if isinstance(value, tuple):
-            if len(value) == 2:
-                # neither the 3rd parameter (content_type) nor the 4th (headers)
-                # was included
-                filename, fileobj = value
-            elif len(value) == 3:
-                filename, fileobj, content_type = value
-            else:
-                # all 4 parameters included
-                filename, fileobj, content_type, headers = value  # type: ignore
-        else:
-            filename = Path(str(getattr(value, "name", "upload"))).name
-            fileobj = value
-
-        if content_type is None:
-            content_type = _guess_content_type(filename)
-
-        has_content_type_header = any("content-type" in key.lower() for key in headers)
-        if content_type is not None and not has_content_type_header:
-            # note that unlike requests, we ignore the content_type provided in the 3rd
-            # tuple element if it is also included in the headers requests does
-            # the opposite (it overwrites the headerwith the 3rd tuple element)
-            headers["Content-Type"] = content_type
-
-        if isinstance(fileobj, io.StringIO):
-            raise TypeError(
-                "Multipart file uploads require 'io.BytesIO', not 'io.StringIO'."
-            )
-        if isinstance(fileobj, io.TextIOBase):
-            raise TypeError(
-                "Multipart file uploads must be opened in binary mode, not text mode."
-            )
-
-        self.filename = filename
-        self.file = fileobj
-        self.headers = headers
-
-    def get_length(self) -> int | None:
-        headers = self.render_headers()
-
-        if isinstance(self.file, (str, bytes)):
-            return len(headers) + len(to_bytes(self.file))
-
-        file_length = peek_filelike_length(self.file)
-
-        # If we can't determine the filesize without reading it into memory,
-        # then return `None` here, to indicate an unknown file length.
-        if file_length is None:
-            return None
-
-        return len(headers) + file_length
-
-    def render_headers(self) -> bytes:
-        if not hasattr(self, "_headers"):
-            parts = [
-                b"Content-Disposition: form-data; ",
-                _format_form_param("name", self.name),
-            ]
-            if self.filename:
-                filename = _format_form_param("filename", self.filename)
-                parts.extend([b"; ", filename])
-            for header_name, header_value in self.headers.items():
-                key, val = f"\r\n{header_name}: ".encode(), header_value.encode()
-                parts.extend([key, val])
-            parts.append(b"\r\n\r\n")
-            self._headers = b"".join(parts)
-
-        return self._headers
-
-    def render_data(self) -> typing.Iterator[bytes]:
-        if isinstance(self.file, (str, bytes)):
-            yield to_bytes(self.file)
-            return
-
-        if hasattr(self.file, "seek"):
-            try:
-                self.file.seek(0)
-            except io.UnsupportedOperation:
-                pass
-
-        chunk = self.file.read(self.CHUNK_SIZE)
-        while chunk:
-            yield to_bytes(chunk)
-            chunk = self.file.read(self.CHUNK_SIZE)
-
-    def render(self) -> typing.Iterator[bytes]:
-        yield self.render_headers()
-        yield from self.render_data()
-
-
-class MultipartStream(SyncByteStream, AsyncByteStream):
-    """
-    Request content as streaming multipart encoded form data.
-    """
-
-    def __init__(
-        self,
-        data: RequestData,
-        files: RequestFiles,
-        boundary: bytes | None = None,
-    ) -> None:
-        if boundary is None:
-            boundary = os.urandom(16).hex().encode("ascii")
-
-        self.boundary = boundary
-        self.content_type = "multipart/form-data; boundary=%s" % boundary.decode(
-            "ascii"
-        )
-        self.fields = list(self._iter_fields(data, files))
-
-    def _iter_fields(
-        self, data: RequestData, files: RequestFiles
-    ) -> typing.Iterator[FileField | DataField]:
-        for name, value in data.items():
-            if isinstance(value, (tuple, list)):
-                for item in value:
-                    yield DataField(name=name, value=item)
-            else:
-                yield DataField(name=name, value=value)
-
-        file_items = files.items() if isinstance(files, typing.Mapping) else files
-        for name, value in file_items:
-            yield FileField(name=name, value=value)
-
-    def iter_chunks(self) -> typing.Iterator[bytes]:
-        for field in self.fields:
-            yield b"--%s\r\n" % self.boundary
-            yield from field.render()
-            yield b"\r\n"
-        yield b"--%s--\r\n" % self.boundary
-
-    def get_content_length(self) -> int | None:
-        """
-        Return the length of the multipart encoded content, or `None` if
-        any of the files have a length that cannot be determined upfront.
-        """
-        boundary_length = len(self.boundary)
-        length = 0
-
-        for field in self.fields:
-            field_length = field.get_length()
-            if field_length is None:
-                return None
-
-            length += 2 + boundary_length + 2  # b"--{boundary}\r\n"
-            length += field_length
-            length += 2  # b"\r\n"
-
-        length += 2 + boundary_length + 4  # b"--{boundary}--\r\n"
-        return length
-
-    # Content stream interface.
-
-    def get_headers(self) -> dict[str, str]:
-        content_length = self.get_content_length()
-        content_type = self.content_type
-        if content_length is None:
-            return {"Transfer-Encoding": "chunked", "Content-Type": content_type}
-        return {"Content-Length": str(content_length), "Content-Type": content_type}
-
-    def __iter__(self) -> typing.Iterator[bytes]:
-        for chunk in self.iter_chunks():
-            yield chunk
-
-    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
-        for chunk in self.iter_chunks():
-            yield chunk

package/python/.venv/Lib/site-packages/httpx/_status_codes.py

@@ -1,162 +0,0 @@
-from __future__ import annotations
-
-from enum import IntEnum
-
-__all__ = ["codes"]
-
-
-class codes(IntEnum):
-    """HTTP status codes and reason phrases
-
-    Status codes from the following RFCs are all observed:
-
-        * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
-        * RFC 6585: Additional HTTP Status Codes
-        * RFC 3229: Delta encoding in HTTP
-        * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
-        * RFC 5842: Binding Extensions to WebDAV
-        * RFC 7238: Permanent Redirect
-        * RFC 2295: Transparent Content Negotiation in HTTP
-        * RFC 2774: An HTTP Extension Framework
-        * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2)
-        * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)
-        * RFC 7725: An HTTP Status Code to Report Legal Obstacles
-        * RFC 8297: An HTTP Status Code for Indicating Hints
-        * RFC 8470: Using Early Data in HTTP
-    """
-
-    def __new__(cls, value: int, phrase: str = "") -> codes:
-        obj = int.__new__(cls, value)
-        obj._value_ = value
-
-        obj.phrase = phrase  # type: ignore[attr-defined]
-        return obj
-
-    def __str__(self) -> str:
-        return str(self.value)
-
-    @classmethod
-    def get_reason_phrase(cls, value: int) -> str:
-        try:
-            return codes(value).phrase  # type: ignore
-        except ValueError:
-            return ""
-
-    @classmethod
-    def is_informational(cls, value: int) -> bool:
-        """
-        Returns `True` for 1xx status codes, `False` otherwise.
-        """
-        return 100 <= value <= 199
-
-    @classmethod
-    def is_success(cls, value: int) -> bool:
-        """
-        Returns `True` for 2xx status codes, `False` otherwise.
-        """
-        return 200 <= value <= 299
-
-    @classmethod
-    def is_redirect(cls, value: int) -> bool:
-        """
-        Returns `True` for 3xx status codes, `False` otherwise.
-        """
-        return 300 <= value <= 399
-
-    @classmethod
-    def is_client_error(cls, value: int) -> bool:
-        """
-        Returns `True` for 4xx status codes, `False` otherwise.
-        """
-        return 400 <= value <= 499
-
-    @classmethod
-    def is_server_error(cls, value: int) -> bool:
-        """
-        Returns `True` for 5xx status codes, `False` otherwise.
-        """
-        return 500 <= value <= 599
-
-    @classmethod
-    def is_error(cls, value: int) -> bool:
-        """
-        Returns `True` for 4xx or 5xx status codes, `False` otherwise.
-        """
-        return 400 <= value <= 599
-
-    # informational
-    CONTINUE = 100, "Continue"
-    SWITCHING_PROTOCOLS = 101, "Switching Protocols"
-    PROCESSING = 102, "Processing"
-    EARLY_HINTS = 103, "Early Hints"
-
-    # success
-    OK = 200, "OK"
-    CREATED = 201, "Created"
-    ACCEPTED = 202, "Accepted"
-    NON_AUTHORITATIVE_INFORMATION = 203, "Non-Authoritative Information"
-    NO_CONTENT = 204, "No Content"
-    RESET_CONTENT = 205, "Reset Content"
-    PARTIAL_CONTENT = 206, "Partial Content"
-    MULTI_STATUS = 207, "Multi-Status"
-    ALREADY_REPORTED = 208, "Already Reported"
-    IM_USED = 226, "IM Used"
-
-    # redirection
-    MULTIPLE_CHOICES = 300, "Multiple Choices"
-    MOVED_PERMANENTLY = 301, "Moved Permanently"
-    FOUND = 302, "Found"
-    SEE_OTHER = 303, "See Other"
-    NOT_MODIFIED = 304, "Not Modified"
-    USE_PROXY = 305, "Use Proxy"
-    TEMPORARY_REDIRECT = 307, "Temporary Redirect"
-    PERMANENT_REDIRECT = 308, "Permanent Redirect"
-
-    # client error
-    BAD_REQUEST = 400, "Bad Request"
-    UNAUTHORIZED = 401, "Unauthorized"
-    PAYMENT_REQUIRED = 402, "Payment Required"
-    FORBIDDEN = 403, "Forbidden"
-    NOT_FOUND = 404, "Not Found"
-    METHOD_NOT_ALLOWED = 405, "Method Not Allowed"
-    NOT_ACCEPTABLE = 406, "Not Acceptable"
-    PROXY_AUTHENTICATION_REQUIRED = 407, "Proxy Authentication Required"
-    REQUEST_TIMEOUT = 408, "Request Timeout"
-    CONFLICT = 409, "Conflict"
-    GONE = 410, "Gone"
-    LENGTH_REQUIRED = 411, "Length Required"
-    PRECONDITION_FAILED = 412, "Precondition Failed"
-    REQUEST_ENTITY_TOO_LARGE = 413, "Request Entity Too Large"
-    REQUEST_URI_TOO_LONG = 414, "Request-URI Too Long"
-    UNSUPPORTED_MEDIA_TYPE = 415, "Unsupported Media Type"
-    REQUESTED_RANGE_NOT_SATISFIABLE = 416, "Requested Range Not Satisfiable"
-    EXPECTATION_FAILED = 417, "Expectation Failed"
-    IM_A_TEAPOT = 418, "I'm a teapot"
-    MISDIRECTED_REQUEST = 421, "Misdirected Request"
-    UNPROCESSABLE_ENTITY = 422, "Unprocessable Entity"
-    LOCKED = 423, "Locked"
-    FAILED_DEPENDENCY = 424, "Failed Dependency"
-    TOO_EARLY = 425, "Too Early"
-    UPGRADE_REQUIRED = 426, "Upgrade Required"
-    PRECONDITION_REQUIRED = 428, "Precondition Required"
-    TOO_MANY_REQUESTS = 429, "Too Many Requests"
-    REQUEST_HEADER_FIELDS_TOO_LARGE = 431, "Request Header Fields Too Large"
-    UNAVAILABLE_FOR_LEGAL_REASONS = 451, "Unavailable For Legal Reasons"
-
-    # server errors
-    INTERNAL_SERVER_ERROR = 500, "Internal Server Error"
-    NOT_IMPLEMENTED = 501, "Not Implemented"
-    BAD_GATEWAY = 502, "Bad Gateway"
-    SERVICE_UNAVAILABLE = 503, "Service Unavailable"
-    GATEWAY_TIMEOUT = 504, "Gateway Timeout"
-    HTTP_VERSION_NOT_SUPPORTED = 505, "HTTP Version Not Supported"
-    VARIANT_ALSO_NEGOTIATES = 506, "Variant Also Negotiates"
-    INSUFFICIENT_STORAGE = 507, "Insufficient Storage"
-    LOOP_DETECTED = 508, "Loop Detected"
-    NOT_EXTENDED = 510, "Not Extended"
-    NETWORK_AUTHENTICATION_REQUIRED = 511, "Network Authentication Required"
-
-
-# Include lower-case styles for `requests` compatibility.
-for code in codes:
-    setattr(codes, code._name_.lower(), int(code))

package/python/.venv/Lib/site-packages/httpx/_transports/__init__.py

@@ -1,15 +0,0 @@
-from .asgi import *
-from .base import *
-from .default import *
-from .mock import *
-from .wsgi import *
-
-__all__ = [
-    "ASGITransport",
-    "AsyncBaseTransport",
-    "BaseTransport",
-    "AsyncHTTPTransport",
-    "HTTPTransport",
-    "MockTransport",
-    "WSGITransport",
-]

package/python/.venv/Lib/site-packages/httpx/_transports/asgi.py

@@ -1,187 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .._models import Request, Response
-from .._types import AsyncByteStream
-from .base import AsyncBaseTransport
-
-if typing.TYPE_CHECKING:  # pragma: no cover
-    import asyncio
-
-    import trio
-
-    Event = typing.Union[asyncio.Event, trio.Event]
-
-
-_Message = typing.MutableMapping[str, typing.Any]
-_Receive = typing.Callable[[], typing.Awaitable[_Message]]
-_Send = typing.Callable[
-    [typing.MutableMapping[str, typing.Any]], typing.Awaitable[None]
-]
-_ASGIApp = typing.Callable[
-    [typing.MutableMapping[str, typing.Any], _Receive, _Send], typing.Awaitable[None]
-]
-
-__all__ = ["ASGITransport"]
-
-
-def is_running_trio() -> bool:
-    try:
-        # sniffio is a dependency of trio.
-
-        # See https://github.com/python-trio/trio/issues/2802
-        import sniffio
-
-        if sniffio.current_async_library() == "trio":
-            return True
-    except ImportError:  # pragma: nocover
-        pass
-
-    return False
-
-
-def create_event() -> Event:
-    if is_running_trio():
-        import trio
-
-        return trio.Event()
-
-    import asyncio
-
-    return asyncio.Event()
-
-
-class ASGIResponseStream(AsyncByteStream):
-    def __init__(self, body: list[bytes]) -> None:
-        self._body = body
-
-    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
-        yield b"".join(self._body)
-
-
-class ASGITransport(AsyncBaseTransport):
-    """
-    A custom AsyncTransport that handles sending requests directly to an ASGI app.
-
-    ```python
-    transport = httpx.ASGITransport(
-        app=app,
-        root_path="/submount",
-        client=("1.2.3.4", 123)
-    )
-    client = httpx.AsyncClient(transport=transport)
-    ```
-
-    Arguments:
-
-    * `app` - The ASGI application.
-    * `raise_app_exceptions` - Boolean indicating if exceptions in the application
-       should be raised. Default to `True`. Can be set to `False` for use cases
-       such as testing the content of a client 500 response.
-    * `root_path` - The root path on which the ASGI application should be mounted.
-    * `client` - A two-tuple indicating the client IP and port of incoming requests.
-    ```
-    """
-
-    def __init__(
-        self,
-        app: _ASGIApp,
-        raise_app_exceptions: bool = True,
-        root_path: str = "",
-        client: tuple[str, int] = ("127.0.0.1", 123),
-    ) -> None:
-        self.app = app
-        self.raise_app_exceptions = raise_app_exceptions
-        self.root_path = root_path
-        self.client = client
-
-    async def handle_async_request(
-        self,
-        request: Request,
-    ) -> Response:
-        assert isinstance(request.stream, AsyncByteStream)
-
-        # ASGI scope.
-        scope = {
-            "type": "http",
-            "asgi": {"version": "3.0"},
-            "http_version": "1.1",
-            "method": request.method,
-            "headers": [(k.lower(), v) for (k, v) in request.headers.raw],
-            "scheme": request.url.scheme,
-            "path": request.url.path,
-            "raw_path": request.url.raw_path.split(b"?")[0],
-            "query_string": request.url.query,
-            "server": (request.url.host, request.url.port),
-            "client": self.client,
-            "root_path": self.root_path,
-        }
-
-        # Request.
-        request_body_chunks = request.stream.__aiter__()
-        request_complete = False
-
-        # Response.
-        status_code = None
-        response_headers = None
-        body_parts = []
-        response_started = False
-        response_complete = create_event()
-
-        # ASGI callables.
-
-        async def receive() -> dict[str, typing.Any]:
-            nonlocal request_complete
-
-            if request_complete:
-                await response_complete.wait()
-                return {"type": "http.disconnect"}
-
-            try:
-                body = await request_body_chunks.__anext__()
-            except StopAsyncIteration:
-                request_complete = True
-                return {"type": "http.request", "body": b"", "more_body": False}
-            return {"type": "http.request", "body": body, "more_body": True}
-
-        async def send(message: typing.MutableMapping[str, typing.Any]) -> None:
-            nonlocal status_code, response_headers, response_started
-
-            if message["type"] == "http.response.start":
-                assert not response_started
-
-                status_code = message["status"]
-                response_headers = message.get("headers", [])
-                response_started = True
-
-            elif message["type"] == "http.response.body":
-                assert not response_complete.is_set()
-                body = message.get("body", b"")
-                more_body = message.get("more_body", False)
-
-                if body and request.method != "HEAD":
-                    body_parts.append(body)
-
-                if not more_body:
-                    response_complete.set()
-
-        try:
-            await self.app(scope, receive, send)
-        except Exception:  # noqa: PIE-786
-            if self.raise_app_exceptions:
-                raise
-
-            response_complete.set()
-            if status_code is None:
-                status_code = 500
-            if response_headers is None:
-                response_headers = {}
-
-        assert response_complete.is_set()
-        assert status_code is not None
-        assert response_headers is not None
-
-        stream = ASGIResponseStream(body_parts)
-
-        return Response(status_code, headers=response_headers, stream=stream)