cliV1 0.0.8__py3-none-any.whl

swagger_petstore_open_api_3_0/core/transport.py

@@ -0,0 +1,191 @@
+"""The HTTP boundary: what a request and a response are, and what a transport must provide.
+
+The two protocols are the seam between the SDK and whatever HTTP library actually moves bytes.
+Keeping them SDK-owned is deliberate: no third-party request or response type reaches the public
+surface, and a caller can supply their own transport by satisfying :class:`HttpClient` or
+:class:`AsyncHttpClient`.
+
+There is no response *dataclass* here at all. A result carries the head as fields of its own, and a
+body that has been read is ``bytes`` -- handed to a decode step or to an error mapper beside the
+status it switches on. So the vocabulary at this boundary is three things: a request, a response
+whose body is still on the wire, and the bytes that come off it.
+
+The request and response shapes live here; the body shapes a request can carry live in
+``bodies.py``, beside the factories that build them, and reach a transport through
+:attr:`HttpRequest.body`."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterator, Mapping
+from dataclasses import dataclass
+from typing import Protocol
+
+from ._internal.urls import strip_query
+from .bodies import RequestBody
+
+
+@dataclass(frozen=True, slots=True)
+class HttpRequest:
+    """An outbound request, fully resolved and ready for a transport to send."""
+
+    method: str
+    url: str
+    headers: Mapping[str, str]
+
+    body: RequestBody | None = None
+    timeout: float | None = None
+    """Seconds to wait, or ``None`` to leave the transport's own timeout in force."""
+
+    def __repr__(self) -> str:
+        # Identify by method and path only. ``headers`` holds the rendered credential, the query
+        # string holds a query-placed api key, and ``body`` holds a form-encoded ``client_secret``
+        # -- so none of the three reaches the string form. This is also the type that crosses the
+        # ``HttpClient`` seam, which is where a logging transport would print it. The fields stay
+        # readable: this is a string form, not redaction.
+        return f"{type(self).__name__}(method={self.method!r}, url={strip_query(self.url)!r})"
+
+
+class HttpResponse(Protocol):
+    """A response whose head has arrived and whose body has not been read.
+
+    The status and headers are facts as soon as this exists, which is what lets a streamed call
+    still yield a ``Success`` or a ``Failure``: only the payload is deferred, never the outcome.
+    It holds a connection until it is closed. Header names MUST be lowercased, the same rule the
+    request side applies in ``_internal/headers.py``.
+
+    ``read`` is the seam the error path and every buffered decoder take, not a convenience over
+    ``iter_bytes``: it must both buffer the whole body *and* release the connection, so a body
+    survives the close that frees the socket.
+
+    ``iter_bytes`` re-chunks to ``chunk_size`` bytes when given an ``int``; given ``None`` it MUST yield
+    each chunk as the network delivered it, buffering nothing of its own -- a latency-bound consumer such
+    as an event stream reads it that way, since a fixed size would hold a twenty-byte event back until
+    enough followed it.
+
+    ``close`` MUST be idempotent. The runtime closes twice on one path: a buffered decoder releases
+    the body in its own ``finally``, and a decoder that raises is then closed again by the seam that
+    called it -- the belt that keeps a failed decode from stranding a socket."""
+
+    @property
+    def url(self) -> str:
+        """The URL this response came from.
+
+        Carried on the response rather than passed alongside it, because the payloads that outlive
+        the call are the only readers and have no other way to name themselves once abandoned. It
+        is the URL the request asked for: the SDK never follows redirects."""
+        ...
+
+    @property
+    def status_code(self) -> int: ...
+
+    @property
+    def headers(self) -> Mapping[str, str]: ...
+
+    def iter_bytes(self, chunk_size: int | None) -> Iterator[bytes]: ...
+
+    def read(self) -> bytes: ...
+
+    def close(self) -> None: ...
+
+
+class AsyncHttpResponse(Protocol):
+    """The awaited twin. ``aclose`` rather than ``close``, matching the SDK's async client.
+
+    ``url``, ``status_code`` and ``headers`` stay synchronous properties -- the head has already
+    arrived. Header names MUST be lowercased, the same rule the request side applies, and ``aread``
+    carries ``read``'s obligation: buffer the whole body and release the connection. ``aclose``
+    carries ``close``'s -- it MUST be idempotent, for the same double-close path. ``aiter_bytes``
+    carries ``iter_bytes``'s ``chunk_size`` contract, ``None`` included."""
+
+    @property
+    def url(self) -> str:
+        """The URL this response came from; see :attr:`HttpResponse.url`."""
+        ...
+
+    @property
+    def status_code(self) -> int: ...
+
+    @property
+    def headers(self) -> Mapping[str, str]: ...
+
+    def aiter_bytes(self, chunk_size: int | None) -> AsyncIterator[bytes]: ...
+
+    async def aread(self) -> bytes: ...
+
+    async def aclose(self) -> None: ...
+
+
+class HttpClient(Protocol):
+    """Sync transport contract.
+
+    There is **one** request seam. ``send`` returns as soon as the response head has arrived and
+    never reads the body; who reads it, and when the connection is released, is the decoder's
+    business (ADR-0063). A transport that buffered would be answering a question nobody asked --
+    and, underneath, the library this one wraps reaches a streamed response first in either case.
+
+    Implementations:
+    - MUST NOT mutate the incoming :class:`HttpRequest`.
+    - MUST honour ``request.timeout`` when it is set, and fall back to their own configured
+      timeout when it is ``None``.
+    - MUST lowercase the header names on the returned response: HTTP/1.1 treats them
+      case-insensitively and HTTP/2 requires lowercase, so a caller's lookup needs no case
+      handling -- the same rule, for the same reason, as the request side in
+      ``_internal/headers.py``.
+    - MUST label a body from what the body carries, and spell nothing of its own: a
+      :class:`BinaryBody`'s ``media_type`` as ``Content-Type`` and, where it names one, its
+      ``filename`` as ``Content-Disposition``. Both merge **underneath** ``request.headers``, so a
+      caller's ``extra_headers`` still wins. The shipped transport renders the disposition through
+      ``_internal/content_disposition.py``; a custom one owning that rendering is the cost it
+      already carries for the media type.
+    - SHOULD be idempotent for ``close()``.
+    - MAY raise their underlying library's exceptions."""
+
+    def send(self, request: HttpRequest) -> HttpResponse:
+        """Execute a request and return its response with the body unread.
+
+        Returns once the response head has arrived; the connection stays checked out until the
+        returned response is closed.
+
+        Args:
+            request: The request to send, which MUST NOT be mutated.
+
+        Returns:
+            The response head, its body pending, its header names lowercased."""
+        ...
+
+    def close(self) -> None:
+        """Release underlying resources (connections, pools). Should be idempotent."""
+        ...
+
+
+class AsyncHttpClient(Protocol):
+    """Async transport contract -- the same shape as :class:`HttpClient`, awaited.
+
+    The same obligations apply, including honouring ``request.timeout``, lowercasing the
+    response's header names, and leaving the body unread. ``aclose`` rather than ``close`` matches
+    httpx and the SDK's own async client.
+
+    One obligation is this side's alone:
+
+    - Implementations MUST resolve an async :attr:`MultipartFile.content` themselves. A multipart
+      encoder pulls every part from a synchronous chunk generator, so an awaitable ``read`` cannot
+      be driven from inside one; the shipped transport drains such a part to a temp file before
+      encoding, which keeps it bounded rather than resident and leaves it sized. A raw
+      :class:`BinaryBody` needs no such pre-pass -- its async arms stream natively."""
+
+    async def send(self, request: HttpRequest) -> AsyncHttpResponse:
+        """Execute a request and return its response with the body unread.
+
+        Returns once the response head has arrived; the connection stays checked out until the
+        returned response is closed.
+
+        Args:
+            request: The request to send, which MUST NOT be mutated.
+
+        Returns:
+            The response head, its body pending, its header names lowercased."""
+        ...
+
+    async def aclose(self) -> None:
+        """Release underlying resources (connections, pools). Should be idempotent."""
+        ...

