mxhttp 1.0.0__py3-none-any.whl

mxhttp/__init__.py

@@ -0,0 +1,36 @@
+"""Minimal typed declarative HTTP client."""
+
+from __future__ import annotations
+
+from mxhttp.consumer import AsyncConsumer, SyncConsumer
+from mxhttp.endpoint import delete, endpoint, get, head, patch, post, put
+from mxhttp.markers import Body, Cookie, Field, Header, Part, Path, Query
+from mxhttp.response import Response, response_handler, streaming_response_handler
+from mxhttp.sse import Event
+from mxhttp.types import PartValue
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "AsyncConsumer",
+    "Body",
+    "Cookie",
+    "Event",
+    "Field",
+    "Header",
+    "Part",
+    "PartValue",
+    "Path",
+    "Query",
+    "Response",
+    "SyncConsumer",
+    "delete",
+    "endpoint",
+    "get",
+    "head",
+    "patch",
+    "post",
+    "put",
+    "response_handler",
+    "streaming_response_handler",
+]

mxhttp/consumer.py

@@ -0,0 +1,95 @@
+"""Base classes for the declarative HTTP consumers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import Self, override
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    import httpx
+
+    from mxhttp.types import ResponseHandler
+
+
+class BaseConsumer:
+    """Base class for the sync and async declarative API client."""
+
+    _response_handler: ResponseHandler | None = None
+    _streaming_response_handler: ResponseHandler | None = None
+
+    def __init__(self, base_url: str, *, use_async: bool = False) -> None:
+        """Initializes the client bound to `base_url` with an empty header dict."""
+        import httpx
+
+        self.base_url = base_url.rstrip("/")
+        self._session = (
+            httpx.AsyncClient(base_url=self.base_url)
+            if use_async
+            else httpx.Client(base_url=self.base_url)
+        )
+
+    @override
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"{type(self).__name__}<{self.base_url}>"
+
+    @property
+    def session(self) -> httpx.Client | httpx.AsyncClient:
+        """The HTTP client used for outbound requests."""
+        return self._session
+
+
+class SyncConsumer(BaseConsumer):
+    """Base class for the synchronous declarative API client."""
+
+    def __init__(self, base_url: str) -> None:
+        """Initializes the client bound to `base_url` with an empty header dict."""
+        super().__init__(base_url, use_async=False)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.session.close()
+
+    if TYPE_CHECKING:
+
+        @override
+        @property
+        def session(self) -> httpx.Client:
+            """The synchronous HTTP client."""
+            return self._session  # type: ignore[return-value]
+
+
+class AsyncConsumer(BaseConsumer):
+    """Base class for the asynchronous declarative API client."""
+
+    def __init__(self, base_url: str) -> None:
+        """Initializes the client bound to `base_url` with an empty header dict."""
+        super().__init__(base_url, use_async=True)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.session.aclose()
+
+    if TYPE_CHECKING:
+
+        @override
+        @property
+        def session(self) -> httpx.AsyncClient:
+            """The asynchronous HTTP client."""
+            return self._session  # type: ignore[return-value]

mxhttp/endpoint.py

@@ -0,0 +1,220 @@
+"""Creates the endpoint wrapped function."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+from collections.abc import AsyncIterator, Callable, Coroutine, Iterator
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Concatenate,
+    ParamSpec,
+    Protocol,
+    get_args,
+    get_origin,
+    overload,
+)
+
+from mxhttp.request import RequestSpec, build_plan, build_request
+from mxhttp.response import (
+    apply_response_handler,
+    decode,
+    sse_async,
+    sse_sync,
+    stream_async,
+    stream_sync,
+)
+from mxhttp.sse import Event
+
+if TYPE_CHECKING:
+    from mxhttp import AsyncConsumer, SyncConsumer
+    from mxhttp.consumer import BaseConsumer
+    from mxhttp.types import AnyC_T, AsyncC_T, Method_T, Parsed_T, SyncC_T
+
+P = ParamSpec("P")
+
+
+class EndpointDecorator(Protocol):
+    """Interface for sync/async return invariants based on the context type."""
+
+    @overload
+    def __call__(
+        self, func: Callable[Concatenate[SyncC_T, P], Parsed_T]
+    ) -> Callable[Concatenate[SyncC_T, P], Parsed_T]: ...
+
+    @overload
+    def __call__(
+        self,
+        func: Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, Parsed_T]],
+    ) -> Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, Parsed_T]]: ...
+
+    @overload
+    def __call__(
+        self, func: Callable[Concatenate[SyncC_T, P], None]
+    ) -> Callable[Concatenate[SyncC_T, P], None]: ...
+
+    @overload
+    def __call__(
+        self,
+        func: Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, None]],
+    ) -> Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, None]]: ...
+
+    @overload
+    def __call__(
+        self, func: Callable[Concatenate[SyncC_T, P], Iterator[bytes]]
+    ) -> Callable[Concatenate[SyncC_T, P], Iterator[bytes]]: ...
+
+    @overload
+    def __call__(
+        self,
+        func: Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, AsyncIterator[bytes]]],
+    ) -> Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, AsyncIterator[bytes]]]: ...
+
+    @overload
+    def __call__(
+        self, func: Callable[Concatenate[SyncC_T, P], Iterator[Event]]
+    ) -> Callable[Concatenate[SyncC_T, P], Iterator[Event]]: ...
+
+    @overload
+    def __call__(
+        self,
+        func: Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, AsyncIterator[Event]]],
+    ) -> Callable[Concatenate[AsyncC_T, P], Coroutine[Any, Any, AsyncIterator[Event]]]: ...
+
+
+def endpoint(method: Method_T, path: str) -> EndpointDecorator:  # noqa: C901
+    """Shared implementation for the HTTP method decorator factories."""
+
+    def decorate(  # noqa: C901
+        func: Callable[Concatenate[AnyC_T, P], Parsed_T]
+        | Callable[Concatenate[AnyC_T, P], Coroutine[Any, Any, Parsed_T]],
+    ) -> (
+        Callable[Concatenate[AnyC_T, P], Parsed_T]
+        | Callable[Concatenate[AnyC_T, P], Coroutine[Any, Any, Parsed_T]]
+    ):
+        plan, return_type = build_plan(func, path)
+        sig = inspect.signature(func)
+        origin = get_origin(return_type)
+        stream_item = get_args(return_type)[0] if origin in (Iterator, AsyncIterator) else None
+        is_raw_stream = stream_item is bytes
+        is_sse_stream = stream_item is Event
+        has_cookies = any(p.kind == "cookie" for p in plan)
+
+        def resolve_spec(self: BaseConsumer, *args: P.args, **kwargs: P.kwargs) -> RequestSpec:
+            """Binds call arguments against the stub signature and builds the request spec."""
+            bound = sig.bind(self, *args, **kwargs)
+            bound.apply_defaults()
+            jar = dict(self.session.cookies) if has_cookies else None
+            return build_request(method, path, plan, bound.arguments, jar=jar)
+
+        if inspect.iscoroutinefunction(func):
+            if is_sse_stream:
+
+                @functools.wraps(func)
+                async def async_sse_wrapper(
+                    self: AsyncConsumer, *args: P.args, **kwargs: P.kwargs
+                ) -> AsyncIterator[Event]:
+                    spec = resolve_spec(self, *args, **kwargs)
+                    return sse_async(self, spec)
+
+                return async_sse_wrapper  # type: ignore[return-value]
+
+            if is_raw_stream:
+
+                @functools.wraps(func)
+                async def async_stream_wrapper(
+                    self: AsyncConsumer, *args: P.args, **kwargs: P.kwargs
+                ) -> AsyncIterator[bytes]:
+                    spec = resolve_spec(self, *args, **kwargs)
+                    return stream_async(self, spec)
+
+                return async_stream_wrapper  # type: ignore[return-value]
+
+            @functools.wraps(func)
+            async def async_wrapper(
+                self: AsyncConsumer, *args: P.args, **kwargs: P.kwargs
+            ) -> Parsed_T:
+                spec = resolve_spec(self, *args, **kwargs)
+                response = await self.session.request(spec.method, spec.url, **spec.to_kwargs())
+                return decode(apply_response_handler(self, response), return_type)
+
+            return async_wrapper  # type: ignore[return-value]
+
+        if is_sse_stream:
+
+            @functools.wraps(func)
+            def sync_sse_wrapper(
+                self: SyncConsumer, *args: P.args, **kwargs: P.kwargs
+            ) -> Iterator[Event]:
+                spec = resolve_spec(self, *args, **kwargs)
+                return sse_sync(self, spec)
+
+            return sync_sse_wrapper  # type: ignore[return-value]
+
+        if is_raw_stream:
+
+            @functools.wraps(func)
+            def sync_stream_wrapper(
+                self: SyncConsumer, *args: P.args, **kwargs: P.kwargs
+            ) -> Iterator[bytes]:
+                spec = resolve_spec(self, *args, **kwargs)
+                return stream_sync(self, spec)
+
+            return sync_stream_wrapper  # type: ignore[return-value]
+
+        @functools.wraps(func)
+        def sync_wrapper(
+            self: SyncConsumer,
+            *args: P.args,
+            **kwargs: P.kwargs,
+        ) -> Parsed_T:
+            spec = resolve_spec(self, *args, **kwargs)
+            response = self.session.request(spec.method, spec.url, **spec.to_kwargs())
+            return decode(apply_response_handler(self, response), return_type)
+
+        return sync_wrapper  # type: ignore[return-value]
+
+    return decorate  # type: ignore[return-value]
+
+
+def get(
+    path: str,
+) -> EndpointDecorator:
+    """Declares a stub method as `GET {path}`."""
+    return endpoint("GET", path)
+
+
+def post(
+    path: str,
+) -> EndpointDecorator:
+    """Declares a stub method as `POST {path}`."""
+    return endpoint("POST", path)
+
+
+def put(
+    path: str,
+) -> EndpointDecorator:
+    """Declares a stub method as `PUT {path}`."""
+    return endpoint("PUT", path)
+
+
+def patch(
+    path: str,
+) -> EndpointDecorator:
+    """Declares a stub method as `PATCH {path}`."""
+    return endpoint("PATCH", path)
+
+
+def delete(
+    path: str,
+) -> EndpointDecorator:
+    """Declares a stub method as `DELETE {path}`."""
+    return endpoint("DELETE", path)
+
+
+def head(
+    path: str,
+) -> EndpointDecorator:
+    """Declares a stub method as `HEAD {path}`."""
+    return endpoint("HEAD", path)

