mxhttp 1.0.0__tar.gz → 1.1.0__tar.gz

{mxhttp-1.0.0 → mxhttp-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mxhttp
-Version: 1.0.0
+Version: 1.1.0
 Summary: Simple HTTP API consumer based on `httpx` and `msgspec`.
 Keywords: http,httpx,msgspec,rest,api,client,declarative,typing
 License-Expression: MIT
@@ -83,6 +83,27 @@ The method body is never run as it is replaced by the decorator. Parameters are
 - `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.
+- `Literal[...]` and `Enum` types are accepted where scalar types are (`Path`, `Query`, `Field`, `Header`, `Cookie`). Every literal value or enum member value must be `str`, `int`, or `float` (plus `bool` outside of `Path`). `Enum` members are serialized by their `.value`.
+
+### Inline query parameters
+
+A path template can bake query parameters directly into the string:
+
+```python
+class Shop(SyncConsumer):
+    @get("/items?category={cat}")
+    def by_category(self, cat: str) -> list[Item]: ...  # type: ignore[empty-body]
+```
+
+- An unmarked parameter binds implicitly to a `{name}` placeholder, same mechanism as `Path`.
+- `Query["cat"]` binds it to a different parameter name. Unlike every other `Marker`, the brackets aren't the wire name here — the wire name is whatever query key the template assigned to `{cat}`.
+- A query entry with no placeholder (e.g. `?active=true`) is a static value sent on every call. That key also cannot be reused by a dynamic `Query` parameter.
+- Each query key, and each placeholder field, can only be used once per path template (e.g. `/things?a={x}&a={y}` is rejected).
+- A placeholder field also cannot be reused by a real path segment (`/{id}?other={id}` is rejected).
+- A placeholder cannot be mixed with literal text in the same value (`key=prefix{name}`), and cannot stand in for the key itself (`{name}` with no `=`).
+- Every `{name}` field must be bound by exactly one parameter (implicit, `Path["name"]`, or `Query["name"]`).
+- An inline query field cannot be a `Sequence` as the placeholder reserves exactly one query spot.
+- All of the above raise a `TypeError` as soon as the class body runs, not at call time.
 
 ### Decoding the response
 
@@ -131,10 +152,12 @@ class Files(SyncConsumer):
 for chunk in shop_files.download(file_id=7):
     ...
 
-class AsyncFiles(AsyncConsumer)
+
+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):
     ...
 ```

{mxhttp-1.0.0 → mxhttp-1.1.0}/README.md

@@ -59,6 +59,27 @@ The method body is never run as it is replaced by the decorator. Parameters are
 - `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.
+- `Literal[...]` and `Enum` types are accepted where scalar types are (`Path`, `Query`, `Field`, `Header`, `Cookie`). Every literal value or enum member value must be `str`, `int`, or `float` (plus `bool` outside of `Path`). `Enum` members are serialized by their `.value`.
+
+### Inline query parameters
+
+A path template can bake query parameters directly into the string:
+
+```python
+class Shop(SyncConsumer):
+    @get("/items?category={cat}")
+    def by_category(self, cat: str) -> list[Item]: ...  # type: ignore[empty-body]
+```
+
+- An unmarked parameter binds implicitly to a `{name}` placeholder, same mechanism as `Path`.
+- `Query["cat"]` binds it to a different parameter name. Unlike every other `Marker`, the brackets aren't the wire name here — the wire name is whatever query key the template assigned to `{cat}`.
+- A query entry with no placeholder (e.g. `?active=true`) is a static value sent on every call. That key also cannot be reused by a dynamic `Query` parameter.
+- Each query key, and each placeholder field, can only be used once per path template (e.g. `/things?a={x}&a={y}` is rejected).
+- A placeholder field also cannot be reused by a real path segment (`/{id}?other={id}` is rejected).
+- A placeholder cannot be mixed with literal text in the same value (`key=prefix{name}`), and cannot stand in for the key itself (`{name}` with no `=`).
+- Every `{name}` field must be bound by exactly one parameter (implicit, `Path["name"]`, or `Query["name"]`).
+- An inline query field cannot be a `Sequence` as the placeholder reserves exactly one query spot.
+- All of the above raise a `TypeError` as soon as the class body runs, not at call time.
 
 ### Decoding the response
 
@@ -107,10 +128,12 @@ class Files(SyncConsumer):
 for chunk in shop_files.download(file_id=7):
     ...
 
-class AsyncFiles(AsyncConsumer)
+
+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):
     ...
 ```

{mxhttp-1.0.0 → mxhttp-1.1.0}/mxhttp/__init__.py

@@ -9,7 +9,7 @@ from mxhttp.response import Response, response_handler, streaming_response_handl
 from mxhttp.sse import Event
 from mxhttp.types import PartValue
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 
 __all__ = [
     "AsyncConsumer",

{mxhttp-1.0.0 → mxhttp-1.1.0}/mxhttp/endpoint.py

@@ -16,6 +16,7 @@ from typing import (
     overload,
 )
 
+from mxhttp.parse import split_path_template
 from mxhttp.request import RequestSpec, build_plan, build_request
 from mxhttp.response import (
     apply_response_handler,
@@ -93,7 +94,8 @@ def endpoint(method: Method_T, path: str) -> EndpointDecorator:  # noqa: C901
         Callable[Concatenate[AnyC_T, P], Parsed_T]
         | Callable[Concatenate[AnyC_T, P], Coroutine[Any, Any, Parsed_T]]
     ):
-        plan, return_type = build_plan(func, path)
+        parsed = split_path_template(path)
+        plan, return_type = build_plan(func, parsed)
         sig = inspect.signature(func)
         origin = get_origin(return_type)
         stream_item = get_args(return_type)[0] if origin in (Iterator, AsyncIterator) else None
@@ -106,7 +108,7 @@ def endpoint(method: Method_T, path: str) -> EndpointDecorator:  # noqa: C901
             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)
+            return build_request(method, parsed, plan, bound.arguments, jar=jar)
 
         if inspect.iscoroutinefunction(func):
             if is_sse_stream:

{mxhttp-1.0.0 → mxhttp-1.1.0}/mxhttp/markers.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 from collections.abc import Mapping, Sequence
+from enum import Enum
 from types import UnionType
-from typing import TYPE_CHECKING, Union, get_args, get_origin
+from typing import TYPE_CHECKING, Literal, Union, get_args, get_origin
 
 from typing_extensions import Self
 
@@ -14,14 +15,37 @@ if TYPE_CHECKING:
     from inspect import Parameter
 
 
+def scalar_value_types(hint: type | None) -> tuple[type, ...] | None:
+    """Returns the concrete runtime types backing a `Literal[...]` or `Enum`, else `None`."""
+    if get_origin(hint) is Literal:
+        return tuple({type(v) for v in get_args(hint)})
+    if isinstance(hint, type) and issubclass(hint, Enum):
+        return tuple({type(member.value) for member in hint})
+    return None
+
+
+def is_valid_scalar(
+    hint: type | None, allowed: type | UnionType, *, forbid_bool: bool = False
+) -> bool:
+    """Checks whether `hint` (a type, `Literal[...]`, or `Enum` subclass) matches `allowed`."""
+    value_types = scalar_value_types(hint)
+    if value_types is None:
+        if not isinstance(hint, type) or get_origin(hint) is not None:
+            return False
+        value_types = (hint,)
+    if not value_types:
+        return False
+    if forbid_bool and any(issubclass(t, bool) for t in value_types):
+        return False
+    return all(issubclass(t, allowed) for t in value_types)
+
+
 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
-    )
+    return bool(item_types) and all(is_valid_scalar(a, ParamValue) for a in item_types)
 
 
 def validate_scalar_arg(
@@ -30,7 +54,7 @@ def validate_scalar_arg(
     """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):
+    if not is_valid_scalar(scalar_type, ParamValue):
         allowed = "str | int | float | bool"
         if allow_sequence:
             allowed += " | Sequence[str | int | float | bool]"
@@ -99,11 +123,7 @@ class Path(Marker):
     @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)
-        ):
+        if not is_valid_scalar(path_type, ValidPath_T, forbid_bool=True):
             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")
@@ -115,9 +135,14 @@ 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)
+    def validate(
+        cls, name: str, resolved_hint: type | None, *, allow_sequence: bool = True
+    ) -> None:
+        """Verifies that a `Query` argument is a scalar and or a sequence of scalars.
+
+        `allow_sequence` is `False` for inline queries.
+        """
+        validate_scalar_arg(name, resolved_hint, cls.__name__, allow_sequence=allow_sequence)
 
 
 class Field(Marker):
@@ -142,7 +167,7 @@ class Part(Marker):
 
     @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.
+        """Verifies that a `Part` argument matches one of the file-upload shapes `httpx` accepts.
 
         `part_type` may be a `Union` of accepted shapes (e.g. the `PartValue` alias), so every
         union member must be individually valid.

mxhttp-1.1.0/mxhttp/parse.py

@@ -0,0 +1,93 @@
+"""Parses a path template into its path portion and any inline query bindings."""
+
+from __future__ import annotations
+
+import string
+import urllib.parse
+import uuid
+from typing import NamedTuple
+
+
+class ParsedPath(NamedTuple):
+    """Pieces of a path template split by `split_path_template()`."""
+
+    path_only: str
+    static_query: dict[str, str]
+    inline_query_names: dict[str, str]
+
+
+def reescape(literal_text: str) -> str:
+    """Re-escapes braces `str.Formatter().parse()` unescaped."""
+    return literal_text.replace("{", "{{").replace("}", "}}")
+
+
+def unescape(text: str) -> str:
+    """Undoes `reescape()`."""
+    return text.replace("{{", "{").replace("}}", "}")
+
+
+def split_path_template(path: str) -> ParsedPath:  # noqa: C901, PLR0912
+    """Splits a path template into its path portion and its query string, if any.
+
+    Returns:
+        `ParsedPath` of the bare path, static `key: value` query entries, and `py_name:
+        wire_name` pairs for inline query placeholders.
+
+    Raises:
+        TypeError: If a `{name}` field has a format spec or conversion, is anonymous or
+            positional, mixes a placeholder with literal text in a query value, uses a bare
+            placeholder as its own query key, reuses a query key or field name, or reuses a
+            field name of a path segment as an inline query placeholder.
+    """
+    marker = uuid.uuid4().hex
+    names: list[str] = []
+    clean_parts: list[str] = []
+    for literal_text, field_name, format_spec, conversion in string.Formatter().parse(path):
+        clean_parts.append(reescape(literal_text))
+        if field_name is None:
+            continue
+        if format_spec or conversion:
+            raise TypeError(f"Field {field_name!r} must not have a format spec or conversion")
+        if not field_name or field_name.isdigit():
+            raise TypeError("Anonymous ('{}') or positional ('{0}') fields are not supported")
+        names.append(field_name)
+        clean_parts.append(f"{marker}{len(names) - 1}_")
+    split = urllib.parse.urlsplit("".join(clean_parts))
+
+    path_field_count = split.path.count(marker)
+    path_only = split.path
+    path_field_names = set(names[:path_field_count])
+    for index, name in enumerate(names[:path_field_count]):
+        path_only = path_only.replace(f"{marker}{index}_", f"{{{name}}}")
+
+    static_query: dict[str, str] = {}
+    inline_query_names: dict[str, str] = {}
+    used_keys: set[str] = set()
+    for key, value in urllib.parse.parse_qsl(split.query, keep_blank_values=True):
+        if marker in key:
+            raise TypeError(
+                "Inline query parameters must supply an explicit key (e.g. 'key={name}')"
+            )
+        if key in used_keys:
+            raise TypeError(f"Query key {key!r} is used more than once")
+        used_keys.add(key)
+
+        token = value.removeprefix(marker)
+        index_text, sep, rest = token.partition("_")
+        if value.startswith(marker) and sep and not rest and index_text.isdigit():
+            field = names[int(index_text)]
+            if field in inline_query_names:
+                raise TypeError(f"Field {field!r} must not be bound multiple times")
+            if field in path_field_names:
+                raise TypeError(
+                    f"Field {field!r} is used for both a path segment and an inline query "
+                    "parameter; give one of them a different placeholder name"
+                )
+            inline_query_names[field] = key
+        elif marker in value:
+            raise TypeError(
+                f"Inline query parameter {key!r} must be a literal value or a bare placeholder"
+            )
+        else:
+            static_query[unescape(key)] = unescape(value)
+    return ParsedPath(path_only, static_query, inline_query_names)

{mxhttp-1.0.0 → mxhttp-1.1.0}/mxhttp/request.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import inspect
 import string
 import urllib.parse
+from enum import Enum
 from types import UnionType
 from typing import (
     TYPE_CHECKING,
@@ -28,6 +29,8 @@ from mxhttp.types import MISSING, AnyC_T, JsonValue, Param_T, Parsed_T, PartValu
 if TYPE_CHECKING:
     from collections.abc import Callable, Collection, Coroutine, Mapping
     from inspect import Parameter
+
+    from mxhttp.parse import ParsedPath
 P = ParamSpec("P")
 
 
@@ -43,7 +46,7 @@ class ParamPlan(msgspec.Struct):
 class RequestKwargs(TypedDict):
     """Stores keyword arguments shared by every `session.request` or `session.stream` call."""
 
-    params: dict[str, QueryValue]
+    params: dict[str, QueryValue] | None
     headers: dict[str, str] | None
     data: dict[str, object] | None
     files: dict[str, PartValue] | None
@@ -55,7 +58,7 @@ class RequestSpec(msgspec.Struct):
 
     method: str
     url: str
-    params: dict[str, QueryValue]
+    params: dict[str, QueryValue] | None
     headers: dict[str, str] | None
     data: dict[str, object] | None
     files: dict[str, PartValue] | None
@@ -72,6 +75,13 @@ class RequestSpec(msgspec.Struct):
         }
 
 
+def scalar_str(value: object) -> str:
+    """Converts a scalar value to a string, using `.value` from `Enum` object."""
+    if isinstance(value, Enum):
+        value = value.value
+    return str(value)
+
+
 def unwrap_hint(hint: type | None) -> tuple[type | None, bool, list[object]]:
     """Unwraps nested `Optional` and `Annotated` layers in any order.
 
@@ -96,15 +106,54 @@ def unwrap_hint(hint: type | None) -> tuple[type | None, bool, list[object]]:
         hint = unwrapped
 
 
-def classify(
-    name: str, hint: type | None, path_parts: Collection[str], param: Parameter
+def resolve_inline_query(
+    marker: Query, name: str, resolved_hint: type | None, inline_query_names: Mapping[str, str]
+) -> tuple[str, Marker] | None:
+    """Resolves an explicit `Query[...]` marker against an inline query field, if it names one.
+
+    Returns:
+        The resolved `(wire_name, marker)` pair, or `None` if the marker doesn't name an inline
+        query field.
+
+    Raises:
+        TypeError: If the marker targets wire name of an inline field directly instead of its
+            placeholder name, which would bypass own validation of the field.
+    """
+    lookup_name = marker.name or name
+    if lookup_name in inline_query_names:
+        marker.validate(name, resolved_hint, allow_sequence=False)
+        return (inline_query_names[lookup_name], marker)
+    if lookup_name in inline_query_names.values():
+        raise TypeError(
+            f"Query argument {name!r} targets wire name {lookup_name!r} directly"
+            " which is reserved by an inline query"
+        )
+    return None
+
+
+def classify(  # noqa: C901
+    name: str,
+    hint: type | None,
+    path_parts: Collection[str],
+    inline_query_names: Mapping[str, str],
+    param: Parameter,
 ) -> tuple[str, Marker | type[Body]]:
-    """Resolves the binding of a parameter: an explicit marker or an implicit path parameter."""
+    """Resolves the binding of a parameter: with explicit marker or implicit path/inline query."""
     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):
+            lookup_name = marker.name or name
+            if lookup_name not in path_parts:
+                raise TypeError(
+                    f"Path argument {name!r} targets field {lookup_name!r}, but it doesn't "
+                    "appear in the path template"
+                )
             marker.validate(name, resolved_hint, is_optional, param)
+        if isinstance(marker, Query):
+            resolved = resolve_inline_query(marker, name, resolved_hint, inline_query_names)
+            if resolved is not None:
+                return resolved
         if isinstance(marker, (Query, Field, Header, Cookie, Part)):
             marker.validate(name, resolved_hint)
         if isinstance(marker, Marker):
@@ -113,6 +162,9 @@ def classify(
             Body.validate(name, resolved_hint)
             return (name, Body)
         raise TypeError(f"Unexpected extra: {extra}")
+    if name in inline_query_names:
+        Query.validate(name, resolved_hint, allow_sequence=False)
+        return (inline_query_names[name], Query())
     if name in path_parts:
         Path.validate(name, resolved_hint, is_optional, param)
         return (name, Path())
@@ -129,10 +181,10 @@ def rejects_union(return_type: type) -> bool:
     return False
 
 
-def build_plan(  # noqa: C901
+def build_plan(  # noqa: C901, PLR0912
     func: Callable[Concatenate[AnyC_T, P], Parsed_T]
     | Callable[Concatenate[AnyC_T, P], Coroutine[Any, Any, Parsed_T]],
-    path: str,
+    parsed: ParsedPath,
 ) -> 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)
@@ -142,15 +194,24 @@ def build_plan(  # noqa: C901
     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}
+    path_parts = {name for _, name, _, _ in string.Formatter().parse(parsed.path_only) if name}
 
     sig = inspect.signature(func)
     plan: list[ParamPlan] = []
+    wire_names_seen: dict[Param_T, set[str]] = {
+        "path": set(),
+        "query": set(parsed.static_query),
+        "field": set(),
+        "header": set(),
+        "cookie": set(),
+    }
     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)
+        wire_name, marker = classify(
+            py_name, hints.get(py_name), path_parts, parsed.inline_query_names, param
+        )
         if marker is Body:
             kind = "body"
         elif isinstance(marker, Path):
@@ -165,18 +226,37 @@ def build_plan(  # noqa: C901
             kind = "cookie"
         else:
             kind = "part"
+        if kind in wire_names_seen:
+            if wire_name in wire_names_seen[kind]:
+                if kind == "query" and wire_name in parsed.static_query:
+                    raise TypeError(
+                        f"Parameter {py_name!r} reuses query wire name {wire_name!r}, already "
+                        "set as a static value in the path template"
+                    )
+                raise TypeError(
+                    f"Parameter {py_name!r} reuses {kind} wire name {wire_name!r}, already "
+                    "bound by another parameter"
+                )
+            wire_names_seen[kind].add(wire_name)
         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
             )
         )
+    bound_path_names = {p.wire_name for p in plan if p.kind == "path"}
+    for field_name in sorted(path_parts - bound_path_names):
+        raise TypeError(f"Path field {field_name!r} is not bound by any parameter")
+    bound_query_names = {p.wire_name for p in plan if p.kind == "query"}
+    for field_name, wire_name in sorted(parsed.inline_query_names.items()):
+        if wire_name not in bound_query_names:
+            raise TypeError(f"Inline query field {field_name!r} is not bound by any parameter")
     return plan, return_type
 
 
 def build_request(
     method: str,
-    path: str,
+    parsed: ParsedPath,
     plan: list[ParamPlan],
     values: Mapping[str, object],
     jar: Mapping[str, str] | None = None,
@@ -185,13 +265,13 @@ def build_request(
 
     Args:
         method: HTTP method for the request.
-        path: URL path template with placeholders.
+        parsed: Bare path template and static query entries, from `split_path_template()`.
         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] = {}
+    params: dict[str, QueryValue] = dict(parsed.static_query)
     headers: dict[str, str] = {}
     cookies: dict[str, str] = {}
     fields: dict[str, object] = {}
@@ -210,10 +290,10 @@ def build_request(
         elif p.kind == "part":
             files[p.wire_name] = value  # type: ignore[assignment]
         elif p.kind == "header":
-            headers[p.wire_name] = str(value)
+            headers[p.wire_name] = scalar_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)
+            cookies[p.wire_name] = jar_value if jar_value is not None else scalar_str(value)
         else:
             body = msgspec.to_builtins(value)
     if cookies:
@@ -222,8 +302,10 @@ def build_request(
         )
     return RequestSpec(
         method=method,
-        url=path.format(**{k: urllib.parse.quote(str(v), safe="") for k, v in path_args.items()}),
-        params=params,
+        url=parsed.path_only.format(
+            **{k: urllib.parse.quote(scalar_str(v), safe="") for k, v in path_args.items()}
+        ),
+        params=params or None,
         headers=headers or None,
         data=fields or None,
         files=files or None,

{mxhttp-1.0.0 → mxhttp-1.1.0}/pyproject.toml

@@ -35,7 +35,7 @@ dependencies = [
     "msgspec",
     "typing-extensions",
 ]
-version = "1.0.0"
+version = "1.1.0"
 
 [project.optional-dependencies]
 pydantic = [