fixturify 0.1.9__py3-none-any.whl

fixturify/json_assert/_normalizer.py

@@ -0,0 +1,83 @@
+"""Normalizer for converting various input types to comparable format."""
+
+import json
+from typing import Any, Union
+
+from fixturify.object_mapper import ObjectMapper
+
+
+class _Normalizer:
+    """Converts various input types to dict/list for comparison."""
+
+    def normalize(self, data: Any) -> Union[dict, list]:
+        """
+        Convert input data to dict or list for comparison.
+
+        - Objects → ObjectMapper → dict/list
+        - Dict → as-is
+        - JSON string → json.loads → dict/list
+        - List of objects → ObjectMapper → list
+
+        Args:
+            data: Input data to normalize
+
+        Returns:
+            Normalized dict or list ready for comparison
+
+        Raises:
+            ValueError: If data cannot be normalized
+        """
+        # Handle dict - return as-is
+        if isinstance(data, dict):
+            return data
+
+        # Handle list/tuple/set - may contain objects to serialize
+        if isinstance(data, (list, tuple, set)):
+            return self._normalize_collection(data)
+
+        # Handle JSON string
+        if isinstance(data, str):
+            try:
+                parsed = json.loads(data)
+                # Only accept JSON objects or arrays, not primitives
+                if not isinstance(parsed, (dict, list)):
+                    raise ValueError(
+                        f"JSON string must contain an object or array, got: {type(parsed).__name__}"
+                    )
+                return parsed
+            except json.JSONDecodeError:
+                raise ValueError(
+                    "String is not valid JSON. If comparing a string value, "
+                    "wrap it in a dict or compare directly."
+                )
+
+        # Handle objects using ObjectMapper
+        try:
+            result = ObjectMapper(data).to_json()
+            # Ensure result is a dict or list (not a primitive)
+            if not isinstance(result, (dict, list)):
+                raise ValueError(
+                    f"ObjectMapper returned a primitive ({type(result).__name__}). "
+                    f"JsonAssert expects objects that serialize to dict or list."
+                )
+            return result
+        except Exception as e:
+            raise ValueError(f"Cannot normalize data to JSON: {e}") from e
+
+    def _normalize_collection(self, collection: Any) -> list:
+        """Normalize a collection, serializing any objects within."""
+        result = []
+        for item in collection:
+            if isinstance(item, dict):
+                result.append(item)
+            elif isinstance(item, (list, tuple, set)):
+                result.append(self._normalize_collection(item))
+            elif isinstance(item, (str, int, float, bool, type(None))):
+                result.append(item)
+            else:
+                # Serialize object using ObjectMapper
+                try:
+                    result.append(ObjectMapper(item).to_json())
+                except Exception as e:
+                    raise ValueError(f"Cannot serialize collection item: {e}") from e
+        return result

fixturify/object_mapper/__init__.py

@@ -0,0 +1,5 @@
+"""ObjectMapper module for bidirectional object-to-JSON mapping."""
+
+from fixturify.object_mapper.mapper import ObjectMapper
+
+__all__ = ["ObjectMapper"]

fixturify/object_mapper/_deserializers/__init__.py

@@ -0,0 +1,19 @@
+"""Deserializer implementations for different object types."""
+
+from fixturify.object_mapper._deserializers._base import _BaseDeserializer
+from fixturify.object_mapper._deserializers._dataclass import _DataclassDeserializer
+from fixturify.object_mapper._deserializers._pydantic_v1 import _PydanticV1Deserializer
+from fixturify.object_mapper._deserializers._pydantic_v2 import _PydanticV2Deserializer
+from fixturify.object_mapper._deserializers._sqlalchemy import _SQLAlchemyDeserializer
+from fixturify.object_mapper._deserializers._sqlmodel import _SQLModelDeserializer
+from fixturify.object_mapper._deserializers._plain import _PlainObjectDeserializer
+
+__all__ = [
+    "_BaseDeserializer",
+    "_DataclassDeserializer",
+    "_PydanticV1Deserializer",
+    "_PydanticV2Deserializer",
+    "_SQLAlchemyDeserializer",
+    "_SQLModelDeserializer",
+    "_PlainObjectDeserializer",
+]

