cliV1 0.0.8__py3-none-any.whl

swagger_petstore_open_api_3_0/async_client.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from functools import cached_property
+from types import TracebackType
+
+from typing_extensions import Self
+
+from .apis.pet_api import AsyncPetApi
+from .apis.store import AsyncStore
+from .apis.user_api import AsyncUserApi
+from .auth import AsyncAuthSchemes
+from .base_client import DEFAULT_TIMEOUT, BaseSwaggerPetstoreOpenApi30Client
+from .core import (
+    OPERATING_SYSTEM,
+    PYTHON_RUNTIME,
+    ApiKeyHeaderScheme,
+    AsyncHttpClient,
+    AsyncHttpxClient,
+    AsyncRawClient,
+    no_auth,
+    param,
+)
+from .server.server_config import ServerConfigOrDict
+
+
+class AsyncSwaggerPetstoreOpenApi30Client(BaseSwaggerPetstoreOpenApi30Client[AsyncRawClient]):
+    def __init__(
+        self,
+        *,
+        server_config: ServerConfigOrDict | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        custom_async_http_client: AsyncHttpClient | None = None,
+        petstore_auth: str | None = None,
+        api_key: str | None = None,
+    ) -> None:
+        super().__init__(server_config=server_config, timeout=timeout)
+        self._raw_client = AsyncRawClient(
+            http_client=(
+                custom_async_http_client if custom_async_http_client is not None else AsyncHttpxClient(timeout=timeout)
+            ),
+            global_headers=[
+                param[str]("User-Agent", "SwaggerPetstoreOpenApi30Client/1.0.26 Python"),
+                param[str]("X-APIMatic-Lang", "Python"),
+                param[str]("X-APIMatic-Package-Version", "1.0.26"),
+                param[str]("X-APIMatic-Gen-Version", "4.0.0"),
+                param[str]("X-APIMatic-OS", OPERATING_SYSTEM),
+                param[str]("X-APIMatic-Runtime", PYTHON_RUNTIME),
+            ],
+        )
+        self._auth = AsyncAuthSchemes(
+            petstore_auth=ApiKeyHeaderScheme("Authorization", petstore_auth) if petstore_auth is not None else no_auth,
+            api_key=ApiKeyHeaderScheme("api_key", api_key) if api_key is not None else no_auth,
+        )
+
+    @cached_property
+    def pet_api(self) -> AsyncPetApi:
+        return AsyncPetApi(self._raw_client, self._server, self._auth)
+
+    @cached_property
+    def store(self) -> AsyncStore:
+        return AsyncStore(self._raw_client, self._server, self._auth)
+
+    @cached_property
+    def user_api(self) -> AsyncUserApi:
+        return AsyncUserApi(self._raw_client, self._server)
+
+    async def aclose(self) -> None:
+        await self._raw_client.http_client.aclose()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, exc_tb: TracebackType | None
+    ) -> None:
+        await self.aclose()
+
+
+AsyncClient = AsyncSwaggerPetstoreOpenApi30Client

swagger_petstore_open_api_3_0/auth.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .core import AsyncAuthScheme, AuthScheme
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AuthSchemes:
+    petstore_auth: AuthScheme
+    api_key: AuthScheme
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AsyncAuthSchemes:
+    petstore_auth: AsyncAuthScheme
+    api_key: AsyncAuthScheme

swagger_petstore_open_api_3_0/base_client.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Generic
+
+from .core import RawClientT
+from .server.server import Server
+from .server.server_config import ServerConfig, ServerConfigOrDict
+
+DEFAULT_TIMEOUT = 30.0
+
+
+class BaseSwaggerPetstoreOpenApi30Client(Generic[RawClientT]):
+    _raw_client: RawClientT
+
+    def __init__(self, *, server_config: ServerConfigOrDict | None = None, timeout: float = DEFAULT_TIMEOUT) -> None:
+        if not timeout > 0:
+            raise ValueError(f"timeout must be greater than 0; got {timeout!r}")
+        self._server = Server(ServerConfig.coerce(server_config))

