fixturify 0.1.9__py3-none-any.whl

fixturify/object_mapper/_serializers/_sqlalchemy.py

@@ -0,0 +1,70 @@
+"""SQLAlchemy model serializer."""
+
+from typing import Any
+
+from fixturify.object_mapper._serializers._base import _BaseSerializer
+
+
+class _SQLAlchemySerializer(_BaseSerializer):
+    """Serializer for SQLAlchemy models."""
+
+    def serialize(self, obj: Any) -> dict:
+        """
+        Serialize a SQLAlchemy model to a dictionary.
+
+        Args:
+            obj: A SQLAlchemy model instance
+
+        Returns:
+            Dictionary representation of the model
+        """
+        self.reset()
+        return self._serialize_with_path(obj, "#")
+
+    def _serialize_object(self, obj: Any, path: str) -> dict:
+        """Serialize a SQLAlchemy model."""
+        obj_type = type(obj)
+
+        # Check if this is a SQLAlchemy model
+        if hasattr(obj_type, "__tablename__") and hasattr(obj_type, "__mapper__"):
+            return self._serialize_sqlalchemy(obj, path)
+
+        # Fall back to base implementation for nested non-SQLAlchemy objects
+        return super()._serialize_object(obj, path)
+
+    def _serialize_sqlalchemy(self, obj: Any, path: str) -> dict:
+        """Serialize a SQLAlchemy model using its mapper columns."""
+        result = {}
+
+        # Get the mapper for column information
+        mapper = getattr(type(obj), "__mapper__", None)
+        if mapper is None:
+            return result
+
+        # Iterate over column properties
+        for column in mapper.columns:
+            column_name = column.key
+
+            # Skip dunder fields
+            if self._is_dunder(column_name):
+                continue
+
+            value = getattr(obj, column_name, None)
+            item_path = f"{path}/{column_name}"
+            result[column_name] = self._serialize_value(value, item_path)
+
+        # Also handle relationships if loaded (not lazy)
+        for relationship in mapper.relationships:
+            rel_name = relationship.key
+
+            # Skip dunder fields
+            if self._is_dunder(rel_name):
+                continue
+
+            # Check if the relationship is loaded
+            if rel_name in obj.__dict__:
+                value = getattr(obj, rel_name, None)
+                item_path = f"{path}/{rel_name}"
+                result[rel_name] = self._serialize_value(value, item_path)
+
+        return result

fixturify/object_mapper/_serializers/_sqlmodel.py

@@ -0,0 +1,54 @@
+"""SQLModel model serializer."""
+
+from typing import Any
+
+from fixturify.object_mapper._serializers._base import _BaseSerializer
+
+
+class _SQLModelSerializer(_BaseSerializer):
+    """Serializer for SQLModel models."""
+
+    def serialize(self, obj: Any) -> dict:
+        """
+        Serialize a SQLModel model to a dictionary.
+
+        SQLModel combines Pydantic v2 and SQLAlchemy, so we use
+        Pydantic's model_fields for serialization.
+
+        Args:
+            obj: A SQLModel model instance
+
+        Returns:
+            Dictionary representation of the model
+        """
+        self.reset()
+        return self._serialize_with_path(obj, "#")
+
+    def _serialize_object(self, obj: Any, path: str) -> dict:
+        """Serialize a SQLModel model."""
+        obj_type = type(obj)
+
+        # Check if this is a SQLModel model (has both __tablename__ and model_fields)
+        if hasattr(obj_type, "__tablename__") and hasattr(obj_type, "model_fields"):
+            return self._serialize_sqlmodel(obj, path)
+
+        # Fall back to base implementation for nested non-SQLModel objects
+        return super()._serialize_object(obj, path)
+
+    def _serialize_sqlmodel(self, obj: Any, path: str) -> dict:
+        """Serialize a SQLModel using its model_fields (Pydantic v2 style)."""
+        result = {}
+
+        # Get fields from model_fields (Pydantic v2)
+        model_fields = getattr(type(obj), "model_fields", {})
+
+        for field_name in model_fields:
+            # Skip dunder fields
+            if self._is_dunder(field_name):
+                continue
+
+            value = getattr(obj, field_name)
+            item_path = f"{path}/{field_name}"
+            result[field_name] = self._serialize_value(value, item_path)
+
+        return result

fixturify/object_mapper/mapper.py