fixturify/object_mapper/_deserializers/_base.py

@@ -0,0 +1,186 @@
+"""Base deserializer class for all deserializers."""
+
+import sys
+from abc import ABC, abstractmethod
+from datetime import datetime, date, time
+from enum import Enum
+from typing import Any, Dict, Type, TypeVar, Union, get_type_hints
+from uuid import UUID
+
+T = TypeVar("T")
+
+
+class _BaseDeserializer(ABC):
+    """Abstract base class for all deserializers."""
+
+    @abstractmethod
+    def deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Convert a dictionary to an object of target_class.
+
+        Args:
+            data: Dictionary data to deserialize
+            target_class: The class to create an instance of
+
+        Returns:
+            Instance of target_class
+        """
+        pass
+
+    def _get_type_hints(self, cls: Type) -> Dict[str, Any]:
+        """
+        Get type hints for a class, resolving forward references.
+
+        Args:
+            cls: The class to get type hints for
+
+        Returns:
+            Dictionary of field names to their types
+        """
+        try:
+            # Try to get type hints with the class's module globals
+            module = sys.modules.get(cls.__module__, None)
+            globalns = getattr(module, "__dict__", {}) if module else {}
+            return get_type_hints(cls, globalns=globalns, localns=None)
+        except Exception:
+            # Fallback to __annotations__ if get_type_hints fails
+            return getattr(cls, "__annotations__", {})
+
+    def _convert_value(self, value: Any, target_type: Type) -> Any:
+        """
+        Convert a value to the target type.
+
+        Args:
+            value: The value to convert
+            target_type: The target type
+
+        Returns:
+            Converted value
+        """
+        # Handle None
+        if value is None:
+            return None
+
+        # Handle Any type
+        if target_type is Any:
+            return value
+
+        # Get the origin type for generic types
+        origin = getattr(target_type, "__origin__", None)
+        args = getattr(target_type, "__args__", ())
+
+        # Handle Optional (Union with None)
+        if origin is Union:
+            # Filter out NoneType from args
+            non_none_args = [arg for arg in args if arg is not type(None)]
+            if len(non_none_args) == 1:
+                # This is Optional[T]
+                return self._convert_value(value, non_none_args[0])
+            # For Union with multiple types, try each one
+            for arg in non_none_args:
+                try:
+                    return self._convert_value(value, arg)
+                except (ValueError, TypeError):
+                    continue
+            return value
+
+        # Handle List
+        if origin is list or target_type is list:
+            if not isinstance(value, list):
+                return value
+            item_type = args[0] if args else Any
+            return [self._convert_value(item, item_type) for item in value]
+
+        # Handle Set
+        if origin is set or target_type is set:
+            if not isinstance(value, (list, set)):
+                return value
+            item_type = args[0] if args else Any
+            return {self._convert_value(item, item_type) for item in value}
+
+        # Handle Tuple
+        if origin is tuple or target_type is tuple:
+            if not isinstance(value, (list, tuple)):
+                return value
+            if args:
+                # Handle Tuple[T, ...] (variable-length homogeneous tuple)
+                # In this case, args = (T, Ellipsis)
+                if len(args) >= 2 and args[-1] is ...:
+                    item_type = args[0]
+                    return tuple(self._convert_value(item, item_type) for item in value)
+                # Handle Tuple[T1, T2, ...] (fixed-length heterogeneous tuple)
+                return tuple(
+                    self._convert_value(item, args[i] if i < len(args) else args[-1])
+                    for i, item in enumerate(value)
+                )
+            return tuple(value)
+
+        # Handle Dict
+        if origin is dict or target_type is dict:
+            if not isinstance(value, dict):
+                return value
+            if len(args) >= 2:
+                key_type, val_type = args[0], args[1]
+                return {
+                    self._convert_value(k, key_type): self._convert_value(v, val_type)
+                    for k, v in value.items()
+                }
+            return value
+
+        # Handle datetime
+        if target_type is datetime:
+            if isinstance(value, str):
+                return datetime.fromisoformat(value)
+            return value
+
+        # Handle date
+        if target_type is date:
+            if isinstance(value, str):
+                return date.fromisoformat(value)
+            return value
+
+        # Handle time
+        if target_type is time:
+            if isinstance(value, str):
+                return time.fromisoformat(value)
+            return value
+
+        # Handle UUID
+        if target_type is UUID:
+            if isinstance(value, str):
+                return UUID(value)
+            return value
+
+        # Handle Enum
+        if isinstance(target_type, type) and issubclass(target_type, Enum):
+            return target_type(value)
+
+        # Handle primitives
+        if target_type in (str, int, float, bool):
+            if isinstance(value, target_type):
+                return value
+            try:
+                return target_type(value)
+            except (ValueError, TypeError):
+                return value
+
+        # Handle nested objects (dict to object)
+        if isinstance(value, dict) and isinstance(target_type, type):
+            return self._deserialize_nested(value, target_type)
+
+        return value
+
+    def _deserialize_nested(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a nested object. Override in subclasses for specific handling.
+
+        Args:
+            data: Dictionary data
+            target_class: The target class
+
+        Returns:
+            Instance of target_class
+        """
+        # This will be overridden by subclasses
+        # Default: try to instantiate with **data
+        return target_class(**data)