mxhttp/markers.py

@@ -0,0 +1,200 @@
+"""Markers for HTTP request parameters inside `Annotated[...]`."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from types import UnionType
+from typing import TYPE_CHECKING, Union, get_args, get_origin
+
+from typing_extensions import Self
+
+from mxhttp.types import ParamValue, ValidPath_T
+
+if TYPE_CHECKING:
+    from inspect import Parameter
+
+
+def is_scalar_sequence(hint: type | None) -> bool:
+    """Checks whether `hint` is a `list`, `tuple`, or `Sequence` of scalar `ParamValue` objects."""
+    if get_origin(hint) not in (list, tuple, Sequence):
+        return False
+    item_types = [a for a in get_args(hint) if a is not Ellipsis]
+    return bool(item_types) and all(
+        isinstance(a, type) and issubclass(a, ParamValue) for a in item_types
+    )
+
+
+def validate_scalar_arg(
+    py_name: str, scalar_type: type | None, marker_name: str, *, allow_sequence: bool = False
+) -> None:
+    """Verifies that `Query`,`Field`, `Header`, or `Cookie` arguments have a scalar type."""
+    if allow_sequence and is_scalar_sequence(scalar_type):
+        return
+    if not isinstance(scalar_type, type) or not issubclass(scalar_type, ParamValue):
+        allowed = "str | int | float | bool"
+        if allow_sequence:
+            allowed += " | Sequence[str | int | float | bool]"
+        raise TypeError(f"{marker_name} argument {py_name!r} must be {allowed}")
+
+
+def is_file_content(hint: type | None) -> bool:
+    """Checks whether `hint` is bytes/str/file-like, or a `Union` of those, like `FileContent`."""
+    if get_origin(hint) in (Union, UnionType):
+        return all(is_file_content(a) for a in get_args(hint))
+    return hint in (bytes, str) or callable(getattr(hint, "read", None))
+
+
+def unwrap_optional(hint: type | None) -> tuple[type | None, bool]:
+    """Removes the `Optional` wrapper from a `None`-defaulted parameter annotation."""
+    if get_origin(hint) not in (UnionType, Union):
+        return hint, hint is None
+    args = get_args(hint)
+    non_none = [a for a in args if a is not type(None)]
+    return non_none[0] if len(non_none) == 1 else hint, len(args) > len(non_none)
+
+
+def is_optional_str(hint: type | None) -> bool:
+    """Checks whether `hint` is `str` or `str | None`."""
+    resolved, _ = unwrap_optional(hint)
+    return resolved is str
+
+
+def is_part_tuple(hint: type | None) -> bool:  # noqa: PLR0911
+    """Checks whether `hint` is a multipart file part tuple shape."""
+    if get_origin(hint) is not tuple:
+        return False
+    args = get_args(hint)
+    if len(args) < 2:  # noqa: PLR2004
+        return False
+    filename, content, *rest = args
+    if not is_optional_str(filename) or not is_file_content(content):
+        return False
+    match rest:
+        case []:
+            return True
+        case [content_type]:
+            return is_optional_str(content_type)
+        case [content_type, headers]:
+            return is_optional_str(content_type) and get_origin(headers) in (Mapping, dict)
+        case _:
+            return False
+
+
+class Marker:
+    """Base class for parameter-binding annotations inside `Annotated[...]`."""
+
+    __slots__ = ("name",)
+
+    def __init__(self, name: str | None = None) -> None:
+        """Initializes the tracker with an optional name."""
+        self.name = name
+
+    def __class_getitem__(cls, name: str) -> Self:
+        return cls(name)
+
+
+class Path(Marker):
+    """Binds a parameter to an URL path parameter."""
+
+    @staticmethod
+    def validate(py_name: str, path_type: type | None, is_optional: bool, param: Parameter) -> None:
+        """Verifies that path arguments have the correct type."""
+        if (
+            not isinstance(path_type, type)
+            or issubclass(path_type, bool)
+            or not issubclass(path_type, ValidPath_T)
+        ):
+            raise TypeError(f"Path argument {py_name!r} must be str | int | float")
+        if param.default is None:
+            raise TypeError(f"Path argument {py_name!r} must not default to None")
+        if is_optional:
+            raise TypeError(f"Path argument {py_name!r} must not be optional")
+
+
+class Query(Marker):
+    """Binds a parameter to an URL query string parameter, omitting `None` values."""
+
+    @classmethod
+    def validate(cls, name: str, resolved_hint: type | None) -> None:
+        """Verifies that a `Query` argument is a scalar and or a sequence of scalars."""
+        validate_scalar_arg(name, resolved_hint, cls.__name__, allow_sequence=True)
+
+
+class Field(Marker):
+    """Binds a parameter to a form field, omitting `None` values.
+
+    Encoded as `application/x-www-form-urlencoded`, unless the same call also has a `Part`
+    parameter, in which case the whole body becomes multipart instead.
+    """
+
+    @classmethod
+    def validate(cls, name: str, resolved_hint: type | None) -> None:
+        """Verifies that a `Field` argument is a scalar and or a sequence of scalars."""
+        validate_scalar_arg(name, resolved_hint, cls.__name__, allow_sequence=True)
+
+
+class Part(Marker):
+    """Binds a parameter to a multipart file part.
+
+    Converts the request body to multipart format, making any `Field` parameters on the
+    same call multipart fields instead of urlencoded.
+    """
+
+    @staticmethod
+    def validate(py_name: str, part_type: type | None) -> None:
+        """Verifies that a `Part` argument matches one of `httpx`'s accepted file-upload shapes.
+
+        `part_type` may be a `Union` of accepted shapes (e.g. the `PartValue` alias), so every
+        union member must be individually valid.
+        """
+        candidates = (
+            get_args(part_type) if get_origin(part_type) in (Union, UnionType) else [part_type]
+        )
+        if candidates and all(is_file_content(c) or is_part_tuple(c) for c in candidates):
+            return
+        raise TypeError(
+            f"Part argument {py_name!r} must be bytes | str | IO, optionally wrapped in a "
+            "(filename, content), (filename, content, content_type), or "
+            "(filename, content, content_type, headers) tuple"
+        )
+
+
+class Header(Marker):
+    """Binds a parameter to an HTTP request header and omits `None` values."""
+
+    @classmethod
+    def validate(cls, name: str, resolved_hint: type | None) -> None:
+        """Verifies that a `Header` argument is a scalar and not a sequence."""
+        validate_scalar_arg(name, resolved_hint, cls.__name__)
+
+
+class Cookie(Marker):
+    """Binds a parameter to a request cookie, omitting `None` values.
+
+    If the cookie jar already holds a cookie with this name, the jar value is sent
+    instead of this parameter value, unless `override=True` is set.
+    """
+
+    __slots__ = ("override",)
+
+    def __init__(self, name: str | None = None, *, override: bool = False) -> None:
+        """Initializes the cookie binding with an optional name and jar-override flag."""
+        super().__init__(name)
+        self.override = override
+
+    @classmethod
+    def validate(cls, name: str, resolved_hint: type | None) -> None:
+        """Verifies that a `Cookie` argument is a scalar and not a sequence."""
+        validate_scalar_arg(name, resolved_hint, cls.__name__)
+
+
+class Body:
+    """Binds a whole JSON-encodable parameter as the JSON request body."""
+
+    @staticmethod
+    def validate(py_name: str, body_type: type | None) -> None:
+        """Verifies that a `Body` argument is a object, not just a scalar."""
+        if isinstance(body_type, type) and issubclass(body_type, (*get_args(ParamValue), bytes)):
+            raise TypeError(
+                f"Body argument {py_name!r} must not be str | int | float | bool | bytes"
+            )

mxhttp/request.py

@@ -0,0 +1,231 @@
+"""Builds the `httpx.Request`."""
+
+from __future__ import annotations
+
+import inspect
+import string
+import urllib.parse
+from types import UnionType
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Concatenate,
+    ParamSpec,
+    TypedDict,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+import msgspec
+
+from mxhttp.markers import Body, Cookie, Field, Header, Marker, Part, Path, Query, unwrap_optional
+from mxhttp.response import Response
+from mxhttp.types import MISSING, AnyC_T, JsonValue, Param_T, Parsed_T, PartValue, QueryValue
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Collection, Coroutine, Mapping
+    from inspect import Parameter
+P = ParamSpec("P")
+
+
+class ParamPlan(msgspec.Struct):
+    """Stores the binding location for a single bound parameter in a request."""
+
+    py_name: str
+    wire_name: str
+    kind: Param_T
+    cookie_override: bool = False
+
+
+class RequestKwargs(TypedDict):
+    """Stores keyword arguments shared by every `session.request` or `session.stream` call."""
+
+    params: dict[str, QueryValue]
+    headers: dict[str, str] | None
+    data: dict[str, object] | None
+    files: dict[str, PartValue] | None
+    json: JsonValue
+
+
+class RequestSpec(msgspec.Struct):
+    """Stores a fully resolved request, ready to pass to `httpx`."""
+
+    method: str
+    url: str
+    params: dict[str, QueryValue]
+    headers: dict[str, str] | None
+    data: dict[str, object] | None
+    files: dict[str, PartValue] | None
+    json: JsonValue
+
+    def to_kwargs(self) -> RequestKwargs:
+        """Builds the keyword arguments shared by every `session.request`/`session.stream` call."""
+        return {
+            "params": self.params,
+            "headers": self.headers,
+            "data": self.data,
+            "files": self.files,
+            "json": self.json,
+        }
+
+
+def unwrap_hint(hint: type | None) -> tuple[type | None, bool, list[object]]:
+    """Unwraps nested `Optional` and `Annotated` layers in any order.
+
+    `get_type_hints` re-wraps `= None` parameters in `Optional[...]`, so the layers can nest
+    in either order and repeat.
+
+    Returns:
+        Tuple of the innermost type, whether `None` was found, and all markers.
+    """
+    is_optional = False
+    markers: list[object] = []
+    while True:
+        if get_origin(hint) is Annotated:
+            args = get_args(hint)
+            hint = args[0]
+            markers.extend(args[1:])
+            continue
+        unwrapped, hint_is_optional = unwrap_optional(hint)
+        is_optional = is_optional or hint_is_optional
+        if unwrapped is hint:
+            return hint, is_optional, markers
+        hint = unwrapped
+
+
+def classify(
+    name: str, hint: type | None, path_parts: Collection[str], param: Parameter
+) -> tuple[str, Marker | type[Body]]:
+    """Resolves the binding of a parameter: an explicit marker or an implicit path parameter."""
+    resolved_hint, is_optional, markers = unwrap_hint(hint)
+    for extra in markers:  # pragma: no branch
+        marker = extra() if extra in (Path, Query, Field, Part, Header, Cookie) else extra
+        if isinstance(marker, Path):
+            marker.validate(name, resolved_hint, is_optional, param)
+        if isinstance(marker, (Query, Field, Header, Cookie, Part)):
+            marker.validate(name, resolved_hint)
+        if isinstance(marker, Marker):
+            return (marker.name or name, marker)
+        if extra is Body:
+            Body.validate(name, resolved_hint)
+            return (name, Body)
+        raise TypeError(f"Unexpected extra: {extra}")
+    if name in path_parts:
+        Path.validate(name, resolved_hint, is_optional, param)
+        return (name, Path())
+    raise TypeError(f"Parameter {name!r} has no Query/Field/Part/Body binding or path match")
+
+
+def rejects_union(return_type: type) -> bool:
+    """A bare union, or `Response[...]` wrapping one directly, is not decodable."""
+    if get_origin(return_type) in (Union, UnionType):
+        return True
+    if get_origin(return_type) is Response:
+        (inner_type,) = get_args(return_type)
+        return get_origin(inner_type) in (Union, UnionType)
+    return False
+
+
+def build_plan(  # noqa: C901
+    func: Callable[Concatenate[AnyC_T, P], Parsed_T]
+    | Callable[Concatenate[AnyC_T, P], Coroutine[Any, Any, Parsed_T]],
+    path: str,
+) -> tuple[list[ParamPlan], type[Parsed_T]]:
+    """Builds a parameter plan and return type for a callable."""
+    hints: dict[str, type] = get_type_hints(func, include_extras=True)
+    return_type = hints.get("return", MISSING)
+    if return_type is MISSING:
+        raise ValueError("No return type annotated")
+    if rejects_union(return_type):
+        raise TypeError(f"Return type must not be a union: {return_type!r}")
+
+    path_parts = {name for _, name, _, _ in string.Formatter().parse(path) if name}
+
+    sig = inspect.signature(func)
+    plan: list[ParamPlan] = []
+    kind: Param_T
+    for py_name, param in sig.parameters.items():
+        if py_name == "self":
+            continue
+        wire_name, marker = classify(py_name, hints.get(py_name), path_parts, param)
+        if marker is Body:
+            kind = "body"
+        elif isinstance(marker, Path):
+            kind = "path"
+        elif isinstance(marker, Query):
+            kind = "query"
+        elif isinstance(marker, Field):
+            kind = "field"
+        elif isinstance(marker, Header):
+            kind = "header"
+        elif isinstance(marker, Cookie):
+            kind = "cookie"
+        else:
+            kind = "part"
+        cookie_override = marker.override if isinstance(marker, Cookie) else False
+        plan.append(
+            ParamPlan(
+                py_name=py_name, wire_name=wire_name, kind=kind, cookie_override=cookie_override
+            )
+        )
+    return plan, return_type
+
+
+def build_request(
+    method: str,
+    path: str,
+    plan: list[ParamPlan],
+    values: Mapping[str, object],
+    jar: Mapping[str, str] | None = None,
+) -> RequestSpec:
+    """Builds a request spec from the parameter plan and provided values.
+
+    Args:
+        method: HTTP method for the request.
+        path: URL path template with placeholders.
+        plan: Parameter plan describing how to map values to the request.
+        values: Mapping of parameter names to their values.
+        jar: Snapshot of the current cookie jar.
+    """
+    path_args: dict[str, object] = {}
+    params: dict[str, QueryValue] = {}
+    headers: dict[str, str] = {}
+    cookies: dict[str, str] = {}
+    fields: dict[str, object] = {}
+    files: dict[str, PartValue] = {}
+    body: JsonValue = None
+    for p in plan:
+        value = values.get(p.py_name)
+        if p.kind == "path":
+            path_args[p.wire_name] = value
+        elif value is None:
+            continue  # None values are omitted for queries, fields, headers, and cookies
+        elif p.kind == "query":
+            params[p.wire_name] = value  # type: ignore[assignment]
+        elif p.kind == "field":
+            fields[p.wire_name] = value
+        elif p.kind == "part":
+            files[p.wire_name] = value  # type: ignore[assignment]
+        elif p.kind == "header":
+            headers[p.wire_name] = str(value)
+        elif p.kind == "cookie":
+            jar_value = None if p.cookie_override else (jar or {}).get(p.wire_name)
+            cookies[p.wire_name] = jar_value if jar_value is not None else str(value)
+        else:
+            body = msgspec.to_builtins(value)
+    if cookies:
+        headers["cookie"] = "; ".join(
+            f"{k}={urllib.parse.quote(v, safe='')}" for k, v in cookies.items()
+        )
+    return RequestSpec(
+        method=method,
+        url=path.format(**{k: urllib.parse.quote(str(v), safe="") for k, v in path_args.items()}),
+        params=params,
+        headers=headers or None,
+        data=fields or None,
+        files=files or None,
+        json=body,
+    )

mxhttp/response.py

@@ -0,0 +1,174 @@
+"""Processing steps for the raw `httpx.Reponse`."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic, get_args, get_origin, overload
+
+import msgspec
+
+from mxhttp.sse import Event, SseBuilder
+from mxhttp.types import AnyC_T, Parsed_T, ResponseHandler, is_parsed_type
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Callable, Iterator
+    from types import ModuleType
+
+    import httpx
+
+    from mxhttp.consumer import AsyncConsumer, BaseConsumer, SyncConsumer
+    from mxhttp.request import RequestSpec
+
+
+class Response(msgspec.Struct, Generic[Parsed_T]):
+    """Wraps decoded `data` alongside the raw `httpx.Response`."""
+
+    data: Parsed_T
+    response: httpx.Response
+
+
+@overload
+def decode(
+    response: httpx.Response, return_type: type[Response[Parsed_T]]
+) -> Response[Parsed_T]: ...
+@overload
+def decode(response: httpx.Response, return_type: type[None]) -> None: ...
+@overload
+def decode(response: httpx.Response, return_type: type[Parsed_T]) -> Parsed_T: ...
+def decode(  # noqa: PLR0911
+    response: httpx.Response, return_type: type[Parsed_T | None]
+) -> Parsed_T | None:
+    """Decodes a HTTP response into the specified return type.
+
+    `httpx.Response` passes through, `str` and `bytes` use `.text` and `.content` directly,
+    `None` discards the body without decoding it, and `pydantic.BaseModel` subclasses
+    validate via `model_validate_json`. All other types decode via `msgspec.json.decode`.
+    """
+    import httpx
+
+    if not is_parsed_type(return_type):
+        return None
+
+    if get_origin(return_type) is Response:
+        (inner_type,) = get_args(return_type)
+        return Response(decode(response, inner_type), response)  # type: ignore[return-value]
+    if isinstance(return_type, type):  # pragma: no branch
+        if return_type is httpx.Response:
+            return response  # type: ignore[return-value]
+        if issubclass(return_type, str):
+            return response.text  # type: ignore[return-value]
+        if issubclass(return_type, bytes):
+            return response.content  # type: ignore[return-value]
+        pydantic: ModuleType | None
+        try:
+            import pydantic
+        except ImportError:  # pragma: no cover
+            pydantic = None
+        if pydantic is not None and issubclass(return_type, pydantic.BaseModel):
+            return return_type.model_validate_json(  # type: ignore[attr-defined, no-any-return]
+                response.content
+            )
+    return msgspec.json.decode(response.content, type=return_type)
+
+
+def apply_response_handler(self: BaseConsumer, response: httpx.Response) -> httpx.Response:
+    """Applies the response hook, defaults to `raise_for_status` if none is set."""
+    if self._response_handler:
+        return self._response_handler(response)
+    return response.raise_for_status()
+
+
+def apply_streaming_response_handler(
+    self: BaseConsumer, response: httpx.Response
+) -> httpx.Response:
+    """Applies the streaming response hook, defaults to `raise_for_status` if unset.
+
+    Only the status line and headers are available at this point.
+    """
+    if self._streaming_response_handler:
+        return self._streaming_response_handler(response)
+    return response.raise_for_status()
+
+
+def response_handler(
+    hook: ResponseHandler,
+) -> Callable[[type[AnyC_T]], type[AnyC_T]]:
+    """Class decorator that runs every raw response through `hook` before decoding.
+
+    Overrides the default hook, which calls `response.raise_for_status()`.
+    Does not apply to streaming endpoints. Use `@streaming_response_handler` for those.
+    """
+
+    def decorate(cls: type[AnyC_T]) -> type[AnyC_T]:
+        cls._response_handler = staticmethod(hook)
+        return cls
+
+    return decorate
+
+
+def streaming_response_handler(
+    hook: ResponseHandler,
+) -> Callable[[type[AnyC_T]], type[AnyC_T]]:
+    """Class decorator that runs every streaming response through `hook` before yielding.
+
+    Applies only to streaming endpoints. Use `@response_handler` for other endpoints.
+    Only the status line and headers can be inspected.
+    """
+
+    def decorate(cls: type[AnyC_T]) -> type[AnyC_T]:
+        cls._streaming_response_handler = staticmethod(hook)
+        return cls
+
+    return decorate
+
+
+def stream_sync(self: SyncConsumer, spec: RequestSpec) -> Iterator[bytes]:
+    """Streams the response body in chunks instead of buffering it.
+
+    Runs the `@streaming_response_handler` hook before yielding events.
+    Any incomplete event when the stream ends is discarded.
+    """
+    with self.session.stream(spec.method, spec.url, **spec.to_kwargs()) as response:
+        apply_streaming_response_handler(self, response)
+        yield from response.iter_bytes()
+
+
+async def stream_async(self: AsyncConsumer, spec: RequestSpec) -> AsyncIterator[bytes]:
+    """Streams the response body in chunks instead of buffering it.
+
+    Runs the `@streaming_response_handler` hook before yielding events.
+    Any incomplete event when the stream ends is discarded.
+    """
+    async with self.session.stream(spec.method, spec.url, **spec.to_kwargs()) as response:
+        apply_streaming_response_handler(self, response)
+        async for chunk in response.aiter_bytes():
+            yield chunk
+
+
+def sse_sync(self: SyncConsumer, spec: RequestSpec) -> Iterator[Event]:
+    """Streams the response as parsed Server-Sent Events.
+
+    Runs the `@streaming_response_handler` hook before yielding events.
+    Any incomplete event when the stream ends is discarded.
+    """
+    builder = SseBuilder()
+    with self.session.stream(spec.method, spec.url, **spec.to_kwargs()) as response:
+        apply_streaming_response_handler(self, response)
+        for line in response.iter_lines():
+            event = builder.feed(line)
+            if event is not None:
+                yield event
+
+
+async def sse_async(self: AsyncConsumer, spec: RequestSpec) -> AsyncIterator[Event]:
+    """Streams the response as parsed Server-Sent Events.
+
+    Runs the `@streaming_response_handler` hook before yielding events.
+    Any incomplete event when the stream ends is discarded.
+    """
+    builder = SseBuilder()
+    async with self.session.stream(spec.method, spec.url, **spec.to_kwargs()) as response:
+        apply_streaming_response_handler(self, response)
+        async for line in response.aiter_lines():
+            event = builder.feed(line)
+            if event is not None:
+                yield event

