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

statuspro_public_api_client/models_pydantic/_registry.py

@@ -0,0 +1,171 @@
+"""Registry for mapping between attrs and Pydantic model classes.
+
+This module provides a registry that maps attrs model classes to their
+corresponding Pydantic model classes and vice versa. This is essential
+for the bi-directional conversion functionality in _base.py.
+
+The registry is populated automatically when models are generated,
+via the _auto_registry.py module.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ._base import StatusProPydanticBase
+
+# Registries mapping class names and types
+_attrs_to_pydantic: dict[type, type[StatusProPydanticBase]] = {}
+_pydantic_to_attrs: dict[type[StatusProPydanticBase], type] = {}
+_attrs_name_to_class: dict[str, type] = {}
+_pydantic_name_to_class: dict[str, type[StatusProPydanticBase]] = {}
+
+
+def register(attrs_class: type, pydantic_class: type[StatusProPydanticBase]) -> None:
+    """Register a mapping between an attrs class and a Pydantic class.
+
+    This function should be called for each model pair after generation.
+    It enables the from_attrs() and to_attrs() conversion methods to work.
+
+    Args:
+        attrs_class: The attrs model class (from models/).
+        pydantic_class: The corresponding Pydantic model class.
+
+    Raises:
+        TypeError: If attrs_class is not an attrs class or pydantic_class is not
+            a subclass of StatusProPydanticBase.
+        ValueError: If the classes are already registered with different mappings.
+    """
+    # Import StatusProPydanticBase at runtime to avoid circular imports
+    from ._base import StatusProPydanticBase as BaseClass
+
+    # Validate attrs_class has attrs attributes
+    if not hasattr(attrs_class, "__attrs_attrs__"):
+        msg = f"{attrs_class.__name__} is not an attrs class (missing __attrs_attrs__)"
+        raise TypeError(msg)
+
+    # Validate pydantic_class is a proper Pydantic model
+    if not isinstance(pydantic_class, type) or not issubclass(
+        pydantic_class, BaseClass
+    ):
+        msg = f"{pydantic_class.__name__} is not a subclass of StatusProPydanticBase"
+        raise TypeError(msg)
+
+    # Check for conflicting registrations
+    existing_pydantic = _attrs_to_pydantic.get(attrs_class)
+    if existing_pydantic is not None and existing_pydantic is not pydantic_class:
+        msg = (
+            f"{attrs_class.__name__} is already registered to "
+            f"{existing_pydantic.__name__}, cannot register to {pydantic_class.__name__}"
+        )
+        raise ValueError(msg)
+
+    existing_attrs = _pydantic_to_attrs.get(pydantic_class)
+    if existing_attrs is not None and existing_attrs is not attrs_class:
+        msg = (
+            f"{pydantic_class.__name__} is already registered to "
+            f"{existing_attrs.__name__}, cannot register to {attrs_class.__name__}"
+        )
+        raise ValueError(msg)
+
+    _attrs_to_pydantic[attrs_class] = pydantic_class
+    _pydantic_to_attrs[pydantic_class] = attrs_class
+    _attrs_name_to_class[attrs_class.__name__] = attrs_class
+    _pydantic_name_to_class[pydantic_class.__name__] = pydantic_class
+
+    # Also set the _attrs_model class variable on the pydantic class
+    pydantic_class._attrs_model = attrs_class
+
+
+def get_pydantic_class(attrs_class: type) -> type[StatusProPydanticBase] | None:
+    """Get the Pydantic class for a given attrs class.
+
+    Args:
+        attrs_class: An attrs model class.
+
+    Returns:
+        The corresponding Pydantic model class, or None if not registered.
+    """
+    return _attrs_to_pydantic.get(attrs_class)
+
+
+def get_attrs_class(pydantic_class: type[StatusProPydanticBase]) -> type | None:
+    """Get the attrs class for a given Pydantic class.
+
+    Args:
+        pydantic_class: A Pydantic model class.
+
+    Returns:
+        The corresponding attrs model class, or None if not registered.
+    """
+    return _pydantic_to_attrs.get(pydantic_class)
+
+
+def get_pydantic_class_by_name(name: str) -> type[StatusProPydanticBase] | None:
+    """Get a Pydantic class by its name.
+
+    Args:
+        name: The class name to look up.
+
+    Returns:
+        The Pydantic model class, or None if not found.
+    """
+    return _pydantic_name_to_class.get(name)
+
+
+def get_attrs_class_by_name(name: str) -> type | None:
+    """Get an attrs class by its name.
+
+    Args:
+        name: The class name to look up.
+
+    Returns:
+        The attrs model class, or None if not found.
+    """
+    return _attrs_name_to_class.get(name)
+
+
+def list_registered_models() -> list[tuple[str, str]]:
+    """List all registered model pairs.
+
+    Returns:
+        List of (attrs_class_name, pydantic_class_name) tuples.
+    """
+    return [
+        (attrs_cls.__name__, pydantic_cls.__name__)
+        for attrs_cls, pydantic_cls in _attrs_to_pydantic.items()
+    ]
+
+
+def is_registered(model_class: type) -> bool:
+    """Check if a model class is registered (either attrs or pydantic).
+
+    Args:
+        model_class: A model class to check.
+
+    Returns:
+        True if the class is registered in either direction.
+    """
+    return model_class in _attrs_to_pydantic or model_class in _pydantic_to_attrs
+
+
+def clear_registry() -> None:
+    """Clear all registrations. Mainly for testing purposes."""
+    _attrs_to_pydantic.clear()
+    _pydantic_to_attrs.clear()
+    _attrs_name_to_class.clear()
+    _pydantic_name_to_class.clear()
+
+
+def get_registration_stats() -> dict[str, Any]:
+    """Get statistics about the current registry state.
+
+    Returns:
+        Dictionary with counts and other stats.
+    """
+    return {
+        "total_pairs": len(_attrs_to_pydantic),
+        "attrs_classes": len(_attrs_name_to_class),
+        "pydantic_classes": len(_pydantic_name_to_class),
+    }

statuspro_public_api_client/models_pydantic/converters.py

@@ -0,0 +1,184 @@
+"""Batch conversion utilities for attrs <-> Pydantic model conversion.
+
+This module provides convenience functions for converting API responses
+and collections of models between attrs and Pydantic representations.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar, overload
+
+from . import _registry
+from ._base import StatusProPydanticBase
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from ..client_types import Response
+
+
+T = TypeVar("T", bound=StatusProPydanticBase)
+
+
+@overload
+def convert_response[T: StatusProPydanticBase](
+    response: Response[None],
+    pydantic_class: type[T],
+) -> None: ...
+
+
+@overload
+def convert_response[T: StatusProPydanticBase](
+    response: Response[list[object]],
+    pydantic_class: type[T],
+) -> list[T]: ...
+
+
+@overload
+def convert_response[T: StatusProPydanticBase](
+    response: Response[object],
+    pydantic_class: type[T],
+) -> T: ...
+
+
+def convert_response[T: StatusProPydanticBase](
+    response: Response[object] | Response[list[object]] | Response[None],
+    pydantic_class: type[T],
+) -> T | list[T] | None:
+    """Convert an API response's parsed data to Pydantic models.
+
+    This is the recommended way to convert API responses when you want
+    Pydantic models instead of attrs models.
+
+    Args:
+        response: The Response object from an API call.
+        pydantic_class: The Pydantic model class to convert to.
+
+    Returns:
+        - None if response.parsed is None
+        - A list of Pydantic models if response.parsed is a list
+        - A single Pydantic model otherwise
+
+    Example:
+        ```python
+        from statuspro_public_api_client.api.product import get_all_products
+        from statuspro_public_api_client.models_pydantic import Product
+        from statuspro_public_api_client.models_pydantic.converters import (
+            convert_response,
+        )
+
+        response = await get_all_products.asyncio_detailed(client=client)
+        products = convert_response(response, Product)  # list[Product]
+        ```
+    """
+    if response.parsed is None:
+        return None
+
+    if isinstance(response.parsed, list):
+        return batch_convert(response.parsed, pydantic_class)
+
+    return pydantic_class.from_attrs(response.parsed)
+
+
+def batch_convert[T: StatusProPydanticBase](
+    attrs_objects: Sequence[object],
+    pydantic_class: type[T],
+) -> list[T]:
+    """Convert a list of attrs objects to Pydantic models.
+
+    Args:
+        attrs_objects: A sequence of attrs model instances.
+        pydantic_class: The Pydantic model class to convert to.
+
+    Returns:
+        A list of Pydantic model instances.
+
+    Example:
+        ```python
+        from statuspro_public_api_client.models_pydantic import Product
+        from statuspro_public_api_client.models_pydantic.converters import (
+            batch_convert,
+        )
+
+        pydantic_products = batch_convert(attrs_products, Product)
+        ```
+    """
+    return [pydantic_class.from_attrs(obj) for obj in attrs_objects]
+
+
+def batch_convert_to_attrs(
+    pydantic_objects: Sequence[StatusProPydanticBase],
+) -> list[object]:
+    """Convert a list of Pydantic models to attrs objects.
+
+    Args:
+        pydantic_objects: A sequence of Pydantic model instances.
+
+    Returns:
+        A list of attrs model instances.
+
+    Example:
+        ```python
+        attrs_products = batch_convert_to_attrs(pydantic_products)
+        ```
+    """
+    return [obj.to_attrs() for obj in pydantic_objects]
+
+
+def to_pydantic(attrs_obj: object) -> StatusProPydanticBase | None:
+    """Convert any registered attrs object to its Pydantic equivalent.
+
+    This function automatically looks up the correct Pydantic class
+    from the registry.
+
+    Args:
+        attrs_obj: An attrs model instance.
+
+    Returns:
+        The corresponding Pydantic model instance, or None if the class
+        is not registered.
+
+    Example:
+        ```python
+        from statuspro_public_api_client.models_pydantic.converters import (
+            to_pydantic,
+        )
+
+        pydantic_product = to_pydantic(attrs_product)
+        ```
+    """
+    if attrs_obj is None:
+        return None
+
+    pydantic_class = _registry.get_pydantic_class(type(attrs_obj))
+    if pydantic_class is None:
+        return None
+
+    return pydantic_class.from_attrs(attrs_obj)
+
+
+def to_attrs(pydantic_obj: StatusProPydanticBase) -> object | None:
+    """Convert any registered Pydantic object to its attrs equivalent.
+
+    This is equivalent to calling pydantic_obj.to_attrs() but provides
+    a consistent functional interface.
+
+    Args:
+        pydantic_obj: A Pydantic model instance.
+
+    Returns:
+        The corresponding attrs model instance.
+
+    Example:
+        ```python
+        from statuspro_public_api_client.models_pydantic.converters import (
+            to_attrs,
+        )
+
+        attrs_product = to_attrs(pydantic_product)
+        ```
+    """
+    if pydantic_obj is None:
+        return None
+
+    return pydantic_obj.to_attrs()

statuspro_public_api_client/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561