csrd-models 0.1.0__py3-none-any.whl

csrd/models/__init__.py

@@ -0,0 +1,21 @@
+from . import model_parser
+from ._base_model import BaseModel, model_config
+from ._base_settings import BaseSettings, settings_config
+from .claims import UserClaims
+from .errors import APIErrorResponse, APIVersion, Error, ErrorMeta, SerializerMixin
+from .message import Message
+
+__all__ = (
+    "APIErrorResponse",
+    "APIVersion",
+    "BaseModel",
+    "BaseSettings",
+    "Error",
+    "ErrorMeta",
+    "Message",
+    "SerializerMixin",
+    "UserClaims",
+    "model_config",
+    "model_parser",
+    "settings_config",
+)

csrd/models/_base_model.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel as _BaseModel
+from pydantic import ConfigDict
+from pydantic.alias_generators import to_camel
+
+model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class BaseModel(_BaseModel):
+    model_config = model_config

csrd/models/_base_settings.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings as _BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+settings_config = SettingsConfigDict(
+    env_file=(".default_env", ".env"), env_file_encoding="utf-8", case_sensitive=False
+)
+
+
+class BaseSettings(_BaseSettings, frozen=True):  # type: ignore[misc]
+    model_config = SettingsConfigDict(
+        env_file=(".default_env", ".env"), env_file_encoding="utf-8", case_sensitive=False
+    )

csrd/models/claims.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+
+
+@dataclass
+class UserClaims:
+    """Generic user claims for API authentication."""
+
+    sub: str = ""
+    user_name: str = ""
+    authorities: list[str] = field(default_factory=list)
+    iat: datetime = field(default_factory=lambda: datetime.now(UTC))
+    exp: datetime | None = None
+
+    def __post_init__(self) -> None:
+        if self.exp is None:
+            self.exp = self.iat + timedelta(hours=1)
+
+
+__all__ = ("UserClaims",)

csrd/models/errors.py

@@ -0,0 +1,71 @@
+"""Minimal REST API error models extracted from REST API error models."""
+
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import Any
+
+from pydantic import ConfigDict, TypeAdapter
+from pydantic.alias_generators import to_camel
+
+CONFIG = ConfigDict(alias_generator=to_camel, populate_by_name=True, arbitrary_types_allowed=True)
+
+
+class SerializerMixin:
+    def as_dict(self, **kwargs: Any) -> dict[str, Any]:
+        result = TypeAdapter(type(self)).dump_python(self, **kwargs)
+        return dict(result)  # type: ignore[arg-type]
+
+
+@dataclass
+class APIVersion:
+    """API version information for error responses."""
+
+    requested: str | None = None
+    served: str | None = None
+
+    __pydantic_config__ = CONFIG
+
+
+@dataclass
+class ErrorMeta:
+    """Metadata for error responses."""
+
+    status: int = field(metadata={"description": "HTTP status code"})
+    error: str = field(metadata={"description": "Error message"})
+    path: str = field(metadata={"description": "Request path"})
+    api_version: APIVersion = field(metadata={"description": "API version information"})
+    timestamp: datetime = field(
+        default_factory=lambda: datetime.now(UTC), metadata={"description": "Error timestamp"}
+    )
+    method: str | None = field(default=None, metadata={"description": "HTTP method"})
+    request_id: str | None = field(
+        default=None, metadata={"description": "Unique request identifier"}
+    )
+
+    __pydantic_config__ = CONFIG
+
+
+@dataclass
+class Error:
+    """Individual error details."""
+
+    title: str = field(metadata={"description": "Error title"})
+    detail: str | None = field(default=None, metadata={"description": "Detailed error description"})
+    code: str | None = field(
+        default=None, metadata={"description": "Application-specific error code"}
+    )
+
+    __pydantic_config__ = CONFIG
+
+
+@dataclass
+class APIErrorResponse(SerializerMixin):
+    """Standard API error response format."""
+
+    meta: ErrorMeta = field(metadata={"description": "Error metadata"})
+    errors: list[Error] = field(metadata={"description": "List of errors"})
+
+    __pydantic_config__ = CONFIG
+
+
+__all__ = ("APIErrorResponse", "APIVersion", "Error", "ErrorMeta", "SerializerMixin")

csrd/models/message.py

@@ -0,0 +1,5 @@
+from ._base_model import BaseModel
+
+
+class Message(BaseModel):
+    detail: str

csrd/models/model_parser/__init__.py

@@ -0,0 +1,12 @@
+from ._default_model_extractor import DefaultExtractor
+from ._types import ParsedResponse, ResponseModelType
+from .model_parser_mixin import ModelParserMixin
+from .payload_extractor_protocol import PayloadExtractor
+
+__all__ = (
+    "DefaultExtractor",
+    "ModelParserMixin",
+    "ParsedResponse",
+    "PayloadExtractor",
+    "ResponseModelType",
+)

csrd/models/model_parser/_default_model_extractor.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+from .payload_extractor_protocol import PayloadExtractor
+
+
+class DefaultExtractor(PayloadExtractor):
+    def extract(self, source: Any):
+        if hasattr(source, "json") and callable(source.json):
+            result = source.json()
+            # Guard against .json() returning a string (e.g. httpx Response)
+            # — callers expect a dict or list, not a raw JSON string.
+            if isinstance(result, str):
+                import json
+
+                return json.loads(result)
+            return result
+        return source

