django-ninja-aio-crud 2.6.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

{django_ninja_aio_crud-2.6.1.dist-info → django_ninja_aio_crud-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 2.6.1
+Version: 2.7.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10, <3.15

{django_ninja_aio_crud-2.6.1.dist-info → django_ninja_aio_crud-2.7.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ninja_aio/__init__.py,sha256=ww2hnE9C7lFXzVyNnpZ97wv8erYcXdxhjzu8PRiM8bc,119
+ninja_aio/__init__.py,sha256=FkPurmyPz8Yv7VAiIOZYbFEghPXZ7aeLYX5xBwFSMtk,119
 ninja_aio/api.py,sha256=tuC7vdvn7s1GkCnSFy9Kn1zv0glZfYptRQVvo8ZRtGQ,2429
 ninja_aio/auth.py,sha256=4sWdFPjKiQgUL1d_CSGDblVjnY5ptP6LQha6XXdluJA,9157
 ninja_aio/exceptions.py,sha256=_3xFqfFCOfrrMhSA0xbMqgXy8R0UQjhXaExrFvaDAjY,3891
@@ -14,7 +14,7 @@ ninja_aio/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 ninja_aio/helpers/api.py,sha256=YMzuZ4-ZpUrJBQIabE26gb_GYwsH2rVosWRE95YfdPQ,20775
 ninja_aio/helpers/query.py,sha256=lzaH-htswoJVRT-W736HGMkpMba1VmN98TBLv5cZx9Q,4549
 ninja_aio/models/__init__.py,sha256=L3UQnQAlKoI3F7jinadL-Nn55hkPvnSRPYW0JtnbWFo,114
-ninja_aio/models/serializers.py,sha256=zV3gRI4isnCuLCAQbPhQlut3nKT0XuQOLy2ABiaJ6Y4,31372
+ninja_aio/models/serializers.py,sha256=AlZIkwIiOt-nGBfMDoXu9tJotfzH5L13fv3Rw_4sKUg,35697
 ninja_aio/models/utils.py,sha256=P-YfbVyzUfxm_s1BrgSd6Zs0HIGdZ79PU1qM0Ud9-Xs,30492
 ninja_aio/schemas/__init__.py,sha256=iLBwHg0pmL9k_UkIui5Q8QIl_gO4fgxSv2JHxDzqnSI,549
 ninja_aio/schemas/api.py,sha256=-VwXhBRhmMsZLIAmWJ-P7tB5klxXS75eukjabeKKYsc,360
@@ -23,7 +23,7 @@ ninja_aio/schemas/helpers.py,sha256=W6IeHi5Tmbjh3FXwDYqjqlLBTVj5uTYq3_JVkNUWayo,
 ninja_aio/views/__init__.py,sha256=DEzjWA6y3WF0V10nNF8eEurLNEodgxKzyFd09AqVp3s,148
 ninja_aio/views/api.py,sha256=GRtjCvAv7jAp3TxpOirsbMVKpBd8hymSMILdE-JLxvI,21327
 ninja_aio/views/mixins.py,sha256=Jh6BG8Cs823nurVlODlzCquTxKrLH7Pmo5udPqUGZek,11378
-django_ninja_aio_crud-2.6.1.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
-django_ninja_aio_crud-2.6.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-django_ninja_aio_crud-2.6.1.dist-info/METADATA,sha256=aBT8gpjs9TVS_jcs_c4m--5K8YFLjpAUpNPa0ib2T-0,9963
-django_ninja_aio_crud-2.6.1.dist-info/RECORD,,
+django_ninja_aio_crud-2.7.0.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
+django_ninja_aio_crud-2.7.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+django_ninja_aio_crud-2.7.0.dist-info/METADATA,sha256=_eQi4SR0xvfnLM6ShB-yvkxffFzUsxNCB39spSHWTOU,9963
+django_ninja_aio_crud-2.7.0.dist-info/RECORD,,

ninja_aio/__init__.py

@@ -1,6 +1,6 @@
 """Django Ninja AIO CRUD - Rest Framework"""
 
-__version__ = "2.6.1"
+__version__ = "2.7.0"
 
 from .api import NinjaAIO
 

ninja_aio/models/serializers.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Union, get_args, get_origin, ForwardRef
 import warnings
 import sys
 
@@ -69,19 +69,14 @@ class BaseSerializer:
         raise NotImplementedError
 
     @classmethod
-    def _resolve_serializer_reference(cls, serializer_ref: str | type) -> type:
+    def _resolve_string_reference(cls, string_ref: str) -> type:
         """
-        Resolve a serializer reference that may be a string or a class.
-
-        This method performs lazy resolution, meaning it will attempt to resolve
-        string references only when called, allowing for forward references and
-        circular dependencies between serializers in the same module.
+        Resolve a string serializer reference to an actual class.
 
         Parameters
         ----------
-        serializer_ref : str | type
-            Either a string reference to a serializer class name in the same module,
-            or an actual serializer class.
+        string_ref : str
+            String reference (local class name or absolute import path).
 
         Returns
         -------
@@ -93,35 +88,152 @@ class BaseSerializer:
         ValueError
             If the string reference cannot be resolved.
         """
-        # If it's already a class, return it directly
-        if not isinstance(serializer_ref, str):
-            return serializer_ref
+        # Check if it's an absolute import path (contains dots)
+        if "." in string_ref:
+            # Absolute import path: "myapp.serializers.UserSerializer"
+            module_path, class_name = string_ref.rsplit(".", 1)
 
-        # Get the module where the current serializer class is defined
+            try:
+                # Try to get or import the module
+                module = sys.modules.get(module_path)
+                if module is None:
+                    import importlib
+                    module = importlib.import_module(module_path)
+
+                # Get the serializer class from the module
+                serializer_class = getattr(module, class_name, None)
+
+                if serializer_class is None:
+                    raise ValueError(
+                        f"Cannot resolve serializer reference '{string_ref}': "
+                        f"class '{class_name}' not found in module '{module_path}'."
+                    )
+
+                return serializer_class
+            except ImportError as e:
+                raise ValueError(
+                    f"Cannot resolve serializer reference '{string_ref}': "
+                    f"failed to import module '{module_path}': {e}"
+                )
+
+        # Local reference: simple class name in the same module
         module = sys.modules.get(cls.__module__)
 
         if module is None:
             raise ValueError(
-                f"Cannot resolve serializer reference '{serializer_ref}': "
+                f"Cannot resolve serializer reference '{string_ref}': "
                 f"module '{cls.__module__}' not found in sys.modules."
             )
 
-        # Try to get the serializer class from the module
-        serializer_class = getattr(module, serializer_ref, None)
+        serializer_class = getattr(module, string_ref, None)
 
         if serializer_class is None:
             raise ValueError(
-                f"Cannot resolve serializer reference '{serializer_ref}' in module '{cls.__module__}'. "
-                f"Make sure the serializer class '{serializer_ref}' is defined in the same module as {cls.__name__}."
+                f"Cannot resolve serializer reference '{string_ref}' in module '{cls.__module__}'. "
+                f"Make sure the serializer class '{string_ref}' is defined in the same module as {cls.__name__}."
             )
 
         return serializer_class
 
+    @classmethod
+    def _resolve_serializer_reference(cls, serializer_ref: str | type | Any) -> type | Any:
+        """
+        Resolve a serializer reference that may be a string, a class, or a Union of serializers.
+
+        This method performs lazy resolution, meaning it will attempt to resolve
+        string references only when called, allowing for forward references and
+        circular dependencies between serializers in the same module.
+
+        Parameters
+        ----------
+        serializer_ref : str | type | Union
+            Either a string reference to a serializer class, an actual serializer class,
+            or a Union of serializer references. String references can be:
+            - A class name in the same module (e.g., "UserSerializer")
+            - An absolute import path (e.g., "myapp.serializers.UserSerializer")
+
+        Returns
+        -------
+        type | Union
+            The resolved serializer class or Union of serializer classes.
+
+        Raises
+        ------
+        ValueError
+            If the string reference cannot be resolved.
+
+        Examples
+        --------
+        >>> # Single reference
+        >>> cls._resolve_serializer_reference("UserSerializer")
+        >>> cls._resolve_serializer_reference(UserSerializer)
+        >>>
+        >>> # Union reference
+        >>> from typing import Union
+        >>> cls._resolve_serializer_reference(Union[UserSerializer, AdminSerializer])
+        >>> cls._resolve_serializer_reference(Union["UserSerializer", "AdminSerializer"])
+        """
+        # Handle Union types
+        origin = get_origin(serializer_ref)
+        if origin is Union:
+            resolved_types = tuple(
+                cls._resolve_serializer_reference(arg)
+                for arg in get_args(serializer_ref)
+            )
+            # Optimize single-type unions
+            if len(resolved_types) == 1:
+                return resolved_types[0]
+            # Create Union using indexing syntax for Python 3.10+ compatibility
+            return Union[resolved_types]
+
+        # Handle ForwardRef (created when using Union["StringType"])
+        if isinstance(serializer_ref, ForwardRef):
+            return cls._resolve_serializer_reference(serializer_ref.__forward_arg__)
+
+        # Handle string references
+        if isinstance(serializer_ref, str):
+            return cls._resolve_string_reference(serializer_ref)
+
+        # Already a class, return as-is
+        return serializer_ref
+
     @classmethod
     def _get_relations_serializers(cls) -> dict[str, "Serializer"]:
         # Optional in subclasses. Default to no explicit relation serializers.
         return {}
 
+    @classmethod
+    def _generate_union_schema(cls, resolved_union: Any) -> Any:
+        """
+        Generate a Union schema from multiple resolved serializers.
+
+        Parameters
+        ----------
+        resolved_union : Union
+            A Union type containing resolved serializer classes.
+
+        Returns
+        -------
+        Schema | Union[Schema, ...] | None
+            Union of generated schemas or None if all schemas are None.
+        """
+        # Generate schemas for each serializer in the Union
+        schemas = tuple(
+            serializer_type.generate_related_s()
+            for serializer_type in get_args(resolved_union)
+            if serializer_type.generate_related_s() is not None
+        )
+
+        if not schemas:
+            return None
+
+        # Optimize single-schema unions
+        if len(schemas) == 1:
+            return schemas[0]
+
+        # Create Union of schemas using indexing syntax for Python 3.10+ compatibility
+        return Union[schemas]
+
     @classmethod
     def _resolve_relation_schema(cls, field_name: str, rel_model: models.Model):
         """
@@ -136,23 +248,30 @@ class BaseSerializer:
 
         Returns
         -------
-        Schema | None
-            Generated schema or None if cannot be resolved.
+        Schema | Union[Schema, ...] | None
+            Generated schema, Union of schemas, or None if cannot be resolved.
         """
-        # Check if related model is a ModelSerializer with readable fields
+        # Auto-resolve ModelSerializer with readable fields
         if isinstance(rel_model, ModelSerializerMeta):
             if rel_model.get_fields("read") or rel_model.get_custom_fields("read"):
                 return rel_model.generate_related_s()
             return None
 
-        # Fall back to explicit serializer mapping
+        # Resolve from explicit serializer mapping
         rel_serializers = cls._get_relations_serializers() or {}
         serializer_ref = rel_serializers.get(field_name)
-        if serializer_ref:
-            serializer = cls._resolve_serializer_reference(serializer_ref)
-            return serializer.generate_related_s()
 
-        return None
+        if not serializer_ref:
+            return None
+
+        resolved = cls._resolve_serializer_reference(serializer_ref)
+
+        # Handle Union of serializers
+        if get_origin(resolved) is Union:
+            return cls._generate_union_schema(resolved)
+
+        # Handle single serializer
+        return resolved.generate_related_s()
 
     @classmethod
     def _is_special_field(