swagger_petstore_open_api_3_0/errors/__init__.py

@@ -0,0 +1,48 @@
+from .add_pet_error import AddPetErrorBody, add_pet_error_mapper
+from .delete_order_error import DeleteOrderErrorBody, delete_order_error_mapper
+from .delete_pet_error import DeletePetErrorBody, delete_pet_error_mapper
+from .delete_user_error import DeleteUserErrorBody, delete_user_error_mapper
+from .find_pets_by_status_error import FindPetsByStatusErrorBody, find_pets_by_status_error_mapper
+from .find_pets_by_tags_error import FindPetsByTagsErrorBody, find_pets_by_tags_error_mapper
+from .get_order_by_id_error import GetOrderByIdErrorBody, get_order_by_id_error_mapper
+from .get_pet_by_id_error import GetPetByIdErrorBody, get_pet_by_id_error_mapper
+from .get_user_by_name_error import GetUserByNameErrorBody, get_user_by_name_error_mapper
+from .login_user_error import LoginUserErrorBody, login_user_error_mapper
+from .place_order_error import PlaceOrderErrorBody, place_order_error_mapper
+from .update_pet_error import UpdatePetErrorBody, update_pet_error_mapper
+from .update_pet_with_form_error import UpdatePetWithFormErrorBody, update_pet_with_form_error_mapper
+from .update_user_error import UpdateUserErrorBody, update_user_error_mapper
+from .upload_file_error import UploadFileErrorBody, upload_file_error_mapper
+
+__all__ = [
+    "AddPetErrorBody",
+    "DeleteOrderErrorBody",
+    "DeletePetErrorBody",
+    "DeleteUserErrorBody",
+    "FindPetsByStatusErrorBody",
+    "FindPetsByTagsErrorBody",
+    "GetOrderByIdErrorBody",
+    "GetPetByIdErrorBody",
+    "GetUserByNameErrorBody",
+    "LoginUserErrorBody",
+    "PlaceOrderErrorBody",
+    "UpdatePetErrorBody",
+    "UpdatePetWithFormErrorBody",
+    "UpdateUserErrorBody",
+    "UploadFileErrorBody",
+    "add_pet_error_mapper",
+    "delete_order_error_mapper",
+    "delete_pet_error_mapper",
+    "delete_user_error_mapper",
+    "find_pets_by_status_error_mapper",
+    "find_pets_by_tags_error_mapper",
+    "get_order_by_id_error_mapper",
+    "get_pet_by_id_error_mapper",
+    "get_user_by_name_error_mapper",
+    "login_user_error_mapper",
+    "place_order_error_mapper",
+    "update_pet_error_mapper",
+    "update_pet_with_form_error_mapper",
+    "update_user_error_mapper",
+    "upload_file_error_mapper",
+]