fixturify/object_mapper/_deserializers/_dataclass.py

@@ -0,0 +1,52 @@
+"""Dataclass deserializer."""
+
+from dataclasses import fields, is_dataclass
+from typing import Any, Type, TypeVar
+
+from fixturify.object_mapper._deserializers._base import _BaseDeserializer
+
+T = TypeVar("T")
+
+
+class _DataclassDeserializer(_BaseDeserializer):
+    """Deserializer for dataclass objects."""
+
+    def deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a dictionary to a dataclass.
+
+        Args:
+            data: Dictionary data to deserialize
+            target_class: The dataclass to create an instance of
+
+        Returns:
+            Instance of target_class
+
+        Raises:
+            TypeError: If target_class is not a dataclass
+        """
+        if not is_dataclass(target_class):
+            raise TypeError(f"Expected a dataclass, got {target_class}")
+
+        # Get type hints for field type information
+        type_hints = self._get_type_hints(target_class)
+
+        # Build kwargs for dataclass constructor
+        kwargs = {}
+        dataclass_fields = {f.name for f in fields(target_class)}
+
+        for field_name in dataclass_fields:
+            if field_name in data:
+                value = data[field_name]
+                target_type = type_hints.get(field_name, Any)
+                kwargs[field_name] = self._convert_value(value, target_type)
+
+        return target_class(**kwargs)
+
+    def _deserialize_nested(self, data: dict, target_class: Type[T]) -> T:
+        """Deserialize a nested object."""
+        if is_dataclass(target_class):
+            return self.deserialize(data, target_class)
+
+        # For non-dataclass nested objects, try basic instantiation
+        return target_class(**data)

fixturify/object_mapper/_deserializers/_plain.py

@@ -0,0 +1,55 @@
+"""Plain Python object deserializer."""
+
+from typing import Any, Type, TypeVar
+
+from fixturify.object_mapper._deserializers._base import _BaseDeserializer
+
+T = TypeVar("T")
+
+
+class _PlainObjectDeserializer(_BaseDeserializer):
+    """Deserializer for plain Python objects."""
+
+    def deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a dictionary to a plain Python object.
+
+        Attempts to create an instance using:
+        1. __init__ with keyword arguments
+        2. __new__ followed by attribute assignment
+
+        Args:
+            data: Dictionary data to deserialize
+            target_class: The class to create an instance of
+
+        Returns:
+            Instance of target_class
+        """
+        # Get type hints for nested object conversion
+        type_hints = self._get_type_hints(target_class)
+
+        # Convert values to appropriate types
+        converted_data = {}
+        for key, value in data.items():
+            target_type = type_hints.get(key, Any)
+            converted_data[key] = self._convert_value(value, target_type)
+
+        # Try to create instance with __init__
+        try:
+            return target_class(**converted_data)
+        except TypeError:
+            # __init__ doesn't accept kwargs, try manual assignment
+            pass
+
+        # Try creating with __new__ and manual assignment
+        try:
+            instance = object.__new__(target_class)
+            for key, value in converted_data.items():
+                setattr(instance, key, value)
+            return instance
+        except Exception as e:
+            raise ValueError(f"Cannot create instance of {target_class.__name__}: {e}")
+
+    def _deserialize_nested(self, data: dict, target_class: Type[T]) -> T:
+        """Deserialize a nested plain object."""
+        return self.deserialize(data, target_class)

