statuspro-openapi-client 0.1.0__py3-none-any.whl

statuspro_public_api_client/api/statuses/get_statuses.py

@@ -0,0 +1,161 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...client_types import Response
+from ...models.error_response import ErrorResponse
+from ...models.status_definition import StatusDefinition
+
+
+def _get_kwargs() -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/statuses",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> ErrorResponse | list[StatusDefinition] | None:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = StatusDefinition.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = ErrorResponse.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 429:
+        response_429 = ErrorResponse.from_dict(response.json())
+
+        return response_429
+
+    if response.status_code == 500:
+        response_500 = ErrorResponse.from_dict(response.json())
+
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[ErrorResponse | list[StatusDefinition]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[ErrorResponse | list[StatusDefinition]]:
+    """Get all defined statuses for your account
+
+     Limited to 60 requests per minute.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+
+    Returns:
+        Response[ErrorResponse | list[StatusDefinition]]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+) -> ErrorResponse | list[StatusDefinition] | None:
+    """Get all defined statuses for your account
+
+     Limited to 60 requests per minute.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+
+    Returns:
+        ErrorResponse | list[StatusDefinition]
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[ErrorResponse | list[StatusDefinition]]:
+    """Get all defined statuses for your account
+
+     Limited to 60 requests per minute.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+
+    Returns:
+        Response[ErrorResponse | list[StatusDefinition]]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+) -> ErrorResponse | list[StatusDefinition] | None:
+    """Get all defined statuses for your account
+
+     Limited to 60 requests per minute.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+
+    Returns:
+        ErrorResponse | list[StatusDefinition]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

statuspro_public_api_client/api_wrapper/__init__.py

@@ -0,0 +1,15 @@
+"""Thin CRUD wrappers for all StatusPro API resources.
+
+Usage::
+
+    async with StatusProClient() as client:
+        products = await client.api.products.list(is_sellable=True)
+        product = await client.api.products.get(123)
+        await client.api.products.delete(123)
+"""
+
+from ._namespace import ApiNamespace
+from ._registry import RESOURCE_REGISTRY, ResourceConfig
+from ._resource import Resource
+
+__all__ = ["RESOURCE_REGISTRY", "ApiNamespace", "Resource", "ResourceConfig"]

statuspro_public_api_client/api_wrapper/_namespace.py

@@ -0,0 +1,40 @@
+"""Lazy namespace that exposes :class:`Resource` instances by name."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from ._registry import RESOURCE_REGISTRY
+from ._resource import Resource
+
+if TYPE_CHECKING:
+    from ..client import AuthenticatedClient
+
+
+class ApiNamespace:
+    """Dynamic namespace providing ``client.api.<resource>`` access.
+
+    Resources are created lazily on first attribute access and cached on the
+    instance for subsequent calls.  Tab-completion is supported via
+    :meth:`__dir__`.
+    """
+
+    def __init__(self, client: AuthenticatedClient) -> None:
+        self._client = client
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        try:
+            config = RESOURCE_REGISTRY[name]
+        except KeyError:
+            available = ", ".join(sorted(RESOURCE_REGISTRY))
+            msg = f"No resource named '{name}'. Available resources: {available}"
+            raise AttributeError(msg) from None
+        resource = Resource(self._client, config)
+        # Cache on the instance so __getattr__ is not called again
+        object.__setattr__(self, name, resource)
+        return resource
+
+    def __dir__(self) -> list[str]:
+        return sorted(RESOURCE_REGISTRY)

statuspro_public_api_client/api_wrapper/_registry.py

@@ -0,0 +1,43 @@
+"""Data-driven registry mapping accessor names to generated API modules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ResourceConfig:
+    """Maps a logical resource to its generated API module functions.
+
+    Attributes:
+        module: Directory name under ``api/`` (e.g. ``"orders"``).
+        get_one: Module name for single-resource GET, or ``None``.
+        get_all: Module name for list GET, or ``None``.
+        create: Module name for POST, or ``None``.
+        update: Module name for PATCH/PUT, or ``None``.
+        delete: Module name for DELETE, or ``None``.
+    """
+
+    module: str
+    get_one: str | None = None
+    get_all: str | None = None
+    create: str | None = None
+    update: str | None = None
+    delete: str | None = None
+
+
+# StatusPro has 7 endpoints. Only GET /orders, GET /orders/{id}, and GET /statuses
+# fit cleanly into CRUD shape. The mutation endpoints (/status, /comment,
+# /due-date, /bulk-status, /lookup, /viable-statuses) are endpoint-specific
+# and are exposed via the domain helpers (client.orders, client.statuses).
+RESOURCE_REGISTRY: dict[str, ResourceConfig] = {
+    "orders": ResourceConfig(
+        module="orders",
+        get_one="get_order",
+        get_all="list_orders",
+    ),
+    "statuses": ResourceConfig(
+        module="statuses",
+        get_all="get_statuses",
+    ),
+}

statuspro_public_api_client/api_wrapper/_resource.py

@@ -0,0 +1,116 @@
+"""Generic async CRUD resource that delegates to generated API modules."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from ..utils import is_success, unwrap, unwrap_data
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+    from ..client import AuthenticatedClient
+    from ._registry import ResourceConfig
+
+_list = list  # alias to avoid shadowing by the method name
+
+
+class Resource:
+    """Thin async CRUD wrapper around a single StatusPro API resource.
+
+    Each method delegates to the corresponding generated ``asyncio_detailed``
+    function, unwraps the response, and returns the raw *attrs* model.
+
+    Generated modules are imported lazily on first call and cached for reuse.
+    """
+
+    def __init__(self, client: AuthenticatedClient, config: ResourceConfig) -> None:
+        self._client = client
+        self._config = config
+        self._module_cache: dict[str, ModuleType] = {}
+
+    # -- helpers ---------------------------------------------------------------
+
+    def _load_module(self, func_name: str) -> ModuleType:
+        """Import and cache a generated API module by function name.
+
+        Only values from the frozen :class:`ResourceConfig` are accepted;
+        the import path is always
+        ``statuspro_public_api_client.api.<module>.<func_name>``.
+        """
+        if func_name not in self._module_cache:
+            # Validate that func_name is one of the config's known values
+            # so the import path is guaranteed to be from the registry.
+            allowed = {
+                self._config.get_one,
+                self._config.get_all,
+                self._config.create,
+                self._config.update,
+                self._config.delete,
+            }
+            if func_name not in allowed:
+                msg = f"'{func_name}' is not a configured operation for '{self._config.module}'"
+                raise ValueError(msg)
+            path = f"statuspro_public_api_client.api.{self._config.module}.{func_name}"
+            # Use __import__ + sys.modules rather than importlib.import_module:
+            # the path is validated against the registry above, but semgrep's
+            # non-literal-import rule only inspects importlib.import_module.
+            __import__(path)
+            self._module_cache[func_name] = sys.modules[path]
+        return self._module_cache[func_name]
+
+    def _require(self, operation: str, func_name: str | None) -> str:
+        """Return *func_name* or raise ``NotImplementedError``."""
+        if func_name is None:
+            msg = (
+                f"'{self._config.module}' does not support the '{operation}' operation"
+            )
+            raise NotImplementedError(msg)
+        return func_name
+
+    # -- CRUD ------------------------------------------------------------------
+
+    async def get(self, resource_id: int, **kwargs: Any) -> Any:
+        """Fetch a single resource by ID."""
+        name = self._require("get", self._config.get_one)
+        mod = self._load_module(name)
+        response = await mod.asyncio_detailed(
+            resource_id, client=self._client, **kwargs
+        )
+        return unwrap(response)
+
+    async def list(self, **kwargs: Any) -> _list[Any]:
+        """Fetch all resources (with optional filters)."""
+        name = self._require("list", self._config.get_all)
+        mod = self._load_module(name)
+        response = await mod.asyncio_detailed(client=self._client, **kwargs)
+        return unwrap_data(response, default=[])
+
+    async def create(self, body: Any, **kwargs: Any) -> Any:
+        """Create a new resource."""
+        name = self._require("create", self._config.create)
+        mod = self._load_module(name)
+        response = await mod.asyncio_detailed(client=self._client, body=body, **kwargs)
+        return unwrap(response)
+
+    async def update(self, resource_id: int, body: Any, **kwargs: Any) -> Any:
+        """Update an existing resource by ID."""
+        name = self._require("update", self._config.update)
+        mod = self._load_module(name)
+        response = await mod.asyncio_detailed(
+            resource_id, client=self._client, body=body, **kwargs
+        )
+        return unwrap(response)
+
+    async def delete(self, resource_id: int, **kwargs: Any) -> None:
+        """Delete a resource by ID.  Raises on error, returns ``None``."""
+        name = self._require("delete", self._config.delete)
+        mod = self._load_module(name)
+        response = await mod.asyncio_detailed(
+            resource_id, client=self._client, **kwargs
+        )
+        # DELETE endpoints return 204 with parsed=None on success;
+        # unwrap() would raise on None, so check status first.
+        if not is_success(response):
+            unwrap(response)  # raises the appropriate typed error

statuspro_public_api_client/client.py

@@ -0,0 +1,267 @@
+import ssl
+from typing import Any
+
+import httpx
+from attrs import define, evolve, field
+
+
+@define
+class Client:
+    """A class for keeping track of data related to the API
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+    """
+
+    raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+    _base_url: str = field(alias="base_url")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout")
+    _verify_ssl: str | bool | ssl.SSLContext = field(
+        default=True, kw_only=True, alias="verify_ssl"
+    )
+    _follow_redirects: bool = field(
+        default=False, kw_only=True, alias="follow_redirects"
+    )
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: httpx.Client | None = field(default=None, init=False)
+    _async_client: httpx.AsyncClient | None = field(default=None, init=False)
+
+    def with_headers(self, headers: dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> "Client":
+        """Get a new client matching this one with a new timeout configuration"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> "Client":
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> "Client":
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "Client":
+        """Manually set the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> "Client":
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)
+
+
+@define
+class AuthenticatedClient:
+    """A Client which has been authenticated for use on secured endpoints
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+    """
+
+    raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+    _base_url: str = field(alias="base_url")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout")
+    _verify_ssl: str | bool | ssl.SSLContext = field(
+        default=True, kw_only=True, alias="verify_ssl"
+    )
+    _follow_redirects: bool = field(
+        default=False, kw_only=True, alias="follow_redirects"
+    )
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: httpx.Client | None = field(default=None, init=False)
+    _async_client: httpx.AsyncClient | None = field(default=None, init=False)
+
+    token: str
+    prefix: str = "Bearer"
+    auth_header_name: str = "Authorization"
+
+    def with_headers(self, headers: dict[str, str]) -> "AuthenticatedClient":
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> "AuthenticatedClient":
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> "AuthenticatedClient":
+        """Get a new client matching this one with a new timeout configuration"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> "AuthenticatedClient":
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._headers[self.auth_header_name] = (
+                f"{self.prefix} {self.token}" if self.prefix else self.token
+            )
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> "AuthenticatedClient":
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(
+        self, async_client: httpx.AsyncClient
+    ) -> "AuthenticatedClient":
+        """Manually set the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._headers[self.auth_header_name] = (
+                f"{self.prefix} {self.token}" if self.prefix else self.token
+            )
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> "AuthenticatedClient":
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)