swagger_petstore_open_api_3_0/errors/add_pet_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+AddPetErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _AddPetError:
+    def map(self, status_code: int, content: bytes) -> AddPetErrorBody:
+        match status_code:
+            case 400 | 422:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+add_pet_error_mapper: Final[ErrorMapper[AddPetErrorBody]] = _AddPetError()

swagger_petstore_open_api_3_0/errors/delete_order_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+DeleteOrderErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _DeleteOrderError:
+    def map(self, status_code: int, content: bytes) -> DeleteOrderErrorBody:
+        match status_code:
+            case 400 | 404:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+delete_order_error_mapper: Final[ErrorMapper[DeleteOrderErrorBody]] = _DeleteOrderError()

swagger_petstore_open_api_3_0/errors/delete_pet_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+DeletePetErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _DeletePetError:
+    def map(self, status_code: int, content: bytes) -> DeletePetErrorBody:
+        match status_code:
+            case 400:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+delete_pet_error_mapper: Final[ErrorMapper[DeletePetErrorBody]] = _DeletePetError()

swagger_petstore_open_api_3_0/errors/delete_user_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+DeleteUserErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _DeleteUserError:
+    def map(self, status_code: int, content: bytes) -> DeleteUserErrorBody:
+        match status_code:
+            case 400 | 404:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+delete_user_error_mapper: Final[ErrorMapper[DeleteUserErrorBody]] = _DeleteUserError()