fixturify/object_mapper/_deserializers/_pydantic_v1.py

@@ -0,0 +1,38 @@
+"""Pydantic v1 model deserializer."""
+
+from typing import Type, TypeVar
+
+from fixturify.object_mapper._deserializers._base import _BaseDeserializer
+
+T = TypeVar("T")
+
+
+class _PydanticV1Deserializer(_BaseDeserializer):
+    """Deserializer for Pydantic v1 models."""
+
+    def deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a dictionary to a Pydantic v1 model.
+
+        Pydantic v1 models accept dict data directly in their constructor
+        and handle validation/coercion internally.
+
+        Args:
+            data: Dictionary data to deserialize
+            target_class: The Pydantic v1 model class
+
+        Returns:
+            Instance of target_class
+        """
+        # Pydantic v1 handles validation and type coercion
+        # Just pass the data directly
+        return target_class(**data)
+
+    def _deserialize_nested(self, data: dict, target_class: Type[T]) -> T:
+        """Deserialize a nested Pydantic v1 model."""
+        # Check if it's a Pydantic v1 model
+        if hasattr(target_class, "__fields__") and hasattr(target_class, "schema"):
+            return self.deserialize(data, target_class)
+
+        # For non-Pydantic nested objects, try basic instantiation
+        return target_class(**data)

fixturify/object_mapper/_deserializers/_pydantic_v2.py

@@ -0,0 +1,41 @@
+"""Pydantic v2 model deserializer."""
+
+from typing import Type, TypeVar
+
+from fixturify.object_mapper._deserializers._base import _BaseDeserializer
+
+T = TypeVar("T")
+
+
+class _PydanticV2Deserializer(_BaseDeserializer):
+    """Deserializer for Pydantic v2 models."""
+
+    def deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a dictionary to a Pydantic v2 model.
+
+        Pydantic v2 models accept dict data directly in their constructor
+        and handle validation/coercion internally. Can also use model_validate().
+
+        Args:
+            data: Dictionary data to deserialize
+            target_class: The Pydantic v2 model class
+
+        Returns:
+            Instance of target_class
+        """
+        # Pydantic v2 has model_validate for dict -> model conversion
+        if hasattr(target_class, "model_validate"):
+            return target_class.model_validate(data)
+
+        # Fallback to constructor
+        return target_class(**data)
+
+    def _deserialize_nested(self, data: dict, target_class: Type[T]) -> T:
+        """Deserialize a nested Pydantic v2 model."""
+        # Check if it's a Pydantic v2 model
+        if hasattr(target_class, "model_fields"):
+            return self.deserialize(data, target_class)
+
+        # For non-Pydantic nested objects, try basic instantiation
+        return target_class(**data)

fixturify/object_mapper/_deserializers/_sqlalchemy.py