mxhttp/sse.py

@@ -0,0 +1,60 @@
+"""Handles Server-Sent Event streams."""
+
+from __future__ import annotations
+
+from typing import get_args
+
+import msgspec
+
+from mxhttp.types import SseField_T
+
+SSE_FIELDS: frozenset[SseField_T] = frozenset(get_args(SseField_T))
+
+
+class Event(msgspec.Struct):
+    """Stores a parsed Server-Sent Event."""
+
+    data: str = ""
+    """The raw payload."""
+    event: str = "message"
+    id: str | None = None
+    retry: int | None = None
+
+
+class SseBuilder(msgspec.Struct):
+    """Builds SSE field lines into `Event` objects, one per blank-line-terminated block."""
+
+    data_lines: list[str] = []
+    event: str = "message"
+    last_id: str | None = None
+    retry: int | None = None
+
+    def feed(self, line: str) -> Event | None:
+        """Feeds one decoded line and returns a completed `Event` on a blank line, else `None`."""
+        if not line:
+            if not self.data_lines:
+                return None  # a blank line with nothing accumulated dispatches nothing
+            built = Event(
+                data="\n".join(self.data_lines),
+                event=self.event,
+                id=self.last_id,
+                retry=self.retry,
+            )
+            self.data_lines = []
+            self.event = "message"
+            return built
+        if line.startswith(":"):
+            return None  # comment line
+        field, _, value = line.partition(":")
+        if field not in SSE_FIELDS:
+            return None  # unrecognized field, per spec
+        value = value.removeprefix(" ")
+        if field == "data":
+            self.data_lines.append(value)
+        elif field == "event":
+            self.event = value
+        elif field == "id":
+            self.last_id = value
+        elif value.isdigit():  # field == "retry"
+            self.retry = int(value)
+        return None

