fixturify 0.1.9__py3-none-any.whl

fixturify/object_mapper/_detectors/_type_detector.py

@@ -0,0 +1,186 @@
+"""Type detection for determining object types."""
+
+import json
+from dataclasses import is_dataclass
+from enum import Enum, auto
+from typing import Any, Type
+
+
+class ObjectType(Enum):
+    """Enumeration of supported object types."""
+
+    JSON_STRING = auto()
+    DICT = auto()
+    COLLECTION = auto()
+    SQLMODEL = auto()
+    SQLALCHEMY = auto()
+    PYDANTIC_V2 = auto()
+    PYDANTIC_V1 = auto()
+    DATACLASS = auto()
+    PLAIN_OBJECT = auto()
+    PRIMITIVE = auto()
+
+
+class _TypeDetector:
+    """Detects the type of input data or class."""
+
+    # Primitive types that should be serialized directly
+    PRIMITIVE_TYPES = (str, int, float, bool, type(None))
+
+    @staticmethod
+    def detect(data: Any) -> ObjectType:
+        """
+        Detect the type of input data.
+
+        Detection order is critical for correct handling of hybrid types like SQLModel.
+
+        Args:
+            data: Any input data
+
+        Returns:
+            ObjectType enum value
+        """
+        # 1. Check for primitive types first
+        if isinstance(data, _TypeDetector.PRIMITIVE_TYPES):
+            if isinstance(data, str):
+                # Check if it's a valid JSON string
+                if _TypeDetector._is_json_string(data):
+                    return ObjectType.JSON_STRING
+            return ObjectType.PRIMITIVE
+
+        # 2. Check for dict
+        if isinstance(data, dict):
+            return ObjectType.DICT
+
+        # 3. Check for collections (list, tuple, set)
+        if isinstance(data, (list, tuple, set, frozenset)):
+            return ObjectType.COLLECTION
+
+        # 4. Check for SQLModel (must be before SQLAlchemy and Pydantic v2)
+        # SQLModel has both __tablename__ (from SQLAlchemy) and model_fields (from Pydantic v2)
+        if _TypeDetector._is_sqlmodel(data):
+            return ObjectType.SQLMODEL
+
+        # 5. Check for SQLAlchemy
+        if _TypeDetector._is_sqlalchemy(data):
+            return ObjectType.SQLALCHEMY
+
+        # 6. Check for Pydantic v2
+        if _TypeDetector._is_pydantic_v2(data):
+            return ObjectType.PYDANTIC_V2
+
+        # 7. Check for Pydantic v1
+        if _TypeDetector._is_pydantic_v1(data):
+            return ObjectType.PYDANTIC_V1
+
+        # 8. Check for dataclass
+        if is_dataclass(data) and not isinstance(data, type):
+            return ObjectType.DATACLASS
+
+        # 9. Fallback to plain object
+        return ObjectType.PLAIN_OBJECT
+
+    @staticmethod
+    def detect_class(cls: Type) -> ObjectType:
+        """
+        Detect the type from a class definition.
+
+        Args:
+            cls: A class type
+
+        Returns:
+            ObjectType enum value
+        """
+        # Check for SQLModel class
+        if _TypeDetector._is_sqlmodel_class(cls):
+            return ObjectType.SQLMODEL
+
+        # Check for SQLAlchemy class
+        if _TypeDetector._is_sqlalchemy_class(cls):
+            return ObjectType.SQLALCHEMY
+
+        # Check for Pydantic v2 class
+        if _TypeDetector._is_pydantic_v2_class(cls):
+            return ObjectType.PYDANTIC_V2
+
+        # Check for Pydantic v1 class
+        if _TypeDetector._is_pydantic_v1_class(cls):
+            return ObjectType.PYDANTIC_V1
+
+        # Check for dataclass
+        if is_dataclass(cls):
+            return ObjectType.DATACLASS
+
+        # Check for Enum
+        if isinstance(cls, type) and issubclass(cls, Enum):
+            return ObjectType.PRIMITIVE
+
+        # Fallback to plain object
+        return ObjectType.PLAIN_OBJECT
+
+    @staticmethod
+    def _is_json_string(data: str) -> bool:
+        """Check if a string is valid JSON.
+
+        This detects any valid JSON including primitives like "null", "true",
+        "123" and strings like '"active"'. The ObjectMapper.to_object() method
+        handles the parsed result appropriately based on target class.
+        """
+        try:
+            json.loads(data)
+            return True
+        except (json.JSONDecodeError, ValueError):
+            return False
+
+    @staticmethod
+    def _is_sqlmodel(obj: Any) -> bool:
+        """Check if object is a SQLModel instance."""
+        # SQLModel has both __tablename__ and model_fields
+        obj_type = type(obj)
+        return hasattr(obj_type, "__tablename__") and hasattr(obj_type, "model_fields")
+
+    @staticmethod
+    def _is_sqlmodel_class(cls: Type) -> bool:
+        """Check if class is a SQLModel class."""
+        return hasattr(cls, "__tablename__") and hasattr(cls, "model_fields")
+
+    @staticmethod
+    def _is_sqlalchemy(obj: Any) -> bool:
+        """Check if object is a SQLAlchemy model instance."""
+        obj_type = type(obj)
+        return hasattr(obj_type, "__tablename__") and hasattr(obj_type, "__mapper__")
+
+    @staticmethod
+    def _is_sqlalchemy_class(cls: Type) -> bool:
+        """Check if class is a SQLAlchemy model class."""
+        return hasattr(cls, "__tablename__") and hasattr(cls, "__mapper__")
+
+    @staticmethod
+    def _is_pydantic_v2(obj: Any) -> bool:
+        """Check if object is a Pydantic v2 model instance."""
+        obj_type = type(obj)
+        return hasattr(obj_type, "model_fields")
+
+    @staticmethod
+    def _is_pydantic_v2_class(cls: Type) -> bool:
+        """Check if class is a Pydantic v2 model class."""
+        return hasattr(cls, "model_fields")
+
+    @staticmethod
+    def _is_pydantic_v1(obj: Any) -> bool:
+        """Check if object is a Pydantic v1 model instance."""
+        obj_type = type(obj)
+        return (
+            hasattr(obj_type, "__fields__")
+            and hasattr(obj_type, "schema")
+            and callable(getattr(obj_type, "schema", None))
+        )
+
+    @staticmethod
+    def _is_pydantic_v1_class(cls: Type) -> bool:
+        """Check if class is a Pydantic v1 model class."""
+        return (
+            hasattr(cls, "__fields__")
+            and hasattr(cls, "schema")
+            and callable(getattr(cls, "schema", None))
+        )