@@ -0,0 +1,72 @@
+"""SQLAlchemy model deserializer."""
+
+from typing import Any, Type, TypeVar
+
+from fixturify.object_mapper._deserializers._base import _BaseDeserializer
+
+T = TypeVar("T")
+
+
+class _SQLAlchemyDeserializer(_BaseDeserializer):
+    """Deserializer for SQLAlchemy models."""
+
+    def deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a dictionary to a SQLAlchemy model.
+
+        Args:
+            data: Dictionary data to deserialize
+            target_class: The SQLAlchemy model class
+
+        Returns:
+            Instance of target_class
+        """
+        # Get column information from mapper
+        mapper = getattr(target_class, "__mapper__", None)
+        if mapper is None:
+            # Fallback to simple instantiation
+            return target_class(**data)
+
+        # Get type hints for nested object conversion
+        type_hints = self._get_type_hints(target_class)
+
+        # Build kwargs, filtering to only column names
+        column_names = {col.key for col in mapper.columns}
+        kwargs = {}
+
+        for key, value in data.items():
+            if key in column_names:
+                target_type = type_hints.get(key, Any)
+                kwargs[key] = self._convert_value(value, target_type)
+
+        # Create instance
+        instance = target_class(**kwargs)
+
+        # Handle relationships if present in data
+        for relationship in mapper.relationships:
+            rel_name = relationship.key
+            if rel_name in data:
+                rel_data = data[rel_name]
+                rel_class = relationship.mapper.class_
+
+                if isinstance(rel_data, list):
+                    rel_instances = [
+                        self._deserialize_nested(item, rel_class) for item in rel_data
+                    ]
+                    setattr(instance, rel_name, rel_instances)
+                elif isinstance(rel_data, dict):
+                    rel_instance = self._deserialize_nested(rel_data, rel_class)
+                    setattr(instance, rel_name, rel_instance)
+
+        return instance
+
+    def _deserialize_nested(self, data: dict, target_class: Type[T]) -> T:
+        """Deserialize a nested SQLAlchemy model."""
+        # Check if it's a SQLAlchemy model
+        if hasattr(target_class, "__tablename__") and hasattr(
+            target_class, "__mapper__"
+        ):
+            return self.deserialize(data, target_class)
+
+        # For non-SQLAlchemy nested objects, try basic instantiation
+        return target_class(**data)

fixturify/object_mapper/_deserializers/_sqlmodel.py

@@ -0,0 +1,43 @@
+"""SQLModel model deserializer."""
+
+from typing import Type, TypeVar
+
+from fixturify.object_mapper._deserializers._base import _BaseDeserializer
+
+T = TypeVar("T")
+
+
+class _SQLModelDeserializer(_BaseDeserializer):
+    """Deserializer for SQLModel models."""
+
+    def deserialize(self, data: dict, target_class: Type[T]) -> T:
+        """
+        Deserialize a dictionary to a SQLModel model.
+
+        SQLModel combines Pydantic v2 and SQLAlchemy. We use Pydantic's
+        model_validate for deserialization as it handles validation.
+
+        Args:
+            data: Dictionary data to deserialize
+            target_class: The SQLModel model class
+
+        Returns:
+            Instance of target_class
+        """
+        # SQLModel uses Pydantic v2's model_validate
+        if hasattr(target_class, "model_validate"):
+            return target_class.model_validate(data)
+
+        # Fallback to constructor
+        return target_class(**data)
+
+    def _deserialize_nested(self, data: dict, target_class: Type[T]) -> T:
+        """Deserialize a nested SQLModel model."""
+        # Check if it's a SQLModel model
+        if hasattr(target_class, "__tablename__") and hasattr(
+            target_class, "model_fields"
+        ):
+            return self.deserialize(data, target_class)
+
+        # For non-SQLModel nested objects, try basic instantiation
+        return target_class(**data)

fixturify/object_mapper/_detectors/__init__.py

@@ -0,0 +1,5 @@
+"""Type detection utilities."""
+
+from fixturify.object_mapper._detectors._type_detector import _TypeDetector, ObjectType
+
+__all__ = ["_TypeDetector", "ObjectType"]