mxhttp/types.py

@@ -0,0 +1,79 @@
+"""Defines models and types for the HTTP client."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from enum import Enum, auto
+from typing import IO, TYPE_CHECKING, Literal, TypeAlias, TypeVar
+
+from typing_extensions import TypeIs
+
+if TYPE_CHECKING:
+    import httpx
+    import msgspec
+    from _typeshed import DataclassInstance
+    from attrs import AttrsInstance
+
+    from mxhttp.consumer import AsyncConsumer, BaseConsumer, SyncConsumer  # cyclic
+
+
+class Missing(Enum):
+    """Sentinel value representing a missing or absent field."""
+
+    SENTINEL = auto()
+
+
+MISSING = Missing.SENTINEL
+"""Sentinel value representing a missing or absent field."""
+
+AnyC_T = TypeVar("AnyC_T", bound="BaseConsumer")
+SyncC_T = TypeVar("SyncC_T", bound="SyncConsumer")
+AsyncC_T = TypeVar("AsyncC_T", bound="AsyncConsumer")
+
+JsonValue: TypeAlias = bool | int | float | str | list["JsonValue"] | dict[str, "JsonValue"] | None
+TypedDictLike: TypeAlias = "Mapping[str, object]"
+DataclassLike: TypeAlias = "msgspec.Struct | DataclassInstance | AttrsInstance | TypedDictLike"
+JsonDecodable: TypeAlias = "JsonValue | DataclassLike"
+Parsed_T = TypeVar(
+    "Parsed_T",
+    bound=(
+        "httpx.Response | str | bytes | DataclassLike | Sequence[JsonDecodable] | Mapping[str, JsonDecodable]"  # noqa: E501
+    ),
+)
+"""Raw response, raw content, dataclass-like structures, or JSON-decodable types."""
+
+Param_T: TypeAlias = Literal["path", "body", "query", "field", "part", "header", "cookie"]
+"""HTTP request parameters."""
+
+Method_T: TypeAlias = Literal["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"]
+"""HTTP methods."""
+
+SseField_T: TypeAlias = Literal["data", "event", "id", "retry"]
+"""Accepted SSE line prefixes, others are ignored."""
+
+ValidPath_T: TypeAlias = str | int | float
+"""Allowed types for a path argument."""
+
+FileContent: TypeAlias = bytes | str | IO[bytes]
+"""The content of a multipart file part: in-memory bytes/text, or a file-like object."""
+
+PartValue: TypeAlias = (
+    FileContent
+    | tuple[str | None, FileContent]
+    | tuple[str | None, FileContent, str | None]
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+"""A multipart file part: bare content, or a (filename, content, content-type, headers) tuple."""
+
+ParamValue = str | int | float | bool
+"""A scalar query, field, header, or cookie value accepted by `httpx`."""
+
+QueryValue: TypeAlias = "ParamValue | Sequence[ParamValue]"
+"""A `ParamValue` scalar or a sequence of those, repeated as `key=a&key=b&...`."""
+
+ResponseHandler: TypeAlias = "Callable[[httpx.Response], httpx.Response]"
+
+
+def is_parsed_type(return_type: type[Parsed_T | None]) -> TypeIs[type[Parsed_T]]:
+    """Check whether the `return_type` is not `NoneType`."""
+    return return_type is not type(None)

mxhttp-1.0.0.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: mxhttp
+Version: 1.0.0
+Summary: Simple HTTP API consumer based on `httpx` and `msgspec`.
+Keywords: http,httpx,msgspec,rest,api,client,declarative,typing
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/audivir/mxhttp
+Project-URL: Repository, https://github.com/audivir/mxhttp
+Project-URL: Issues, https://github.com/audivir/mxhttp/issues
+Requires-Python: >=3.10
+Requires-Dist: httpx
+Requires-Dist: msgspec
+Requires-Dist: typing-extensions
+Provides-Extra: pydantic
+Requires-Dist: pydantic; extra == "pydantic"
+Description-Content-Type: text/markdown
+
+# mxhttp
+
+Declarative **HTTP** client on top of _**m**sgspec_ and _http**x**_. Write an API as a class of annotated stub methods and `mxhttp` will handle the rest (request building, sending, and response decoding).
+
+## Install
+
+```bash
+pip install mxhttp
+```
+
+## Usage
+
+```python
+from typing import Annotated
+import msgspec
+from mxhttp import Body, Query, SyncConsumer, get, post
+
+
+class Item(msgspec.Struct):
+    id: int
+    name: str
+    price: float
+
+
+class NewItem(msgspec.Struct):
+    name: str
+    price: float
+
+
+class Shop(SyncConsumer):
+    @get("/items/{item_id}")
+    def get_item(self, item_id: int) -> Item: ...  # type: ignore[empty-body]
+
+    @get("/search")
+    def search(self, q: Annotated[str, Query], limit: Annotated[int, Query] = 20) -> list[Item]: ...  # type: ignore[empty-body]
+
+    @post("/items")
+    def create_item(self, item: Annotated[NewItem, Body]) -> Item: ...  # type: ignore[empty-body]
+
+
+shop = Shop("https://api.example.com")
+item = shop.get_item(item_id=7)
+new = shop.create_item(item=NewItem(name="Gadget", price=4.5))
+```
+
+The method body is never run as it is replaced by the decorator. Parameters are bound based on their `Annotated[...]` marker:
+
+| Marker class         | Request Target      | Info                                                                                                                                                                      |
+|----------------------|---------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `Path` (or implicit) | Path                | Matched by parameter name unless annotated explicitly (`Path["name"]`). Must be a non-nullable `str`, `int`, or `float`.                                                  |
+| `Query`              | Query               | Must be a nullable `str`, `int`, `float`, or `bool`, or a `Sequence` of those, sent as `key=a&key=b&...`.                                                                 |
+| `Field`              | Form Field          | `application/x-www-form-urlencoded`. Accepts same types as `Query`.                                                                                                       |
+| `Part`               | Multipart File Part | Forces the whole request to be multipart and any `Field` params on the same call will become multipart fields as well. Accepts the same types `httpx` takes for `files=`. |
+| `Header`             | HTTP Header         | Must be `str`, `int`, `float`, or `bool`, but no list of those.                                                                                                           |
+| `Cookie`             | Cookie              | Is superseded by the cookie jar of the client if it already has a same-named cookie, unless `override=True` is set. Accepts same types as `Header`                        |
+| `Body`               | JSON Body           | Whole object, serialized with `msgspec.to_builtins`. Can't be a scalar type.                                                                                              |
+
+- Use `Path["name"]`, `Query["name"]`, `Field["name"]`, `Header["name"]`, or `Cookie["name"]` to bind under a different name than the parameter (e.g. reserved `from`, or a header like `X-Request-Id`, unsupported string format arguments like `?`).
+- `None`-valued `Query`, `Field`, `Header`, and `Cookie` parameters are omitted from the request.
+- `Path` parameters cannot be optional as a placeholder cannot be ommited from the URL.
+- Mismatched marker/type combinations raise a `TypeError` as soon as the class body runs, not at call time.
+
+### Decoding the response
+
+The return type defines the reponse decoding:
+- `httpx.Response` for the raw response.
+- `str` or `bytes` for the corresponding `.text` or `.content` with no JSON round-trip.
+- `pydantic.BaseModel` subclasses via their own `.model_validate_json`.
+- Anything else `msgspec.json.decode` can decode: `msgspec.Struct`, dataclasses, `TypedDict`, `NamedTuple`, and `list`, `dict`, or other containers of those.
+- `Response[Item]` for a small struct with the decoded `Item` as `.data` and the raw `httpx.Response` in `.response`.
+- Plain `attrs` classes are decoded by `msgspec`, for type hinting `attrs` is needed as dependency.
+
+For an async client, subclass `AsyncConsumer` and declare the methods `async def`, everything else stays the same.
+
+### Response handling
+
+By default, every response is checked by `response.raise_for_status()` before decoding, so errors during the request raise `httpx.HTTPStatusError` automatically. This behavior can be overriden by `@response_handler` decorator for the class.
+
+```python
+import httpx
+from mxhttp import response_handler
+
+
+def ignore_errors(response: httpx.Response) -> httpx.Response:
+    return response
+
+
+@response_handler(ignore_errors)
+class Shop(SyncConsumer): ...
+```
+
+The hook runs on every response before decoding.
+
+### Streaming responses
+
+Annotate the return type as `Iterator[bytes]` (sync) or `AsyncIterator[bytes]` (async) to stream the response body in chunks.
+
+```python
+from collections.abc import AsyncIterator, Iterator
+
+
+class Files(SyncConsumer):
+    @get("/files/{file_id}")
+    def download(self, file_id: int) -> Iterator[bytes]: ...  # type: ignore[empty-body]
+
+
+for chunk in shop_files.download(file_id=7):
+    ...
+
+class AsyncFiles(AsyncConsumer)
+    @get("/files/{file_id}")
+    def download(self, file_id: int) -> AsyncIterator[bytes]: ...  # type: ignore[empty-body]
+
+async for chunk in await shop_async_files.download(file_id=7):
+    ...
+```
+
+`httpx` already decompresses chunks before responding according to `Content-Encoding` (gzip/deflate/br/zstd).
+
+Streaming responses run `@streaming_response_handler` instead of `@response_handler` (defaults to `raise_for_status` as well).
+The handler can only inspect status line and headers.
+
+```python
+from mxhttp import streaming_response_handler
+
+
+def check_status(response: httpx.Response) -> httpx.Response:
+    response.raise_for_status()
+    return response
+
+
+@streaming_response_handler(check_status)
+class Files(SyncConsumer): ...
+```
+
+### Server-Sent Events
+
+Annotate the return type as `Iterator[Event]` (sync) or `AsyncIterator[Event]` (async) to parse the response as a Server-Sent Events stream instead of raw bytes:
+
+```python
+from collections.abc import Iterator
+from mxhttp import Event
+
+
+class Chat(SyncConsumer):
+    @get("/stream")
+    def events(self) -> Iterator[Event]: ...  # type: ignore[empty-body]
+
+
+for event in chat.events():
+    print(event.event, event.data)  # event.event defaults to "message"
+```
+
+`Event` has four attributes, `data`, `event`, `id`, and `retry`:
+- `data` is the raw payload, decode it manually if the server sends JSON.
+- Multi-line `data` fields are joined with `\n`.
+- `id` and `retry` persist across events once set and reset on reconnect only.
+- An event without a trailing blank line at the end of the stream is discarded.
+
+SSE streams use `@streaming_response_handler` matching byte streaming above.
+
+## Further configuration
+
+The underlying `httpx.Client` or `httpx.AsyncClient` is stored at `.session` to set default headers, auth, or timeouts.
+
+## Typing
+
+The package and all its generators are typed.
+
+## Tests
+
+```bash
+pytest
+```
+
+## Acknowledgements
+
+`mxhttp` is inspired by [Uplink](https://github.com/prkumar/uplink) but combining it with Python typing features.

mxhttp-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+mxhttp-1.0.0.dist-info/METADATA,sha256=ITPwUHMUbVVwitV_vwNZ18s4h9H_oGIdz7U6smYPW-4,8402
+mxhttp-1.0.0.dist-info/WHEEL,sha256=VP-D4TPS230sME9Z3vb3INXvo1yt0924YRm5AOsk_dE,90
+mxhttp-1.0.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+mxhttp-1.0.0.dist-info/licenses/LICENSE,sha256=OorQaF5r-zKnjJfsc350yUOKGYNbJCU1iMrycfu1TiM,1069
+mxhttp/__init__.py,sha256=D4mUBD3oSt2LUdFe-qOUjWZx_0PsACnw1KOJUPW9MY8,795
+mxhttp/consumer.py,sha256=Lvwr-HKrqtgciCSdjMYvlcQ7780ZOB3FZRBY8ggHh3c,2709
+mxhttp/endpoint.py,sha256=oGD4ZXxwW48obIkbevyjcTB7FMcXzvVE7JLjsz1MYgA,7102
+mxhttp/markers.py,sha256=az_w0Hakj8p2PONlaXYF4zCgXyBXMrcQmnlTsbnBAv8,7622
+mxhttp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mxhttp/request.py,sha256=ZMVPUgEGyYRC39l7UiSnB8elVWtDD1a7eNyiAx09biQ,7895
+mxhttp/response.py,sha256=EvepcSen-on800NGO8H9cTnTvUun2OHd_dZvyO05x3U,6445
+mxhttp/sse.py,sha256=K8PP6e7-UK1IJlDqOZ-eKZiIUSyU1_QhQx7RPogeMfs,1806
+mxhttp/types.py,sha256=KIm84Ken2MDUGhEILgpxWaDA-Jm0oclV2vk_XWYHDXY,2802
+mxhttp-1.0.0.dist-info/RECORD,,

mxhttp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.9)
+Root-Is-Purelib: true
+Tag: py3-none-any

mxhttp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+

mxhttp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tim Hörmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.