swagger_petstore_open_api_3_0/client.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from functools import cached_property
+from types import TracebackType
+
+from typing_extensions import Self
+
+from .apis.pet_api import PetApi
+from .apis.store import Store
+from .apis.user_api import UserApi
+from .auth import AuthSchemes
+from .base_client import DEFAULT_TIMEOUT, BaseSwaggerPetstoreOpenApi30Client
+from .core import (
+    OPERATING_SYSTEM,
+    PYTHON_RUNTIME,
+    ApiKeyHeaderScheme,
+    HttpClient,
+    HttpxClient,
+    RawClient,
+    no_auth,
+    param,
+)
+from .server.server_config import ServerConfigOrDict
+
+
+class SwaggerPetstoreOpenApi30Client(BaseSwaggerPetstoreOpenApi30Client[RawClient]):
+    def __init__(
+        self,
+        *,
+        server_config: ServerConfigOrDict | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        custom_http_client: HttpClient | None = None,
+        petstore_auth: str | None = None,
+        api_key: str | None = None,
+    ) -> None:
+        super().__init__(server_config=server_config, timeout=timeout)
+        self._raw_client = RawClient(
+            http_client=custom_http_client if custom_http_client is not None else HttpxClient(timeout=timeout),
+            global_headers=[
+                param[str]("User-Agent", "SwaggerPetstoreOpenApi30Client/1.0.26 Python"),
+                param[str]("X-APIMatic-Lang", "Python"),
+                param[str]("X-APIMatic-Package-Version", "1.0.26"),
+                param[str]("X-APIMatic-Gen-Version", "4.0.0"),
+                param[str]("X-APIMatic-OS", OPERATING_SYSTEM),
+                param[str]("X-APIMatic-Runtime", PYTHON_RUNTIME),
+            ],
+        )
+        self._auth = AuthSchemes(
+            petstore_auth=ApiKeyHeaderScheme("Authorization", petstore_auth) if petstore_auth is not None else no_auth,
+            api_key=ApiKeyHeaderScheme("api_key", api_key) if api_key is not None else no_auth,
+        )
+
+    @cached_property
+    def pet_api(self) -> PetApi:
+        return PetApi(self._raw_client, self._server, self._auth)
+
+    @cached_property
+    def store(self) -> Store:
+        return Store(self._raw_client, self._server, self._auth)
+
+    @cached_property
+    def user_api(self) -> UserApi:
+        return UserApi(self._raw_client, self._server)
+
+    def close(self) -> None:
+        self._raw_client.http_client.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, exc_tb: TracebackType | None
+    ) -> None:
+        self.close()
+
+
+Client = SwaggerPetstoreOpenApi30Client

swagger_petstore_open_api_3_0/core/__init__.py