swagger_petstore_open_api_3_0/errors/find_pets_by_status_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+FindPetsByStatusErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _FindPetsByStatusError:
+    def map(self, status_code: int, content: bytes) -> FindPetsByStatusErrorBody:
+        match status_code:
+            case 400:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+find_pets_by_status_error_mapper: Final[ErrorMapper[FindPetsByStatusErrorBody]] = _FindPetsByStatusError()

swagger_petstore_open_api_3_0/errors/find_pets_by_tags_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+FindPetsByTagsErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _FindPetsByTagsError:
+    def map(self, status_code: int, content: bytes) -> FindPetsByTagsErrorBody:
+        match status_code:
+            case 400:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+find_pets_by_tags_error_mapper: Final[ErrorMapper[FindPetsByTagsErrorBody]] = _FindPetsByTagsError()

swagger_petstore_open_api_3_0/errors/get_order_by_id_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+GetOrderByIdErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _GetOrderByIdError:
+    def map(self, status_code: int, content: bytes) -> GetOrderByIdErrorBody:
+        match status_code:
+            case 400 | 404:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+get_order_by_id_error_mapper: Final[ErrorMapper[GetOrderByIdErrorBody]] = _GetOrderByIdError()

swagger_petstore_open_api_3_0/errors/get_pet_by_id_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+GetPetByIdErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _GetPetByIdError:
+    def map(self, status_code: int, content: bytes) -> GetPetByIdErrorBody:
+        match status_code:
+            case 400 | 404:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+get_pet_by_id_error_mapper: Final[ErrorMapper[GetPetByIdErrorBody]] = _GetPetByIdError()

swagger_petstore_open_api_3_0/errors/get_user_by_name_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+GetUserByNameErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _GetUserByNameError:
+    def map(self, status_code: int, content: bytes) -> GetUserByNameErrorBody:
+        match status_code:
+            case 400 | 404:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+get_user_by_name_error_mapper: Final[ErrorMapper[GetUserByNameErrorBody]] = _GetUserByNameError()

swagger_petstore_open_api_3_0/errors/login_user_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+LoginUserErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _LoginUserError:
+    def map(self, status_code: int, content: bytes) -> LoginUserErrorBody:
+        match status_code:
+            case 400:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+login_user_error_mapper: Final[ErrorMapper[LoginUserErrorBody]] = _LoginUserError()

swagger_petstore_open_api_3_0/errors/place_order_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+PlaceOrderErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _PlaceOrderError:
+    def map(self, status_code: int, content: bytes) -> PlaceOrderErrorBody:
+        match status_code:
+            case 400 | 422:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+place_order_error_mapper: Final[ErrorMapper[PlaceOrderErrorBody]] = _PlaceOrderError()

swagger_petstore_open_api_3_0/errors/update_pet_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+UpdatePetErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdatePetError:
+    def map(self, status_code: int, content: bytes) -> UpdatePetErrorBody:
+        match status_code:
+            case 400 | 404 | 422:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+update_pet_error_mapper: Final[ErrorMapper[UpdatePetErrorBody]] = _UpdatePetError()