csrd/models/model_parser/_types.py

@@ -0,0 +1,6 @@
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+
+ResponseModelType = type[T]
+type ParsedResponse = Any  # T | list[T] | bytes | dict — not expressible as a static type alias

csrd/models/model_parser/model_parser_mixin.py

@@ -0,0 +1,76 @@
+from collections.abc import Callable
+from typing import Any, get_args, get_origin
+
+from pydantic import ValidationError
+
+from ._default_model_extractor import DefaultExtractor
+from ._types import ParsedResponse, ResponseModelType
+from .payload_extractor_protocol import PayloadExtractor
+
+
+class ModelParserMixin:
+    """
+    A mixin that applies a Pydantic model to various input formats,
+    with optional support for custom model handlers.
+    """
+
+    _extractor: PayloadExtractor | None
+
+    def __init__(self, *, extractor: PayloadExtractor | None = None):
+        self._extractor = extractor
+
+    def apply_model(
+        self,
+        source: Any,
+        *,
+        model: ResponseModelType | None = None,
+        model_handler: Callable | None = None,
+        exception: type[Exception] | None = None,
+        extractor: PayloadExtractor | None = None,
+    ) -> ParsedResponse:
+        """
+        Convert source data into a parsed model or passthrough object.
+
+        Args:
+            source: Input data (dict, list, or raw object) to parse.
+            model: Optional model class or List[Model] to parse against.
+            model_handler: Optional custom callable to handle parsing.
+            exception: Optional exception type to raise on failure.
+            extractor: Optional extraction handler callable to handle parsing.
+
+        Returns:
+            ParsedResponse: The parsed object(s) or raw source.
+        """
+        try:
+            if model_handler:
+                return model_handler(source, model)
+
+            extractor = extractor or self._extractor
+            data = self._resolve_payload(source, extractor)
+
+            if model is None:
+                return data
+
+            if get_origin(model) is list:
+                item_type = get_args(model)[0]
+                if not isinstance(data, list):
+                    raise TypeError("Expected list in input payload")
+                return [item_type(**item) for item in data]
+
+            if not isinstance(data, dict):
+                raise TypeError("Expected dict in input payload")
+
+            return model(**data)
+
+        except (ValidationError, TypeError, ValueError, KeyError) as e:
+            if exception:
+                raise exception(e) from e
+            raise
+
+    @staticmethod
+    def _resolve_payload(source: Any, extractor: PayloadExtractor | None = None) -> Any:
+        """
+        Uses a pluggable extractor to transform source into raw payload.
+        """
+        extractor = extractor or DefaultExtractor()
+        return extractor.extract(source)

csrd/models/model_parser/payload_extractor_protocol.py

@@ -0,0 +1,5 @@
+from typing import Any, Protocol
+
+
+class PayloadExtractor(Protocol):
+    def extract(self, source: Any) -> Any: ...

csrd_models-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: csrd-models
+Version: 0.1.0
+Summary: Base Pydantic models and settings
+Project-URL: Repository, https://github.com/csrd-api/fastapi-common
+Project-URL: Documentation, https://github.com/csrd-api/fastapi-common/tree/main/packages/models
+Project-URL: Changelog, https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: pydantic-settings<3,>=2.10
+Requires-Dist: pydantic<3,>=2.10

csrd_models-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+csrd/models/__init__.py,sha256=ZjTDQXisCEZ2FWm6jTOiyJbd-GajV5I9H7J0fR1590o,521
+csrd/models/_base_model.py,sha256=hqlwp6Xvbe3AV4PGhqMt7S6o7HiSVDPWx-mWIvt78JE,263
+csrd/models/_base_settings.py,sha256=dYGHQ6dr2gp21B4eJvNQ-b48AAuB8xPKse3ylu1vE2w,445
+csrd/models/claims.py,sha256=s7Yx3SROiA9Wmhu3ov08sWZDm4JGNBnMAmxJiFr9ip0,521
+csrd/models/errors.py,sha256=IhQSmVo8h5_26PHaOZRug-_y5ALegGLg5GZAD4hhlT4,2238
+csrd/models/message.py,sha256=6wzt2px_i-5sGi0GcA7V-O-kaPZmPAbl8XPDpV2TOyM,79
+csrd/models/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+csrd/models/model_parser/__init__.py,sha256=7tSycR6qSnkb1ewy69s689A1m6ZXuGjM3_SHVbbo_b8,349
+csrd/models/model_parser/_default_model_extractor.py,sha256=V3EChNhrSs0jUj8S78EW1hI2q54XDyScHUr7W9MBNV8,566
+csrd/models/model_parser/_types.py,sha256=jpfOJ1BytmDqTGzD_S1k7DCScDHtMJx-GMNq-v29sIw,178
+csrd/models/model_parser/model_parser_mixin.py,sha256=svUvcJa1X6duDC8mQEcYAlFoYisGPAUqWSiALWDDXdY,2575
+csrd/models/model_parser/payload_extractor_protocol.py,sha256=7jcmd87Gq37Sc2IFkRwXySVvn64Ch9WrLE60Y9FizHw,116
+csrd_models-0.1.0.dist-info/METADATA,sha256=WLntD8xdwrxkZUB9fXIko04FshENwoAcMHxZkq6qiss,465
+csrd_models-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+csrd_models-0.1.0.dist-info/RECORD,,

csrd_models-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any