@@ -0,0 +1,358 @@
+"""Public surface of the SDK runtime.
+
+Everything the generated layers (``api/``, ``models/``, ``errors/``, ``server/``, the two clients)
+need from the runtime is re-exported here, so a generated module imports from one place --
+``from <sdk>.core import ApiResult, RawClient, json_decoder`` -- instead of reaching into the
+runtime's internal module layout. That indirection is the point: the modules behind this facade are
+free to move without touching a single generated file.
+
+A symbol earns a place here by one test: a generator may emit it, or a caller may need to name it.
+Internal machinery the runtime only calls itself -- the adapter cache, the decoder implementation
+classes, the sentinel stripper -- is deliberately absent, and remains reachable at its own module
+path for the unit tests that target it.
+
+Everything remains importable from its fully-qualified module path as well."""
+
+from .auth import (
+    AllSchemes,
+    AnySchemes,
+    AsyncAllSchemes,
+    AsyncAnySchemes,
+    AsyncAuthScheme,
+    AsyncRefreshableTokenSource,
+    AsyncTokenSource,
+    AuthParams,
+    AuthScheme,
+    OAuthError,
+    OAuthProviderError,
+    OAuthToken,
+    OAuthTokenRefreshable,
+    RefreshableTokenSource,
+    RevocableAuthScheme,
+    TokenSource,
+    client_secret_basic,
+    client_secret_post,
+    invalidate,
+    is_configured,
+    no_auth,
+    oauth_error_response,
+    resolve_auth,
+)
+from .auth.schemes import (
+    ApiKeyCookieScheme,
+    ApiKeyHeaderScheme,
+    ApiKeyQueryScheme,
+    AsyncAuthorizationCodeCredentials,
+    AsyncAuthorizationCodeCredentialsDict,
+    AsyncAuthorizationCodeCredentialsOrDict,
+    AsyncAuthorizationCodePrompt,
+    AsyncAuthorizationCodeTokenSource,
+    AsyncClientCredentialsTokenSource,
+    AsyncOAuth2RefreshableScheme,
+    AsyncOAuth2Scheme,
+    AsyncPasswordTokenSource,
+    AuthorizationCodeCredentials,
+    AuthorizationCodeCredentialsDict,
+    AuthorizationCodeCredentialsOrDict,
+    AuthorizationCodePrompt,
+    AuthorizationCodeTokenSource,
+    BasicAuthCredentials,
+    BasicAuthCredentialsDict,
+    BasicAuthCredentialsOrDict,
+    BasicAuthScheme,
+    BearerAuthScheme,
+    ClientCredentials,
+    ClientCredentialsDict,
+    ClientCredentialsOrDict,
+    ClientCredentialsTokenSource,
+    OAuth2RefreshableScheme,
+    OAuth2Scheme,
+    PasswordCredentials,
+    PasswordCredentialsDict,
+    PasswordCredentialsOrDict,
+    PasswordTokenSource,
+    PkceMethod,
+)
+from .base_raw_response import BaseRawResponse, SecuredRawResponse
+from .bodies import (
+    BinaryBody,
+    FormBody,
+    JsonBody,
+    MultipartBody,
+    MultipartFile,
+    MultipartPart,
+    MultipartText,
+    RequestBody,
+    TextBody,
+    binary_body,
+    file_part,
+    form_body,
+    json_body,
+    json_part,
+    multipart_body,
+    text_body,
+)
+from .converters import (
+    Base16AsciiEncodedBytes,
+    Base16Cp1252EncodedBytes,
+    Base16Latin1EncodedBytes,
+    Base16Utf8EncodedBytes,
+    Base32AsciiEncodedBytes,
+    Base32Cp1252EncodedBytes,
+    Base32HexAsciiEncodedBytes,
+    Base32HexCp1252EncodedBytes,
+    Base32HexLatin1EncodedBytes,
+    Base32HexUtf8EncodedBytes,
+    Base32Latin1EncodedBytes,
+    Base32Utf8EncodedBytes,
+    Base64AsciiEncodedBytes,
+    Base64Cp1252EncodedBytes,
+    Base64Latin1EncodedBytes,
+    Base64UrlAsciiEncodedBytes,
+    Base64UrlCp1252EncodedBytes,
+    Base64UrlLatin1EncodedBytes,
+    Base64UrlUtf8EncodedBytes,
+    Base64Utf8EncodedBytes,
+    ByteField,
+    Date,
+    RFC1123DateTime,
+    RFC3339DateTime,
+    UnixSecondsDateTime,
+    open_enum_validator,
+)
+from .decoding import (
+    AsyncResponseDecoder,
+    ErrorMapper,
+    ResponseDecoder,
+    async_empty_response,
+    async_file_decoder,
+    async_json_decoder,
+    async_json_event_decoder,
+    async_text_decoder,
+    async_text_event_decoder,
+    decode_json,
+    decode_text,
+    empty_response,
+    file_decoder,
+    json_decoder,
+    json_event_decoder,
+    raw_error_response,
+    text_decoder,
+    text_event_decoder,
+)
+from .discriminators import WireDiscriminator
+from .event_streams import AsyncEventStream, EventStream
+from .exceptions import ApiError
+from .file_responses import AsyncFileResponse, FileResponse
+from .files import (
+    AsyncBinaryContent,
+    AsyncBinaryReader,
+    AsyncFileInput,
+    BinaryContent,
+    BinaryReader,
+    FileInput,
+    NamedFile,
+)
+from .httpx_transport import AsyncHttpxClient, HttpxClient
+from .models import SdkBaseModel
+from .optionality import UNSET, Optional, OptionalNullable, UnsetType
+from .params import SerializationFormat, UrlTemplate, param
+from .raw_client import (
+    AsyncRawClient,
+    RawClient,
+    RawClientT,
+)
+from .request_options import RequestOptions, RequestOptionsDict, RequestOptionsOrDict
+from .results import ApiResult, Failure, RawError, Success
+from .runtime_env import OPERATING_SYSTEM, PYTHON_RUNTIME
+from .servers import validate_one_of
+from .transport import (
+    AsyncHttpClient,
+    AsyncHttpResponse,
+    HttpClient,
+    HttpRequest,
+    HttpResponse,
+)
+
+__all__ = [
+    # Result and error types
+    "ApiResult",
+    "Success",
+    "Failure",
+    "RawError",
+    "ApiError",
+    # HTTP transport
+    "HttpClient",
+    "AsyncHttpClient",
+    "HttpRequest",
+    "HttpResponse",
+    "AsyncHttpResponse",
+    "HttpxClient",
+    "AsyncHttpxClient",
+    # Request parameters and bodies
+    "param",
+    "SerializationFormat",
+    "UrlTemplate",
+    "RequestBody",
+    "JsonBody",
+    "json_body",
+    "FormBody",
+    "form_body",
+    "MultipartBody",
+    "multipart_body",
+    "MultipartPart",
+    "MultipartText",
+    "MultipartFile",
+    "file_part",
+    "json_part",
+    "BinaryBody",
+    "binary_body",
+    "TextBody",
+    "text_body",
+    # File input
+    "BinaryReader",
+    "AsyncBinaryReader",
+    "BinaryContent",
+    "AsyncBinaryContent",
+    "NamedFile",
+    "FileInput",
+    "AsyncFileInput",
+    # Streamed payloads
+    "FileResponse",
+    "AsyncFileResponse",
+    "EventStream",
+    "AsyncEventStream",
+    # Per-call request options
+    "RequestOptions",
+    "RequestOptionsDict",
+    "RequestOptionsOrDict",
+    # Authentication
+    "AuthParams",
+    "AuthScheme",
+    "AsyncAuthScheme",
+    "no_auth",
+    "is_configured",
+    "resolve_auth",
+    "BasicAuthCredentials",
+    "BasicAuthCredentialsDict",
+    "BasicAuthCredentialsOrDict",
+    "BasicAuthScheme",
+    "BearerAuthScheme",
+    "ApiKeyHeaderScheme",
+    "ApiKeyQueryScheme",
+    "ApiKeyCookieScheme",
+    "AnySchemes",
+    "AsyncAnySchemes",
+    "AllSchemes",
+    "AsyncAllSchemes",
+    "RevocableAuthScheme",
+    "invalidate",
+    # Managed OAuth 2.0
+    "OAuth2Scheme",
+    "AsyncOAuth2Scheme",
+    "OAuth2RefreshableScheme",
+    "AsyncOAuth2RefreshableScheme",
+    "TokenSource",
+    "AsyncTokenSource",
+    "RefreshableTokenSource",
+    "AsyncRefreshableTokenSource",
+    "client_secret_basic",
+    "client_secret_post",
+    "OAuthToken",
+    "OAuthTokenRefreshable",
+    "OAuthProviderError",
+    "OAuthError",
+    "oauth_error_response",
+    # oauth2 / clientCredentials
+    "ClientCredentials",
+    "ClientCredentialsDict",
+    "ClientCredentialsOrDict",
+    "ClientCredentialsTokenSource",
+    "AsyncClientCredentialsTokenSource",
+    # oauth2 / password
+    "PasswordCredentials",
+    "PasswordCredentialsDict",
+    "PasswordCredentialsOrDict",
+    "PasswordTokenSource",
+    "AsyncPasswordTokenSource",
+    # oauth2 / authorizationCode
+    "AuthorizationCodeCredentials",
+    "AuthorizationCodeCredentialsDict",
+    "AuthorizationCodeCredentialsOrDict",
+    "AsyncAuthorizationCodeCredentials",
+    "AsyncAuthorizationCodeCredentialsDict",
+    "AsyncAuthorizationCodeCredentialsOrDict",
+    "AuthorizationCodePrompt",
+    "AsyncAuthorizationCodePrompt",
+    "PkceMethod",
+    "AuthorizationCodeTokenSource",
+    "AsyncAuthorizationCodeTokenSource",
+    # Response decoding and error mapping
+    "ResponseDecoder",
+    "AsyncResponseDecoder",
+    "ErrorMapper",
+    "json_decoder",
+    "async_json_decoder",
+    "text_decoder",
+    "async_text_decoder",
+    "decode_json",
+    "decode_text",
+    "empty_response",
+    "async_empty_response",
+    "raw_error_response",
+    "file_decoder",
+    "async_file_decoder",
+    "json_event_decoder",
+    "text_event_decoder",
+    "async_json_event_decoder",
+    "async_text_event_decoder",
+    # Model base and optionality
+    "SdkBaseModel",
+    "UNSET",
+    "UnsetType",
+    "Optional",
+    "OptionalNullable",
+    # Union discrimination
+    "WireDiscriminator",
+    # Wire-format converters
+    "Date",
+    "RFC3339DateTime",
+    "RFC1123DateTime",
+    "UnixSecondsDateTime",
+    # Wire-format binary aliases -- one per (RFC 4648 alphabet, charset) pair
+    "Base64AsciiEncodedBytes",
+    "Base64Utf8EncodedBytes",
+    "Base64Latin1EncodedBytes",
+    "Base64Cp1252EncodedBytes",
+    "Base64UrlAsciiEncodedBytes",
+    "Base64UrlUtf8EncodedBytes",
+    "Base64UrlLatin1EncodedBytes",
+    "Base64UrlCp1252EncodedBytes",
+    "Base32AsciiEncodedBytes",
+    "Base32Utf8EncodedBytes",
+    "Base32Latin1EncodedBytes",
+    "Base32Cp1252EncodedBytes",
+    "Base32HexAsciiEncodedBytes",
+    "Base32HexUtf8EncodedBytes",
+    "Base32HexLatin1EncodedBytes",
+    "Base32HexCp1252EncodedBytes",
+    "Base16AsciiEncodedBytes",
+    "Base16Utf8EncodedBytes",
+    "Base16Latin1EncodedBytes",
+    "Base16Cp1252EncodedBytes",
+    # Binary property declaration
+    "ByteField",
+    # Open enums
+    "open_enum_validator",
+    # Raw clients and the raw-response base
+    "RawClient",
+    "AsyncRawClient",
+    "RawClientT",
+    "BaseRawResponse",
+    "SecuredRawResponse",
+    # Host environment reported in the SDK identification headers
+    "OPERATING_SYSTEM",
+    "PYTHON_RUNTIME",
+    # Server layer
+    "validate_one_of",
+]

swagger_petstore_open_api_3_0/core/_internal/__init__.py

@@ -0,0 +1,9 @@
+"""Runtime plumbing.
+
+Nothing here is part of the SDK's public surface: mostly the pure functions the raw client calls to
+turn parameters into a URL, a header mapping, and form fields, plus the one base class the
+subscripted factories share and one stateful object -- ``sse_parser``'s push parser, which is
+incremental by nature because it is fed a chunk at a time. They are grouped under a private package
+so this runtime's own ``__init__`` stays the whole of what generated code imports."""
+
+__all__: list[str] = []