photonhq-api 0.1.0__py3-none-any.whl

photon_api/__init__.py

@@ -0,0 +1,18 @@
+from .client import AsyncPhoton, Photon
+from .errors import (
+    ApiError,
+    PhotonError,
+    ResponseValidationError,
+    TransportError,
+)
+from .transport import RawResponse
+
+__all__ = [
+    "ApiError",
+    "AsyncPhoton",
+    "Photon",
+    "PhotonError",
+    "RawResponse",
+    "ResponseValidationError",
+    "TransportError",
+]

photon_api/_model_base.py

@@ -0,0 +1,62 @@
+"""Base classes and helpers of the generated models (tools/python-codegen).
+
+The models carry the contract's types; values the contract restricts only by
+validation keywords (patterns, lengths, bounds, sizes) are left to the service.
+"""
+
+from typing import Annotated, Any, Generic, TypeVar
+
+from pydantic import AfterValidator, ConfigDict, TypeAdapter
+from pydantic import BaseModel as PydanticBaseModel
+from pydantic import RootModel as PydanticRootModel
+
+T = TypeVar("T")
+
+
+class BaseModel(PydanticBaseModel):
+    # Members the SDK does not know are kept (a response may gain fields).
+    model_config = ConfigDict(extra="allow", defer_build=True)
+
+
+class RootModel(PydanticRootModel[T], Generic[T]):
+    model_config = ConfigDict(defer_build=True)
+
+
+def validate_all_of(data: Any, *constraints: type[PydanticBaseModel]) -> Any:
+    """Check the input of a union narrowed by object constraints against each constraint.
+
+    Generated (tools/python-codegen/intersections.py) as a `mode="before"`
+    validator: every constraint model validates the value as given, and the
+    root type validates the union; the value is valid only if all accept it.
+    A model instance is checked through its JSON form.
+    """
+    raw = (
+        data.model_dump(mode="json", by_alias=True) if isinstance(data, PydanticBaseModel) else data
+    )
+    for constraint in constraints:
+        constraint.model_validate(raw)
+    return data
+
+
+class PrefixItems:
+    """`PrefixItems[T1, ..., Tn]`: a JSON Schema `prefixItems` array without `items`.
+
+    Item i, when present, validates as Ti; later items are unconstrained, and
+    the array may be shorter than n. Generated for arrays whose positional
+    items the model generator would otherwise drop
+    (tools/python-codegen/prefix_items.py). The value is a `list`.
+    """
+
+    def __class_getitem__(cls, params: Any) -> Any:
+        types = params if isinstance(params, tuple) else (params,)
+        adapters: list[TypeAdapter[Any]] = []
+
+        def validate(value: list[Any]) -> list[Any]:
+            if not adapters:
+                adapters.extend(TypeAdapter(item) for item in types)
+            return [
+                adapters[index].validate_python(item) if index < len(adapters) else item
+                for index, item in enumerate(value)
+            ]
+
+        return Annotated[list[Any], AfterValidator(validate)]

photon_api/client.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .config_generated import DEFAULT_BASE_URL
+from .rpc_generated import AsyncRoot, SyncRoot
+from .transport import (
+    DEFAULT_MAX_RETRY_AFTER,
+    AsyncHeaderProvider,
+    AsyncTransport,
+    SyncHeaderProvider,
+    SyncTransport,
+)
+
+
+class Photon(SyncRoot):
+    def __init__(
+        self,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        headers: SyncHeaderProvider | None = None,
+        timeout: float = 30.0,
+        max_attempts: int = 3,
+        client: httpx.Client | None = None,
+        max_retry_after: float = DEFAULT_MAX_RETRY_AFTER,
+    ) -> None:
+        self._transport = SyncTransport(
+            base_url=base_url,
+            headers=headers,
+            timeout=timeout,
+            max_attempts=max_attempts,
+            client=client,
+            max_retry_after=max_retry_after,
+        )
+        super().__init__(self._transport)
+        self.raw = SyncRoot(self._transport, raw=True)
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> Photon:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+
+class AsyncPhoton(AsyncRoot):
+    def __init__(
+        self,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        headers: AsyncHeaderProvider | None = None,
+        timeout: float = 30.0,
+        max_attempts: int = 3,
+        client: httpx.AsyncClient | None = None,
+        max_retry_after: float = DEFAULT_MAX_RETRY_AFTER,
+    ) -> None:
+        self._transport = AsyncTransport(
+            base_url=base_url,
+            headers=headers,
+            timeout=timeout,
+            max_attempts=max_attempts,
+            client=client,
+            max_retry_after=max_retry_after,
+        )
+        super().__init__(self._transport)
+        self.raw = AsyncRoot(self._transport, raw=True)
+
+    async def close(self) -> None:
+        await self._transport.close()
+
+    async def __aenter__(self) -> AsyncPhoton:
+        return self
+
+    async def __aexit__(self, *_: Any) -> None:
+        await self.close()

photon_api/config_generated.py

@@ -0,0 +1,2 @@
+# Generated from config/sdk.json. Do not edit.
+DEFAULT_BASE_URL = "https://api.photon.codes"

photon_api/errors.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class PhotonError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        operation_id: str | None = None,
+        request_id: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.operation_id = operation_id
+        self.request_id = request_id
+
+
+class ResponseValidationError(PhotonError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int,
+        raw_body: str,
+        operation_id: str,
+        request_id: str | None,
+    ) -> None:
+        super().__init__(
+            message,
+            operation_id=operation_id,
+            request_id=request_id,
+        )
+        self.status = status
+        self.raw_body = raw_body
+
+
+class TransportError(PhotonError):
+    pass
+
+
+class ApiError(PhotonError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int,
+        headers: dict[str, str],
+        body: Any,
+        raw_body: str,
+        operation_id: str,
+        request_id: str | None,
+    ) -> None:
+        super().__init__(
+            message,
+            operation_id=operation_id,
+            request_id=request_id,
+        )
+        self.status = status
+        self.headers = headers
+        self.body = body
+        self.raw_body = raw_body

photon_api/generated/__init__.py

@@ -0,0 +1 @@
+from .models import *