csrd-models 0.1.0__tar.gz

csrd_models-0.1.0/.gitignore

@@ -0,0 +1,217 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+/env/
+/venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+*.db
+
+
+# Import linter cache
+.import_linter_cache/
+
+# IDE
+.idea/
+.idea/*

csrd_models-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,23 @@
+# csrd-models
+
+Base Pydantic models, settings, and parsing utilities for FastAPI microservices.
+
+**Package**: `csrd.models` · **Import**: `from csrd.models import BaseModel, BaseSettings`
+
+## What's included
+
+- `BaseModel` / `BaseSettings` with camelCase alias config and `populate_by_name=True`
+- `ModelParserMixin` — response parsing mixin for delegates and repositories
+- `PayloadExtractor` / `DefaultExtractor` — pluggable payload extraction
+- `UserClaims` — JWT user claims dataclass
+- `APIErrorResponse`, `ErrorMeta`, `Error`, `APIVersion` — structured error response models
+
+## Installation
+
+```bash
+uv pip install "csrd-models @ git+ssh://git@github.com/csrd-api/fastapi-common.git#subdirectory=packages/models"
+```
+
+## Dependencies
+
+None (Tier 1 — standalone)

csrd_models-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "csrd-models"
+version = "0.1.0"
+description = "Base Pydantic models and settings"
+license = { text = "MIT" }
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic>=2.10,<3",
+    "pydantic-settings>=2.10,<3",
+]
+
+[project.urls]
+Repository = "https://github.com/csrd-api/fastapi-common"
+Documentation = "https://github.com/csrd-api/fastapi-common/tree/main/packages/models"
+Changelog = "https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/csrd"]

csrd_models-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/csrd/models/message.py

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

csrd_models-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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/tests/test_base_model.py

@@ -0,0 +1,36 @@
+"""Tests for BaseModel camelCase aliasing and model_config."""
+
+from csrd.models import BaseModel, model_config
+
+
+class SampleModel(BaseModel):
+    first_name: str
+    last_name: str
+    is_active: bool = True
+
+
+class SampleWithConfig(BaseModel):
+    model_config = model_config
+    hello_world: str = "hi"
+
+
+class TestBaseModelAliasing:
+    def test_camel_case_serialization(self):
+        m = SampleModel(firstName="Alice", lastName="Smith")
+        dumped = m.model_dump(by_alias=True)
+        assert dumped == {"firstName": "Alice", "lastName": "Smith", "isActive": True}
+
+    def test_camel_case_deserialization(self):
+        m = SampleModel.model_validate({"firstName": "Bob", "lastName": "Jones"})
+        assert m.first_name == "Bob"
+        assert m.last_name == "Jones"
+
+    def test_snake_case_dump(self):
+        m = SampleModel(firstName="Carol", lastName="Doe")
+        dumped = m.model_dump()
+        assert dumped == {"first_name": "Carol", "last_name": "Doe", "is_active": True}
+
+    def test_populate_by_name_with_config(self):
+        """SampleWithConfig uses model_config with populate_by_name=True."""
+        m = SampleWithConfig(hello_world="hey")
+        assert m.hello_world == "hey"

csrd_models-0.1.0/tests/test_claims.py

@@ -0,0 +1,36 @@
+"""Tests for UserClaims dataclass."""
+
+from datetime import UTC, datetime, timedelta
+
+from csrd.models.claims import UserClaims
+
+
+class TestUserClaims:
+    def test_defaults(self):
+        claims = UserClaims()
+        assert claims.sub == ""
+        assert claims.user_name == ""
+        assert claims.authorities == []
+        assert claims.iat is not None
+        assert claims.exp is not None
+
+    def test_exp_auto_generated(self):
+        claims = UserClaims(sub="user1")
+        assert claims.exp == claims.iat + timedelta(hours=1)
+
+    def test_custom_exp_preserved(self):
+        custom_exp = datetime(2030, 1, 1, tzinfo=UTC)
+        claims = UserClaims(sub="user1", exp=custom_exp)
+        assert claims.exp == custom_exp
+
+    def test_authorities_list(self):
+        claims = UserClaims(sub="admin", authorities=["ROLE_ADMIN", "ROLE_USER"])
+        assert len(claims.authorities) == 2
+        assert "ROLE_ADMIN" in claims.authorities
+
+    def test_mutable_authorities(self):
+        claims = UserClaims()
+        claims.authorities.append("NEW_ROLE")
+        # Verify the default_factory creates independent lists
+        claims2 = UserClaims()
+        assert "NEW_ROLE" not in claims2.authorities

csrd_models-0.1.0/tests/test_errors.py

@@ -0,0 +1,87 @@
+"""Tests for error models and SerializerMixin."""
+
+from csrd.models.errors import APIErrorResponse, APIVersion, Error, ErrorMeta
+
+
+class TestAPIVersion:
+    def test_defaults(self):
+        v = APIVersion()
+        assert v.requested is None
+        assert v.served is None
+
+    def test_camel_case_serialization(self):
+        from pydantic import TypeAdapter
+
+        v = APIVersion(requested="2025-06-20", served="2025-06-20")
+        dumped = TypeAdapter(APIVersion).dump_python(v, by_alias=True)
+        assert dumped["requested"] == "2025-06-20"
+        assert dumped["served"] == "2025-06-20"
+
+
+class TestErrorMeta:
+    def test_required_fields(self):
+        meta = ErrorMeta(
+            status=404,
+            error="Not Found",
+            path="/api/test",
+            api_version=APIVersion(),
+        )
+        assert meta.status == 404
+        assert meta.error == "Not Found"
+        assert meta.timestamp is not None
+
+    def test_optional_fields(self):
+        meta = ErrorMeta(
+            status=500,
+            error="Internal Server Error",
+            path="/api/test",
+            api_version=APIVersion(),
+            method="GET",
+            request_id="abc-123",
+        )
+        assert meta.method == "GET"
+        assert meta.request_id == "abc-123"
+
+
+class TestError:
+    def test_minimal(self):
+        err = Error(title="Something went wrong")
+        assert err.title == "Something went wrong"
+        assert err.detail is None
+        assert err.code is None
+
+    def test_full(self):
+        err = Error(title="Validation", detail="Field required", code="FIELD_REQUIRED")
+        assert err.code == "FIELD_REQUIRED"
+
+
+class TestAPIErrorResponse:
+    def test_as_dict(self):
+        resp = APIErrorResponse(
+            meta=ErrorMeta(
+                status=400,
+                error="Bad Request",
+                path="/api/test",
+                api_version=APIVersion(requested="v1", served="v1"),
+            ),
+            errors=[Error(title="Invalid input")],
+        )
+        d = resp.as_dict(by_alias=True, mode="json")
+        assert d["meta"]["status"] == 400
+        assert d["meta"]["error"] == "Bad Request"
+        assert d["meta"]["apiVersion"]["requested"] == "v1"
+        assert len(d["errors"]) == 1
+        assert d["errors"][0]["title"] == "Invalid input"
+
+    def test_empty_errors(self):
+        resp = APIErrorResponse(
+            meta=ErrorMeta(
+                status=500,
+                error="Internal Server Error",
+                path="/",
+                api_version=APIVersion(),
+            ),
+            errors=[],
+        )
+        d = resp.as_dict(by_alias=True)
+        assert d["errors"] == []

csrd_models-0.1.0/tests/test_message.py

@@ -0,0 +1,14 @@
+"""Tests for Message model."""
+
+from csrd.models import Message
+
+
+class TestMessage:
+    def test_create(self):
+        m = Message(detail="hello")
+        assert m.detail == "hello"
+
+    def test_camel_case(self):
+        """Message inherits BaseModel — verify aliasing works."""
+        dumped = Message(detail="test").model_dump(by_alias=True)
+        assert "detail" in dumped

csrd_models-0.1.0/tests/test_model_parser.py

@@ -0,0 +1,94 @@
+"""Tests for ModelParserMixin."""
+
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from csrd.models.model_parser import ModelParserMixin
+
+
+class Item(BaseModel):
+    name: str
+    price: float
+
+
+class TestModelParserMixin:
+    def setup_method(self):
+        self.parser = ModelParserMixin()
+
+    def test_apply_model_dict_to_model(self):
+        result = self.parser.apply_model({"name": "Widget", "price": 9.99}, model=Item)
+        assert isinstance(result, Item)
+        assert result.name == "Widget"
+        assert result.price == 9.99
+
+    def test_apply_model_list_to_list_model(self):
+        data = [{"name": "A", "price": 1.0}, {"name": "B", "price": 2.0}]
+        result = self.parser.apply_model(data, model=list[Item])
+        assert isinstance(result, list)
+        assert len(result) == 2
+        assert result[0].name == "A"
+        assert result[1].name == "B"
+
+    def test_apply_model_no_model_passthrough(self):
+        data = {"key": "value"}
+        result = self.parser.apply_model(data)
+        assert result == data
+
+    def test_apply_model_none_model_passthrough(self):
+        data = [1, 2, 3]
+        result = self.parser.apply_model(data, model=None)
+        assert result == [1, 2, 3]
+
+    def test_apply_model_dict_expected_but_list_given(self):
+        with pytest.raises(TypeError, match="Expected dict"):
+            self.parser.apply_model([1, 2], model=Item)
+
+    def test_apply_model_list_expected_but_dict_given(self):
+        with pytest.raises(TypeError, match="Expected list"):
+            self.parser.apply_model({"name": "X", "price": 1.0}, model=list[Item])
+
+    def test_apply_model_validation_error(self):
+        with pytest.raises(ValidationError):
+            self.parser.apply_model({"name": "X"}, model=Item)  # missing price
+
+    def test_apply_model_custom_exception(self):
+        with pytest.raises(ValueError):
+            self.parser.apply_model({"wrong": "data"}, model=Item, exception=ValueError)
+
+    def test_apply_model_with_handler(self):
+        def custom_handler(source, model):
+            return "custom_result"
+
+        result = self.parser.apply_model(
+            {"name": "X", "price": 1.0}, model=Item, model_handler=custom_handler
+        )
+        assert result == "custom_result"
+
+    def test_apply_model_with_json_source(self):
+        """Test DefaultExtractor handles objects with .json() method."""
+
+        class FakeResponse:
+            def json(self):
+                return {"name": "FromJSON", "price": 5.0}
+
+        result = self.parser.apply_model(FakeResponse(), model=Item)
+        assert result.name == "FromJSON"
+
+    def test_custom_extractor(self):
+        class UpperExtractor:
+            def extract(self, source):
+                return {k.upper(): v for k, v in source.items()}
+
+        # Use extractor at parse time
+        parser = ModelParserMixin()
+
+        class UpperModel(BaseModel):
+            NAME: str
+            PRICE: float
+
+        result = parser.apply_model(
+            {"name": "test", "price": 1.0},
+            model=UpperModel,
+            extractor=UpperExtractor(),
+        )
+        assert result.NAME == "test"