fixturify/object_mapper/_serializers/__init__.py

@@ -0,0 +1,19 @@
+"""Serializer implementations for different object types."""
+
+from fixturify.object_mapper._serializers._base import _BaseSerializer
+from fixturify.object_mapper._serializers._dataclass import _DataclassSerializer
+from fixturify.object_mapper._serializers._plain import _PlainObjectSerializer
+from fixturify.object_mapper._serializers._pydantic_v1 import _PydanticV1Serializer
+from fixturify.object_mapper._serializers._pydantic_v2 import _PydanticV2Serializer
+from fixturify.object_mapper._serializers._sqlalchemy import _SQLAlchemySerializer
+from fixturify.object_mapper._serializers._sqlmodel import _SQLModelSerializer
+
+__all__ = [
+    "_BaseSerializer",
+    "_DataclassSerializer",
+    "_PlainObjectSerializer",
+    "_PydanticV1Serializer",
+    "_PydanticV2Serializer",
+    "_SQLAlchemySerializer",
+    "_SQLModelSerializer",
+]

fixturify/object_mapper/_serializers/_base.py

@@ -0,0 +1,260 @@
+"""Base serializer class for all serializers."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime, date, time
+from enum import Enum
+from typing import Any, Dict, TYPE_CHECKING
+from uuid import UUID
+
+from fixturify._utils._constants import MAX_DEPTH
+
+if TYPE_CHECKING:
+    pass
+
+
+class _BaseSerializer(ABC):
+    """Abstract base class for all serializers."""
+
+    # Reference path delimiter for $ref
+    REF_DELIMITER = "/"
+
+    # Class-level serializer registry (set by ObjectMapper)
+    _serializer_registry: Dict[Any, type] = {}
+
+    def __init__(self):
+        """Initialize the serializer with tracking state."""
+        self._visited: Dict[int, str] = {}  # id -> json path
+        self._current_depth: int = 0
+        self._max_depth: int = MAX_DEPTH
+
+    def reset(self):
+        """Reset the serializer state for a new serialization."""
+        self._visited.clear()
+        self._current_depth = 0
+
+    @classmethod
+    def set_serializer_registry(cls, registry: Dict[Any, type]) -> None:
+        """Set the serializer registry for nested object routing."""
+        cls._serializer_registry = registry
+
+    @abstractmethod
+    def serialize(self, obj: Any) -> dict:
+        """
+        Convert an object to a dictionary.
+
+        Args:
+            obj: The object to serialize
+
+        Returns:
+            Dictionary representation of the object
+        """
+        pass
+
+    def _serialize_with_path(self, obj: Any, path: str = "#") -> Any:
+        """
+        Serialize an object while tracking the JSON path for circular reference detection.
+
+        Args:
+            obj: The object to serialize
+            path: Current JSON path (default: root "#")
+
+        Returns:
+            Serialized value (could be dict, list, primitive, or $ref)
+        """
+        return self._serialize_value(obj, path)
+
+    def _serialize_value(self, value: Any, path: str) -> Any:
+        """
+        Serialize a single value, handling nested objects and collections.
+
+        Args:
+            value: The value to serialize
+            path: Current JSON path
+
+        Returns:
+            Serialized value
+        """
+        # Increment depth for complex types
+        self._current_depth += 1
+
+        if self._current_depth > self._max_depth:
+            raise ValueError(
+                f"Maximum serialization depth ({self._max_depth}) exceeded at path: {path}"
+            )
+
+        try:
+            # Handle None
+            if value is None:
+                return None
+
+            # Handle primitives
+            if isinstance(value, (str, int, float, bool)):
+                return value
+
+            # Handle special types
+            if isinstance(value, datetime):
+                return value.isoformat()
+
+            if isinstance(value, date):
+                return value.isoformat()
+
+            if isinstance(value, time):
+                return value.isoformat()
+
+            if isinstance(value, UUID):
+                return str(value)
+
+            if isinstance(value, Enum):
+                return value.value
+
+            # Handle bytes
+            if isinstance(value, bytes):
+                return value.decode("utf-8", errors="replace")
+
+            # Handle dict
+            if isinstance(value, dict):
+                return self._serialize_dict(value, path)
+
+            # Handle collections (list, tuple, set, frozenset)
+            if isinstance(value, (list, tuple, set, frozenset)):
+                return self._serialize_collection(value, path)
+
+            # Handle complex objects - check for circular reference
+            obj_id = id(value)
+            if obj_id in self._visited:
+                # Return a JSON reference
+                return {"$ref": self._visited[obj_id]}
+
+            # Mark as visited with current path
+            self._visited[obj_id] = path
+
+            # Route to appropriate serializer based on object type
+            return self._serialize_nested_object(value, path)
+        finally:
+            self._current_depth -= 1
+
+    def _serialize_nested_object(self, value: Any, path: str) -> dict:
+        """
+        Serialize a nested object using the appropriate type-specific serializer.
+
+        This method detects the nested object's type and routes to the correct
+        serializer, ensuring mixed-type object graphs are serialized correctly.
+
+        Args:
+            value: The nested object to serialize
+            path: Current JSON path
+
+        Returns:
+            Dictionary representation of the nested object
+        """
+        # Import here to avoid circular imports
+        from .._detectors import _TypeDetector
+
+        # Detect the nested object's type
+        obj_type = _TypeDetector.detect(value)
+
+        # If we have a registry and this type has a specific serializer, use it
+        if self._serializer_registry and obj_type in self._serializer_registry:
+            serializer_class = self._serializer_registry[obj_type]
+            # Create a new serializer but share state for circular reference detection
+            nested_serializer = serializer_class()
+            nested_serializer._visited = self._visited
+            nested_serializer._current_depth = self._current_depth
+            nested_serializer._max_depth = self._max_depth
+            return nested_serializer._serialize_object(value, path)
+
+        # Fallback to current serializer's _serialize_object
+        return self._serialize_object(value, path)
+
+    def _serialize_dict(self, d: dict, path: str) -> dict:
+        """Serialize a dictionary."""
+        result = {}
+        for key, value in d.items():
+            item_path = f"{path}/{key}"
+            result[key] = self._serialize_value(value, item_path)
+        return result
+
+    def _serialize_collection(self, collection: Any, path: str) -> list:
+        """Serialize a collection (list, tuple, set, frozenset).
+
+        For sets and frozensets, the output is sorted by serialized representation
+        to ensure deterministic output for stable tests and diffs.
+        """
+        result = []
+        for i, item in enumerate(collection):
+            item_path = f"{path}/{i}"
+            result.append(self._serialize_value(item, item_path))
+
+        # Sort sets and frozensets for deterministic output
+        if isinstance(collection, (set, frozenset)):
+            try:
+                # Try to sort by the serialized values
+                # For primitives, this sorts them directly
+                # For complex objects, this sorts by their string representation
+                result = sorted(result, key=lambda x: (type(x).__name__, str(x)))
+            except TypeError:
+                # If items are not comparable at all, leave unsorted
+                pass
+
+        return result
+
+    def _serialize_object(self, obj: Any, path: str) -> dict:
+        """
+        Serialize a complex object. Override in subclasses for specific handling.
+
+        Args:
+            obj: The object to serialize
+            path: Current JSON path
+
+        Returns:
+            Dictionary representation
+        """
+        # Default implementation - get object attributes
+        result = {}
+        for attr_name in self._get_serializable_attributes(obj):
+            value = getattr(obj, attr_name, None)
+            item_path = f"{path}/{attr_name}"
+            result[attr_name] = self._serialize_value(value, item_path)
+        return result
+
+    def _get_serializable_attributes(self, obj: Any) -> list:
+        """
+        Get list of attribute names that should be serialized.
+
+        Rules:
+        - Single underscore prefix (_attr): ARE serialized
+        - Double underscore dunder (__attr__): ARE NOT serialized
+
+        Args:
+            obj: The object to inspect
+
+        Returns:
+            List of attribute names to serialize
+        """
+        attributes = []
+        for attr_name in dir(obj):
+            # Skip dunder attributes
+            if attr_name.startswith("__") and attr_name.endswith("__"):
+                continue
+
+            # Skip methods and callables
+            attr_value = getattr(obj, attr_name, None)
+            if callable(attr_value) and not isinstance(attr_value, property):
+                continue
+
+            # Skip class-level attributes that are not instance-specific
+            if not hasattr(obj, "__dict__") or attr_name not in obj.__dict__:
+                # Also check __slots__ if present
+                if hasattr(type(obj), "__slots__"):
+                    if attr_name not in type(obj).__slots__:
+                        continue
+                else:
+                    continue
+
+            attributes.append(attr_name)
+
+        return attributes
+
+    def _is_dunder(self, name: str) -> bool:
+        """Check if a name is a dunder (double underscore) attribute."""
+        return name.startswith("__") and name.endswith("__")

fixturify/object_mapper/_serializers/_dataclass.py

@@ -0,0 +1,55 @@
+"""Dataclass serializer."""
+
+from dataclasses import fields, is_dataclass
+from typing import Any
+
+from fixturify.object_mapper._serializers._base import _BaseSerializer
+
+
+class _DataclassSerializer(_BaseSerializer):
+    """Serializer for dataclass objects."""
+
+    def serialize(self, obj: Any) -> dict:
+        """
+        Serialize a dataclass object to a dictionary.
+
+        Args:
+            obj: A dataclass instance
+
+        Returns:
+            Dictionary representation of the dataclass
+
+        Raises:
+            TypeError: If obj is not a dataclass instance
+        """
+        if not is_dataclass(obj) or isinstance(obj, type):
+            raise TypeError(f"Expected a dataclass instance, got {type(obj)}")
+
+        self.reset()
+        return self._serialize_with_path(obj, "#")
+
+    def _serialize_object(self, obj: Any, path: str) -> dict:
+        """Serialize a dataclass object."""
+        # Check if this is a dataclass
+        if is_dataclass(obj) and not isinstance(obj, type):
+            return self._serialize_dataclass(obj, path)
+
+        # Fall back to base implementation for nested non-dataclass objects
+        return super()._serialize_object(obj, path)
+
+    def _serialize_dataclass(self, obj: Any, path: str) -> dict:
+        """Serialize a dataclass using its fields."""
+        result = {}
+
+        for field in fields(obj):
+            field_name = field.name
+
+            # Skip dunder fields (though unlikely in dataclasses)
+            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/_serializers/_plain.py

@@ -0,0 +1,49 @@
+"""Plain Python object serializer."""
+
+from typing import Any
+
+from fixturify.object_mapper._serializers._base import _BaseSerializer
+
+
+class _PlainObjectSerializer(_BaseSerializer):
+    """Serializer for plain Python objects."""
+
+    def serialize(self, obj: Any) -> dict:
+        """
+        Serialize a plain Python object to a dictionary.
+
+        Args:
+            obj: A plain Python object with __dict__ or __slots__
+
+        Returns:
+            Dictionary representation of the object
+        """
+        self.reset()
+        return self._serialize_with_path(obj, "#")
+
+    def _serialize_object(self, obj: Any, path: str) -> dict:
+        """Serialize a plain Python object."""
+        result = {}
+
+        # Try to get attributes from __dict__
+        if hasattr(obj, "__dict__"):
+            for attr_name, value in obj.__dict__.items():
+                # Skip dunder attributes
+                if self._is_dunder(attr_name):
+                    continue
+                item_path = f"{path}/{attr_name}"
+                result[attr_name] = self._serialize_value(value, item_path)
+
+        # Also check __slots__ if present
+        if hasattr(type(obj), "__slots__"):
+            for slot_name in type(obj).__slots__:
+                if self._is_dunder(slot_name):
+                    continue
+                if slot_name in result:
+                    continue  # Already added from __dict__
+                if hasattr(obj, slot_name):
+                    value = getattr(obj, slot_name)
+                    item_path = f"{path}/{slot_name}"
+                    result[slot_name] = self._serialize_value(value, item_path)
+
+        return result

fixturify/object_mapper/_serializers/_pydantic_v1.py

@@ -0,0 +1,49 @@
+"""Pydantic v1 model serializer."""
+
+from typing import Any
+
+from fixturify.object_mapper._serializers._base import _BaseSerializer
+
+
+class _PydanticV1Serializer(_BaseSerializer):
+    """Serializer for Pydantic v1 models."""
+
+    def serialize(self, obj: Any) -> dict:
+        """
+        Serialize a Pydantic v1 model to a dictionary.
+
+        Args:
+            obj: A Pydantic v1 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 Pydantic v1 model."""
+        # Check if this is a Pydantic v1 model
+        if hasattr(type(obj), "__fields__") and hasattr(type(obj), "schema"):
+            return self._serialize_pydantic_v1(obj, path)
+
+        # Fall back to base implementation for nested non-Pydantic objects
+        return super()._serialize_object(obj, path)
+
+    def _serialize_pydantic_v1(self, obj: Any, path: str) -> dict:
+        """Serialize a Pydantic v1 model using its fields."""
+        result = {}
+
+        # Get fields from __fields__
+        model_fields = getattr(type(obj), "__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/_serializers/_pydantic_v2.py

@@ -0,0 +1,49 @@
+"""Pydantic v2 model serializer."""
+
+from typing import Any
+
+from fixturify.object_mapper._serializers._base import _BaseSerializer
+
+
+class _PydanticV2Serializer(_BaseSerializer):
+    """Serializer for Pydantic v2 models."""
+
+    def serialize(self, obj: Any) -> dict:
+        """
+        Serialize a Pydantic v2 model to a dictionary.
+
+        Args:
+            obj: A Pydantic v2 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 Pydantic v2 model."""
+        # Check if this is a Pydantic v2 model
+        if hasattr(type(obj), "model_fields"):
+            return self._serialize_pydantic_v2(obj, path)
+
+        # Fall back to base implementation for nested non-Pydantic objects
+        return super()._serialize_object(obj, path)
+
+    def _serialize_pydantic_v2(self, obj: Any, path: str) -> dict:
+        """Serialize a Pydantic v2 model using its model_fields."""
+        result = {}
+
+        # Get fields from model_fields
+        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