@@ -0,0 +1,256 @@
+"""Main ObjectMapper class for bidirectional object-to-JSON mapping."""
+
+import json
+from enum import Enum
+from typing import Any, List, Optional, Type, TypeVar, Union
+
+from fixturify.object_mapper._detectors import _TypeDetector, ObjectType
+from fixturify.object_mapper._serializers import (
+    _BaseSerializer,
+    _DataclassSerializer,
+    _PlainObjectSerializer,
+    _PydanticV1Serializer,
+    _PydanticV2Serializer,
+    _SQLAlchemySerializer,
+    _SQLModelSerializer,
+)
+from fixturify.object_mapper._deserializers import (
+    _DataclassDeserializer,
+    _PlainObjectDeserializer,
+    _PydanticV1Deserializer,
+    _PydanticV2Deserializer,
+    _SQLAlchemyDeserializer,
+    _SQLModelDeserializer,
+)
+
+T = TypeVar("T")
+
+
+class ObjectMapper:
+    """
+    Universal object-to-JSON mapper supporting multiple object types.
+
+    Supports:
+    - Plain Python objects
+    - Dataclasses
+    - Pydantic v1 models
+    - Pydantic v2 models
+    - SQLAlchemy models
+    - SQLModel models
+    - Collections (list, tuple, set)
+    - Dictionaries
+    """
+
+    # Serializer instances (lazy-loaded)
+    _serializers = {
+        ObjectType.DATACLASS: _DataclassSerializer,
+        ObjectType.PYDANTIC_V1: _PydanticV1Serializer,
+        ObjectType.PYDANTIC_V2: _PydanticV2Serializer,
+        ObjectType.SQLALCHEMY: _SQLAlchemySerializer,
+        ObjectType.SQLMODEL: _SQLModelSerializer,
+        ObjectType.PLAIN_OBJECT: _PlainObjectSerializer,
+    }
+
+    # Deserializer instances (lazy-loaded)
+    _deserializers = {
+        ObjectType.DATACLASS: _DataclassDeserializer,
+        ObjectType.PYDANTIC_V1: _PydanticV1Deserializer,
+        ObjectType.PYDANTIC_V2: _PydanticV2Deserializer,
+        ObjectType.SQLALCHEMY: _SQLAlchemyDeserializer,
+        ObjectType.SQLMODEL: _SQLModelDeserializer,
+        ObjectType.PLAIN_OBJECT: _PlainObjectDeserializer,
+    }
+
+    # Flag to track if serializer registry has been set
+    _registry_initialized = False
+
+    @classmethod
+    def _ensure_registry_initialized(cls) -> None:
+        """Initialize the serializer registry for nested object routing."""
+        if not cls._registry_initialized:
+            _BaseSerializer.set_serializer_registry(cls._serializers)
+            cls._registry_initialized = True
+
+    def __init__(self, data: Any) -> None:
+        """
+        Initialize ObjectMapper with data.
+
+        Args:
+            data: Any data - object, collection, dict, or JSON string
+        """
+        # Ensure serializer registry is initialized for nested type routing
+        ObjectMapper._ensure_registry_initialized()
+
+        self._data = data
+        self._data_type = _TypeDetector.detect(data)
+
+    def to_json(self) -> Any:
+        """
+        Convert stored object/collection to JSON-compatible value.
+
+        Returns:
+            JSON-compatible value: dict, list, or primitive (str, int, float, bool, None)
+
+        Raises:
+            ValueError: If serialization fails
+        """
+        try:
+            return self._serialize(self._data)
+        except Exception as e:
+            raise ValueError(f"Serialization failed: {e}") from e
+
+    def to_json_string(self, indent: Optional[int] = None) -> str:
+        """
+        Convert stored object/collection to JSON string.
+
+        Args:
+            indent: Optional indentation level for pretty printing
+
+        Returns:
+            JSON string representation
+
+        Raises:
+            ValueError: If serialization fails
+        """
+        try:
+            serialized = self._serialize(self._data)
+            return json.dumps(serialized, indent=indent, ensure_ascii=False)
+        except Exception as e:
+            raise ValueError(f"Serialization failed: {e}") from e
+
+    def to_object(self, target_class: Type[T]) -> Union[T, List[T]]:
+        """
+        Convert stored JSON/dict to object or list of objects.
+
+        Args:
+            target_class: The class to deserialize into
+
+        Returns:
+            Instance of target_class, or list of instances if input is a list
+
+        Raises:
+            ValueError: If deserialization fails
+            TypeError: If target_class is unsupported
+        """
+        try:
+            # Parse JSON string if needed
+            if self._data_type == ObjectType.JSON_STRING:
+                data = json.loads(self._data)
+                # If parsed data is a primitive (e.g., string for enum), handle it
+                if not isinstance(data, (dict, list)):
+                    return self._deserialize_primitive(data, target_class)
+            elif self._data_type == ObjectType.DICT:
+                data = self._data
+            elif self._data_type == ObjectType.COLLECTION:
+                # If it's already a collection, use it directly
+                data = list(self._data)
+            elif self._data_type == ObjectType.PRIMITIVE:
+                # Handle primitive types (for Enum deserialization)
+                return self._deserialize_primitive(self._data, target_class)
+            else:
+                raise ValueError(
+                    f"to_object() requires JSON string, dict, or collection. "
+                    f"Got: {self._data_type}"
+                )
+
+            # Handle list of objects
+            if isinstance(data, list):
+                return self._deserialize_list(data, target_class)
+
+            # Handle single object
+            return self._deserialize(data, target_class)
+
+        except Exception as e:
+            if isinstance(e, (ValueError, TypeError)):
+                raise
+            raise ValueError(f"Deserialization failed: {e}") from e
+
+    def _serialize(self, data: Any) -> Any:
+        """
+        Serialize data to a JSON-compatible format.
+
+        Uses a single serializer instance for the entire serialization to ensure
+        shared reference tracking (via $ref) works correctly across all items
+        in root-level dicts and collections.
+
+        Args:
+            data: Data to serialize
+
+        Returns:
+            JSON-compatible dict, list, or primitive
+        """
+        data_type = _TypeDetector.detect(data)
+
+        # Handle primitives directly (no need for serializer)
+        if data_type == ObjectType.PRIMITIVE:
+            if isinstance(data, Enum):
+                return data.value
+            return data
+
+        # Handle JSON string (return parsed)
+        if data_type == ObjectType.JSON_STRING:
+            return json.loads(data)
+
+        # For dicts, collections, and objects, use a single serializer instance
+        # to maintain shared visited state across the entire serialization tree.
+        # This ensures $ref works correctly for shared objects in root collections/dicts.
+        serializer = _PlainObjectSerializer()
+        serializer.reset()
+        return serializer._serialize_value(data, "#")
+
+    def _deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a dict to an object.
+
+        Args:
+            data: Dictionary data
+            target_class: Target class
+
+        Returns:
+            Instance of target_class
+        """
+        # Detect target class type
+        class_type = _TypeDetector.detect_class(target_class)
+
+        # Get appropriate deserializer
+        deserializer_class = self._deserializers.get(class_type)
+        if deserializer_class is None:
+            raise TypeError(f"Unsupported target class type: {class_type}")
+
+        deserializer = deserializer_class()
+        return deserializer.deserialize(data, target_class)
+
+    def _deserialize_list(self, data: list, target_class: Type[T]) -> List[T]:
+        """
+        Deserialize a list to a list of objects.
+
+        Args:
+            data: List of items (dicts for objects, or primitives for Enums)
+            target_class: Target class for each item
+
+        Returns:
+            List of target_class instances
+        """
+        result = []
+        for item in data:
+            if isinstance(item, dict):
+                result.append(self._deserialize(item, target_class))
+            else:
+                # Handle primitives (e.g., list of Enums or simple values)
+                result.append(self._deserialize_primitive(item, target_class))
+        return result
+
+    def _deserialize_primitive(self, data: Any, target_class: Type[T]) -> T:
+        """
+        Deserialize a primitive value to a target class (e.g., Enum).
+
+        Args:
+            data: Primitive value
+            target_class: Target class (e.g., Enum subclass)
+
+        Returns:
+            Instance of target_class
+        """
+        if isinstance(target_class, type) and issubclass(target_class, Enum):
+            return target_class(data)
+        return data

fixturify/read_d/__init__.py

@@ -0,0 +1,5 @@
+"""Read decorator module for injecting file-based test data."""
+
+from fixturify.read_d._decorator import read
+
+__all__ = ["read"]

fixturify/read_d/_decorator.py

@@ -0,0 +1,193 @@
+"""Read decorator implementation for injecting test fixtures."""
+
+import asyncio
+import functools
+import inspect
+from typing import Callable, Optional, Type, TypeVar, List
+
+from fixturify.read_d._fixture_loader import _FixtureLoader
+
+T = TypeVar("T")
+
+
+def _unwrap_func(func: Callable) -> Callable:
+    """Return the original function by walking the __wrapped__ chain."""
+    original = func
+    while hasattr(original, "__wrapped__"):
+        original = original.__wrapped__
+    return original
+
+
+def _get_base_signature(func: Callable) -> inspect.Signature:
+    """Return the most accurate signature, honoring custom __signature__."""
+    if hasattr(func, "__signature__"):
+        return func.__signature__  # type: ignore
+    return inspect.signature(func)
+
+
+def _create_new_signature(
+    original_sig: inspect.Signature, fixture_names: List[str]
+) -> inspect.Signature:
+    """
+    Create a new signature that excludes the fixture parameter names.
+
+    This prevents pytest from trying to inject these parameters as pytest fixtures.
+    """
+    new_params = [
+        param
+        for param in original_sig.parameters.values()
+        if param.name not in fixture_names
+    ]
+    return original_sig.replace(parameters=new_params)
+
+
+class read:
+    """
+    Namespace class for read decorators.
+
+    Provides the @read.fixture() decorator for injecting JSON file data
+    into test functions.
+    """
+
+    @staticmethod
+    def fixture(
+        path: str, fixture_name: str, object_class: Optional[Type[T]] = None
+    ) -> Callable:
+        """
+        Decorator that injects a JSON file as a typed object into a test function.
+
+        This decorator loads JSON data from a file and injects it as a named
+        parameter into the decorated function. The path is resolved relative
+        to the test file's location.
+
+        Args:
+            path: Relative path to JSON file (from test file location)
+            fixture_name: Name of the parameter to inject
+            object_class: Optional class to deserialize JSON into (via ObjectMapper).
+                         If None, returns raw dict/list from JSON.
+
+        Returns:
+            Decorated function with fixture injected
+
+        Example:
+            @read.fixture(path="./fixtures/user.json", fixture_name="user", object_class=User)
+            def test_user_creation(user: User):
+                assert user.name == "John"
+
+        Note:
+            This is NOT a pytest fixture. It's a pure Python function wrapper
+            that works with any test framework (pytest, unittest, nose, etc.).
+        """
+
+        def decorator(func: Callable) -> Callable:
+            # Get the test file path at decoration time
+            # If the function is already wrapped by another @read.fixture,
+            # use the stored test file path from the first decorator
+            if hasattr(func, "__pytools_test_file__"):
+                test_file_path = func.__pytools_test_file__
+            else:
+                test_file_path = inspect.getfile(_unwrap_func(func))
+
+            # Get the original function's signature for validation
+            original_func = _unwrap_func(func)
+            original_sig = inspect.signature(original_func)
+            original_params = set(original_sig.parameters.keys())
+
+            # Check if function accepts **kwargs (VAR_KEYWORD)
+            has_var_keyword = any(
+                param.kind == inspect.Parameter.VAR_KEYWORD
+                for param in original_sig.parameters.values()
+            )
+
+            # Validate that fixture_name exists in the function signature
+            # (excluding 'self' for methods, and skip if **kwargs is present)
+            if not has_var_keyword:
+                params_to_check = original_params - {"self", "cls"}
+                if fixture_name not in params_to_check:
+                    raise ValueError(
+                        f"Fixture name '{fixture_name}' not found in function '{func.__name__}' signature. "
+                        f"Available parameters: {', '.join(sorted(params_to_check)) or 'none'}"
+                    )
+
+            # Get or create fixtures list on the function
+            if not hasattr(func, "__pytools_fixtures__"):
+                func.__pytools_fixtures__ = []
+
+            # Check for duplicate fixture names across stacked decorators
+            existing_names = [
+                loader.fixture_name
+                for loader in getattr(func, "__pytools_fixtures__", [])
+            ]
+            if fixture_name in existing_names:
+                raise ValueError(
+                    f"Duplicate fixture name '{fixture_name}' in decorators "
+                    f"for function '{func.__name__}'"
+                )
+
+            # Create and add the fixture loader
+            loader = _FixtureLoader(
+                path=path,
+                fixture_name=fixture_name,
+                object_class=object_class,
+                test_file_path=test_file_path,
+            )
+            func.__pytools_fixtures__.append(loader)
+
+            # Get all fixture names for signature modification
+            all_fixture_names = [ldr.fixture_name for ldr in func.__pytools_fixtures__]
+
+            # Check if the function is async
+            if asyncio.iscoroutinefunction(func):
+
+                @functools.wraps(func)
+                async def async_wrapper(*args, **kwargs):
+                    request = kwargs.pop("request", None)
+                    if request is None:
+                        request = kwargs.pop("_pytools_request", None)
+                    if getattr(func, "__pytools_wrapper__", False) and request is not None:
+                        kwargs["_pytools_request"] = request
+
+                    # Load all fixtures (sync operation)
+                    for fixture_loader in async_wrapper.__pytools_fixtures__:
+                        kwargs[fixture_loader.fixture_name] = fixture_loader.load()
+                    return await func(*args, **kwargs)
+
+                async_wrapper.__pytools_fixtures__ = func.__pytools_fixtures__
+                async_wrapper.__pytools_test_file__ = test_file_path
+                async_wrapper.__pytools_wrapper__ = True  # type: ignore
+
+                # Modify signature to exclude fixture parameters
+                base_sig = _get_base_signature(func)
+                async_wrapper.__signature__ = _create_new_signature(
+                    base_sig, all_fixture_names
+                )
+
+                return async_wrapper
+            else:
+
+                @functools.wraps(func)
+                def sync_wrapper(*args, **kwargs):
+                    request = kwargs.pop("request", None)
+                    if request is None:
+                        request = kwargs.pop("_pytools_request", None)
+                    if getattr(func, "__pytools_wrapper__", False) and request is not None:
+                        kwargs["_pytools_request"] = request
+
+                    # Load all fixtures
+                    for fixture_loader in sync_wrapper.__pytools_fixtures__:
+                        kwargs[fixture_loader.fixture_name] = fixture_loader.load()
+                    return func(*args, **kwargs)
+
+                sync_wrapper.__pytools_fixtures__ = func.__pytools_fixtures__
+                sync_wrapper.__pytools_test_file__ = test_file_path
+                sync_wrapper.__pytools_wrapper__ = True  # type: ignore
+
+                # Modify signature to exclude fixture parameters
+                base_sig = _get_base_signature(func)
+                sync_wrapper.__signature__ = _create_new_signature(
+                    base_sig, all_fixture_names
+                )
+
+                return sync_wrapper
+
+        return decorator

fixturify/read_d/_fixture_loader.py

@@ -0,0 +1,88 @@
+"""Fixture loading logic for reading JSON files and mapping to objects."""
+
+import json
+from typing import Optional, Type, TypeVar, Union, List
+
+from fixturify._utils._constants import ENCODING
+from fixturify._utils._path_resolver import _PathResolver
+from fixturify.object_mapper import ObjectMapper
+
+T = TypeVar("T")
+
+
+class _FixtureLoader:
+    """
+    Loads JSON fixtures and optionally maps them to objects.
+
+    Handles file reading, JSON parsing, and object conversion.
+    Each call to load() reads the file fresh (no caching).
+    """
+
+    def __init__(
+        self,
+        path: str,
+        fixture_name: str,
+        object_class: Optional[Type[T]],
+        test_file_path: str,
+    ):
+        """
+        Initialize the fixture loader.
+
+        Args:
+            path: Relative path to the JSON file
+            fixture_name: Name of the parameter to inject
+            object_class: Optional class to deserialize JSON into
+            test_file_path: Absolute path to the test file (for path resolution)
+        """
+        self._path = path
+        self._fixture_name = fixture_name
+        self._object_class = object_class
+        self._test_file_path = test_file_path
+
+    @property
+    def fixture_name(self) -> str:
+        """Return the fixture name for parameter injection."""
+        return self._fixture_name
+
+    def load(self) -> Union[T, List[T], dict, list]:
+        """
+        Load and optionally map the fixture.
+
+        Each call reads the file fresh from disk.
+
+        Returns:
+            The loaded fixture data, either as raw dict/list or mapped object(s)
+
+        Raises:
+            FileNotFoundError: If the JSON file doesn't exist
+            ValueError: If JSON parsing or object mapping fails
+        """
+        # Resolve the path relative to the test file
+        try:
+            resolved_path = _PathResolver.resolve(self._path, self._test_file_path)
+        except FileNotFoundError as e:
+            raise FileNotFoundError(
+                f"Fixture file not found: {self._path} "
+                f"(resolved from test file: {self._test_file_path})"
+            ) from e
+
+        # Read and parse the JSON file
+        try:
+            content = resolved_path.read_text(encoding=ENCODING)
+            data = json.loads(content)
+        except json.JSONDecodeError as e:
+            raise ValueError(
+                f"Invalid JSON in fixture file {resolved_path}: {e}"
+            ) from e
+
+        # If no object_class specified, return raw dict/list
+        if self._object_class is None:
+            return data
+
+        # Map to object using ObjectMapper
+        try:
+            return ObjectMapper(data).to_object(self._object_class)
+        except Exception as e:
+            raise ValueError(
+                f"Failed to convert fixture to {self._object_class.__name__}: {e}"
+            ) from e

fixturify/sql_d/__init__.py

@@ -0,0 +1,7 @@
+"""SQL module for executing SQL files before/after tests."""
+
+from fixturify.sql_d._config import SqlTestConfig
+from fixturify.sql_d._decorator import sql
+from fixturify.sql_d._phase import Phase
+
+__all__ = ["sql", "Phase", "SqlTestConfig"]