swagger_petstore_open_api_3_0/errors/update_pet_with_form_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+UpdatePetWithFormErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdatePetWithFormError:
+    def map(self, status_code: int, content: bytes) -> UpdatePetWithFormErrorBody:
+        match status_code:
+            case 400:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+update_pet_with_form_error_mapper: Final[ErrorMapper[UpdatePetWithFormErrorBody]] = _UpdatePetWithFormError()

swagger_petstore_open_api_3_0/errors/update_user_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+UpdateUserErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdateUserError:
+    def map(self, status_code: int, content: bytes) -> UpdateUserErrorBody:
+        match status_code:
+            case 400 | 404:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+update_user_error_mapper: Final[ErrorMapper[UpdateUserErrorBody]] = _UpdateUserError()

swagger_petstore_open_api_3_0/errors/upload_file_error.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final, TypeAlias
+
+from ..core import ErrorMapper, RawError
+
+UploadFileErrorBody: TypeAlias = RawError
+
+
+@dataclass(frozen=True, slots=True)
+class _UploadFileError:
+    def map(self, status_code: int, content: bytes) -> UploadFileErrorBody:
+        match status_code:
+            case 400 | 404:
+                return RawError(status_code, content)
+            case _:
+                return RawError(status_code, content)
+
+
+upload_file_error_mapper: Final[ErrorMapper[UploadFileErrorBody]] = _UploadFileError()

swagger_petstore_open_api_3_0/models/__init__.py

@@ -0,0 +1,23 @@
+from . import enums
+from .api_response import ApiResponse, ApiResponseDict
+from .category import Category, CategoryDict
+from .order import Order, OrderDict
+from .pet import Pet, PetDict
+from .tag_model import TagModel, TagModelDict
+from .user import User, UserDict
+
+__all__ = [
+    "enums",
+    "ApiResponse",
+    "ApiResponseDict",
+    "Category",
+    "CategoryDict",
+    "Order",
+    "OrderDict",
+    "Pet",
+    "PetDict",
+    "TagModel",
+    "TagModelDict",
+    "User",
+    "UserDict",
+]

swagger_petstore_open_api_3_0/models/api_response.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pydantic import Field
+from typing_extensions import NotRequired, TypedDict
+
+from ..core import UNSET, Optional, SdkBaseModel
+
+
+class ApiResponse(SdkBaseModel):
+    code: Optional[int] = UNSET
+    type_: Optional[str] = Field(default=UNSET, alias="type")
+    message: Optional[str] = UNSET
+
+
+class ApiResponseDict(TypedDict):
+    code: NotRequired[int]
+    type_: NotRequired[str]
+    message: NotRequired[str]

swagger_petstore_open_api_3_0/models/category.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing_extensions import NotRequired, TypedDict
+
+from ..core import UNSET, Optional, SdkBaseModel
+
+
+class Category(SdkBaseModel):
+    id: Optional[int] = UNSET
+    name: Optional[str] = UNSET
+
+
+class CategoryDict(TypedDict):
+    id: NotRequired[int]
+    name: NotRequired[str]

swagger_petstore_open_api_3_0/models/enums/__init__.py

@@ -0,0 +1,4 @@
+from .order_status import OrderStatus, OrderStatusOrStr
+from .pet_status import PetStatus, PetStatusOrStr
+
+__all__ = ["OrderStatus", "OrderStatusOrStr", "PetStatus", "PetStatusOrStr"]

swagger_petstore_open_api_3_0/models/enums/order_status.py

@@ -0,0 +1,17 @@
+from enum import Enum
+from typing import Annotated, TypeAlias
+
+from ...core import open_enum_validator
+
+
+class OrderStatus(str, Enum):
+    """Order Status"""
+
+    PLACED = "placed"
+    APPROVED = "approved"
+    DELIVERED = "delivered"
+
+    __str__ = str.__str__
+
+
+OrderStatusOrStr: TypeAlias = Annotated[OrderStatus | str, open_enum_validator(OrderStatus)]