django-ninja-aio-crud 2.16.1__tar.gz → 2.17.0__tar.gz

{django_ninja_aio_crud-2.16.1 → django_ninja_aio_crud-2.17.0}/PKG-INFO

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

{django_ninja_aio_crud-2.16.1 → django_ninja_aio_crud-2.17.0}/docs/api/models/model_serializer.md

@@ -49,7 +49,7 @@ Describes how to build a create (input) schema for a model.
 
 | Attribute   | Type                     | Description                                                                                                                       |
 | ----------- | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
-| `fields`    | `list[str]`              | REQUIRED model field names for creation                                                                                           |
+| `fields`    | `list[str \| tuple]`     | REQUIRED model field names for creation. Can also include inline custom tuples (see below)                                        |
 | `optionals` | `list[tuple[str, type]]` | Optional model fields: `(field_name, python_type)`                                                                                |
 | `customs`   | `list[tuple]`            | Synthetic inputs. Tuple forms: `(name, type)` = required (no default); `(name, type, default)` = optional (literal or callable)   |
 | `excludes`  | `list[str]`              | Field names rejected on create                                                                                                    |
@@ -75,6 +75,23 @@ class User(ModelSerializer):
         excludes = ["id", "created_at"]
 ```
 
+**Inline Custom Fields:**
+
+You can also define custom fields directly in the `fields` list as tuples:
+
+```python
+class User(ModelSerializer):
+    class CreateSerializer:
+        fields = [
+            "username",
+            "email",
+            ("password_confirm", str),          # 2-tuple: required
+            ("send_welcome", bool, True),       # 3-tuple: optional with default
+        ]
+```
+
+This is equivalent to using the separate `customs` list but keeps field definitions together.
+
 **Resolution Order for `customs`:**
 
 1. Payload value (if provided)
@@ -100,12 +117,12 @@ Describes how to build a read (output) schema for a model.
 
 **Attributes**
 
-| Attribute        | Type            | Description |
-|------------------|-----------------|-------------|
-| `fields`         | `list[str]`     | **REQUIRED.** Model fields / related names explicitly included in the read (output) schema. |
-| `excludes`       | `list[str]`     | Fields / related names to always omit (takes precedence over `fields` and `optionals`). Use for sensitive or noisy data (e.g., passwords, internal flags). |
-| `customs`        | `list[tuple]`   | Computed / synthetic output values. Tuple formats:<br>• `(name, type)` = required resolvable attribute (object attribute or property). Serialization error if not resolvable.<br>• `(name, type, default)` = optional; default may be a callable (`lambda obj: ...`) or a literal value. |
-| `relations_as_id`| `list[str]`     | Relation fields to serialize as IDs instead of nested objects. Works with forward FK, forward O2O, reverse FK, reverse O2O, and M2M relations. |
+| Attribute        | Type                 | Description |
+|------------------|----------------------|-------------|
+| `fields`         | `list[str \| tuple]` | **REQUIRED.** Model fields / related names explicitly included in the read (output) schema. Can also include inline custom tuples. |
+| `excludes`       | `list[str]`          | Fields / related names to always omit (takes precedence over `fields` and `optionals`). Use for sensitive or noisy data (e.g., passwords, internal flags). |
+| `customs`        | `list[tuple]`        | Computed / synthetic output values. Tuple formats:<br>• `(name, type)` = required resolvable attribute (object attribute or property). Serialization error if not resolvable.<br>• `(name, type, default)` = optional; default may be a callable (`lambda obj: ...`) or a literal value. |
+| `relations_as_id`| `list[str]`          | Relation fields to serialize as IDs instead of nested objects. Works with forward FK, forward O2O, reverse FK, reverse O2O, and M2M relations. |
 
 **Example:**
 
@@ -163,7 +180,7 @@ This allows partial overrides: define only `DetailSerializer.fields` while inher
 
 | Attribute   | Type                     | Description                                                                   |
 | ----------- | ------------------------ | ----------------------------------------------------------------------------- |
-| `fields`    | `list[str]`              | Model fields to include in detail view (falls back to ReadSerializer.fields if empty) |
+| `fields`    | `list[str \| tuple]`     | Model fields to include in detail view. Can include inline custom tuples. Falls back to ReadSerializer.fields if empty |
 | `excludes`  | `list[str]`              | Fields to exclude from detail view (falls back to ReadSerializer.excludes if empty) |
 | `customs`   | `list[tuple]`            | Computed fields: `(name, type)` required; `(name, type, default)` optional (falls back to ReadSerializer.customs if empty) |
 | `optionals` | `list[tuple[str, type]]` | Optional output fields (falls back to ReadSerializer.optionals if empty) |
@@ -240,7 +257,7 @@ Describes how to build an update (partial/full) input schema.
 
 | Attribute   | Type                     | Description                                                                   |
 | ----------- | ------------------------ | ----------------------------------------------------------------------------- |
-| `fields`    | `list[str]`              | REQUIRED fields for update (rarely used)                                      |
+| `fields`    | `list[str \| tuple]`     | REQUIRED fields for update (rarely used). Can include inline custom tuples    |
 | `optionals` | `list[tuple[str, type]]` | Updatable optional fields (typical for PATCH)                                 |
 | `customs`   | `list[tuple]`            | Instruction fields: `(name, type)` required; `(name, type, default)` optional |
 | `excludes`  | `list[str]`              | Immutable fields that cannot be updated                                       |

{django_ninja_aio_crud-2.16.1 → django_ninja_aio_crud-2.17.0}/docs/api/models/serializers.md

@@ -45,11 +45,48 @@ Define a Serializer subclass with a nested Meta:
 
 SchemaModelConfig fields:
 
-- **fields**: `list[str]` - Model field names to include
+- **fields**: `list[str | tuple]` - Model field names to include. Can also contain inline custom field tuples (see below)
 - **optionals**: `list[tuple[str, type]]` - Optional fields with their types
 - **exclude**: `list[str]` - Fields to exclude from schema
 - **customs**: `list[tuple[str, type, Any]]` - Custom/computed fields
 
+### Inline Custom Fields
+
+You can define custom fields directly in the `fields` list as tuples, providing a more concise syntax:
+
+```python
+class ArticleSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Article
+        schema_out = serializers.SchemaModelConfig(
+            # Mix regular fields with inline custom tuples
+            fields=[
+                "id",
+                "title",
+                ("word_count", int, 0),           # 3-tuple: (name, type, default)
+                ("is_featured", bool),             # 2-tuple: (name, type) - required
+            ]
+        )
+```
+
+**Tuple formats:**
+
+- **2-tuple**: `(name, type)` - Required field (equivalent to default `...`)
+- **3-tuple**: `(name, type, default)` - Optional field with default value
+
+This is equivalent to using the separate `customs` list but keeps field definitions together:
+
+```python
+# These two are equivalent:
+
+# Using inline customs
+fields=["id", "title", ("extra", str, "default")]
+
+# Using separate customs list
+fields=["id", "title"]
+customs=[("extra", str, "default")]
+```
+
 ### Schema Generation
 
 Generate schemas explicitly using these methods:

{django_ninja_aio_crud-2.16.1 → django_ninja_aio_crud-2.17.0}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-2.16.1 → django_ninja_aio_crud-2.17.0}/ninja_aio/models/serializers.py

@@ -305,7 +305,9 @@ class BaseSerializer:
         """
         # Auto-resolve ModelSerializer with readable fields
         if isinstance(rel_model, ModelSerializerMeta):
-            has_readable_fields = rel_model.get_fields("read") or rel_model.get_custom_fields("read")
+            has_readable_fields = rel_model.get_fields(
+                "read"
+            ) or rel_model.get_custom_fields("read")
             return rel_model.generate_related_s() if has_readable_fields else None
 
         # Resolve from explicit serializer mapping
@@ -341,7 +343,7 @@ class BaseSerializer:
         - (name, py_type) -> default Ellipsis (required)
         """
         raw_customs = cls._get_fields(s_type, "customs") or []
-        normalized: list[tuple[str, type, Any]] = []
+        normalized: list[tuple[str, Any, Any]] = []
         for spec in raw_customs:
             if not isinstance(spec, tuple):
                 raise ValueError(f"Custom field spec must be a tuple, got {type(spec)}")
@@ -373,8 +375,39 @@ class BaseSerializer:
 
     @classmethod
     def get_fields(cls, s_type: S_TYPES):
-        """Return explicit declared fields for the serializer type."""
-        return cls._get_fields(s_type, "fields")
+        """Return explicit declared field names for the serializer type (excludes inline customs)."""
+        fields = cls._get_fields(s_type, "fields")
+        # Filter out inline custom field tuples, return only string field names
+        return [f for f in fields if isinstance(f, str)]
+
+    @classmethod
+    def get_inline_customs(cls, s_type: S_TYPES) -> list[tuple[str, Any, Any]]:
+        """
+        Return inline custom field tuples declared directly in the fields list.
+
+        These are tuples in the format (name, type, default) or (name, type) mixed
+        with regular string field names in the fields list.
+
+        Returns
+        -------
+        list[tuple[str, Any, Any]]
+            Normalized list of (name, type, default) tuples.
+        """
+        fields = cls._get_fields(s_type, "fields")
+        inline_customs: list[tuple[str, Any, Any]] = []
+        for spec in fields:
+            if isinstance(spec, tuple):
+                match len(spec):
+                    case 3:
+                        inline_customs.append(spec)
+                    case 2:
+                        name, py_type = spec
+                        inline_customs.append((name, py_type, ...))
+                    case _:
+                        raise ValueError(
+                            f"Inline custom field tuple must have length 2 or 3 (name, type[, default]); got {len(spec)}"
+                        )
+        return inline_customs
 
     @classmethod
     def is_custom(cls, field: str) -> bool:
@@ -430,10 +463,15 @@ class BaseSerializer:
         # Handle relations_as_id for reverse relations
         if field_name in relations_as_id:
             from ninja_aio.models.utils import ModelUtil
+
             pk_field_type = ModelUtil(rel_model).pk_field_type
             if many:
                 # For many relations, use PkFromModel to extract PKs from model instances
-                return (field_name, list[PkFromModel[pk_field_type]], Field(default_factory=list))
+                return (
+                    field_name,
+                    list[PkFromModel[pk_field_type]],
+                    Field(default_factory=list),
+                )
             else:
                 # For single reverse relations (ReverseOneToOne), extract pk
                 return (field_name, PkFromModel[pk_field_type] | None, None)
@@ -472,6 +510,7 @@ class BaseSerializer:
         # Handle relations_as_id: serialize as the raw FK ID
         if field_name in relations_as_id:
             from ninja_aio.models.utils import ModelUtil
+
             pk_field_type = ModelUtil(rel_model).pk_field_type
             # Use PkFromModel to extract pk from the related instance during serialization
             return (field_name, PkFromModel[pk_field_type] | None, None)
@@ -614,11 +653,18 @@ class BaseSerializer:
             if forward:
                 forward_rels.append(forward)
 
+        # Combine explicit customs, inline customs, and forward relation schemas
+        all_customs = (
+            cls.get_custom_fields(fields_type)
+            + cls.get_inline_customs(fields_type)
+            + forward_rels
+        )
+
         return (
             fields,
             reverse_rels,
             cls.get_excluded_fields(fields_type),
-            cls.get_custom_fields(fields_type) + forward_rels,
+            all_customs,
             cls.get_optional_fields(fields_type),
         )
 
@@ -666,7 +712,11 @@ class BaseSerializer:
         s_type = "create" if schema_type == "In" else "update"
         fields = cls.get_fields(s_type)
         optionals = cls.get_optional_fields(s_type)
-        customs = cls.get_custom_fields(s_type) + optionals
+        customs = (
+            cls.get_custom_fields(s_type)
+            + optionals
+            + cls.get_inline_customs(s_type)
+        )
         excludes = cls.get_excluded_fields(s_type)
 
         # If no explicit fields and no excludes specified
@@ -698,17 +748,19 @@ class BaseSerializer:
     def get_related_schema_data(cls):
         """
         Build field/custom lists for 'Related' schema, flattening non-relational fields.
+
+        Custom fields (both explicit and inline) are always included since they
+        are computed/synthetic and not relation descriptors.
         """
         fields = cls.get_fields("read")
-        custom_f = {
-            name: (value, default)
-            for name, value, default in cls.get_custom_fields("read")
-        }
-        _related_fields = []
+        customs = cls.get_custom_fields("read") + cls.get_inline_customs("read")
         model = cls._get_model()
-        for f in fields + list(custom_f.keys()):
-            field_obj = getattr(model, f)
-            if not isinstance(
+
+        # Filter out relation fields from model fields
+        non_relation_fields = []
+        for f in fields:
+            field_obj = getattr(model, f, None)
+            if field_obj is None or not isinstance(
                 field_obj,
                 (
                     ManyToManyDescriptor,
@@ -718,14 +770,13 @@ class BaseSerializer:
                     ForwardOneToOneDescriptor,
                 ),
             ):
-                _related_fields.append(f)
-        if not _related_fields:
+                non_relation_fields.append(f)
+
+        # No fields or customs means nothing to include
+        if not non_relation_fields and not customs:
             return None, None
-        custom_related_fields = [
-            (f, *custom_f[f]) for f in _related_fields if f in custom_f
-        ]
-        related_fields = [f for f in _related_fields if f not in custom_f]
-        return related_fields, custom_related_fields
+
+        return non_relation_fields, customs
 
     @classmethod
     def generate_read_s(cls, depth: int = 1) -> Schema:
@@ -810,9 +861,9 @@ class ModelSerializer(models.Model, BaseSerializer, metaclass=ModelSerializerMet
             Disallowed model fields on create (e.g., id, timestamps).
         """
 
-        fields: list[str] = []
-        customs: list[tuple[str, type, Any]] = []
-        optionals: list[tuple[str, type]] = []
+        fields: list[str | tuple[str, Any, Any]] = []
+        customs: list[tuple[str, Any, Any]] = []
+        optionals: list[tuple[str, Any]] = []
         excludes: list[str] = []
 
     class ReadSerializer:
@@ -832,9 +883,9 @@ class ModelSerializer(models.Model, BaseSerializer, metaclass=ModelSerializerMet
             Relation fields to serialize as IDs instead of nested objects.
         """
 
-        fields: list[str] = []
-        customs: list[tuple[str, type, Any]] = []
-        optionals: list[tuple[str, type]] = []
+        fields: list[str | tuple[str, Any, Any]] = []
+        customs: list[tuple[str, Any, Any]] = []
+        optionals: list[tuple[str, Any]] = []
         excludes: list[str] = []
         relations_as_id: list[str] = []
 
@@ -853,9 +904,9 @@ class ModelSerializer(models.Model, BaseSerializer, metaclass=ModelSerializerMet
             Optional output fields.
         """
 
-        fields: list[str] = []
-        customs: list[tuple[str, type, Any]] = []
-        optionals: list[tuple[str, type]] = []
+        fields: list[str | tuple[str, Any, Any]] = []
+        customs: list[tuple[str, Any, Any]] = []
+        optionals: list[tuple[str, Any]] = []
         excludes: list[str] = []
 
     class UpdateSerializer:
@@ -873,9 +924,9 @@ class ModelSerializer(models.Model, BaseSerializer, metaclass=ModelSerializerMet
             Immutable / blocked fields.
         """
 
-        fields: list[str] = []
-        customs: list[tuple[str, type, Any]] = []
-        optionals: list[tuple[str, type]] = []
+        fields: list[str | tuple[str, Any, Any]] = []
+        customs: list[tuple[str, Any, Any]] = []
+        optionals: list[tuple[str, Any]] = []
         excludes: list[str] = []
 
     # Serializer type to configuration class mapping
@@ -1044,20 +1095,22 @@ class SchemaModelConfig(Schema):
     Configuration container for declarative schema definitions.
     Attributes
     ----------
-    fields : Optional[List[str]]
-        Explicit model fields to include.
-    optionals : Optional[List[tuple[str, type]]]
-        Optional model fields.
+    fields : Optional[List[str | tuple]]
+        Explicit model fields to include. Can also contain inline custom field tuples:
+        - 2-tuple: (name, type) - required field
+        - 3-tuple: (name, type, default) - optional field with default
+    optionals : Optional[List[tuple[str, Any]]]
+        Optional model fields. Type can be any valid type annotation including Union.
     exclude : Optional[List[str]]
         Model fields to exclude.
-    customs : Optional[List[tuple[str, type, Any]]]
-        Custom / synthetic fields.
+    customs : Optional[List[tuple[str, Any, Any]]]
+        Custom / synthetic fields. Type can be any valid type annotation including Union.
     """
 
-    fields: Optional[List[str]] = None
-    optionals: Optional[List[tuple[str, type]]] = None
+    fields: Optional[List[str | tuple[str, Any, Any] | tuple[str, Any]]] = None
+    optionals: Optional[List[tuple[str, Any]]] = None
     exclude: Optional[List[str]] = None
-    customs: Optional[List[tuple[str, type, Any]]] = None
+    customs: Optional[List[tuple[str, Any, Any]]] = None
 
 
 class Serializer(BaseSerializer, metaclass=SerializerMeta):

{django_ninja_aio_crud-2.16.1 → django_ninja_aio_crud-2.17.0}/tests/test_app/models.py

@@ -227,6 +227,16 @@ class TestModelSerializerWithBothSerializers(BaseTestModelSerializer):
         # No customs defined - should NOT inherit from read
 
 
+class TestModelSerializerInlineCustoms(BaseTestModelSerializer):
+    """Model with inline custom fields defined directly in the fields list."""
+
+    class ReadSerializer:
+        fields = ["id", "name", ("inline_computed", str, "computed_value")]
+
+    class CreateSerializer:
+        fields = ["name", ("extra_create_input", str, "")]
+
+
 # ==========================================================
 #              RELATIONS AS ID TEST MODELS
 # ==========================================================

{django_ninja_aio_crud-2.16.1 → django_ninja_aio_crud-2.17.0}/tests/test_serializers.py

@@ -1506,3 +1506,232 @@ class RelationsAsIdStringPKIntegrationTestCase(TestCase):
         self.assertIsInstance(result.articles_str[0], str)
         self.assertIn(self.article.pk, result.articles_str)
         self.assertEqual(result.articles_str[0], "article-001")
+
+
+@tag("serializers", "inline_customs")
+class InlineCustomsSerializerTestCase(TestCase):
+    """Test cases for inline custom fields defined directly in the fields list."""
+
+    def setUp(self):
+        warnings.simplefilter("ignore", UserWarning)
+
+    def test_serializer_read_schema_with_inline_customs_3_tuple(self):
+        """Test that inline customs (3-tuple) in schema_out fields work correctly."""
+
+        class InlineCustomsReadSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", ("custom_read", str, "default_value")]
+                )
+
+        schema = InlineCustomsReadSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("id", schema.model_fields)
+        self.assertIn("name", schema.model_fields)
+        self.assertIn("custom_read", schema.model_fields)
+
+    def test_serializer_read_schema_with_inline_customs_2_tuple(self):
+        """Test that inline customs (2-tuple, required) in schema_out fields work correctly."""
+
+        class InlineCustoms2TupleSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", ("required_custom", int)]
+                )
+
+        schema = InlineCustoms2TupleSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("id", schema.model_fields)
+        self.assertIn("name", schema.model_fields)
+        self.assertIn("required_custom", schema.model_fields)
+
+    def test_serializer_create_schema_with_inline_customs(self):
+        """Test that inline customs in schema_in fields work correctly."""
+
+        class InlineCustomsCreateSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_in = serializers.SchemaModelConfig(
+                    fields=["name", ("extra_input", str, "")]
+                )
+                schema_out = serializers.SchemaModelConfig(fields=["id", "name"])
+
+        schema = InlineCustomsCreateSerializer.generate_create_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("name", schema.model_fields)
+        self.assertIn("extra_input", schema.model_fields)
+        # Should NOT have model fields that weren't explicitly listed
+        self.assertNotIn("description", schema.model_fields)
+
+    def test_serializer_update_schema_with_inline_customs(self):
+        """Test that inline customs in schema_update fields work correctly."""
+
+        class InlineCustomsUpdateSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_update = serializers.SchemaModelConfig(
+                    fields=[("update_flag", bool, False)],
+                    optionals=[("name", str)],
+                )
+                schema_out = serializers.SchemaModelConfig(fields=["id", "name"])
+
+        schema = InlineCustomsUpdateSerializer.generate_update_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("update_flag", schema.model_fields)
+        self.assertIn("name", schema.model_fields)
+
+    def test_serializer_inline_customs_combined_with_explicit_customs(self):
+        """Test that inline customs and explicit customs can coexist."""
+
+        class CombinedCustomsSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", ("inline_custom", str, "inline")],
+                    customs=[("explicit_custom", int, 0)],
+                )
+
+        schema = CombinedCustomsSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("id", schema.model_fields)
+        self.assertIn("name", schema.model_fields)
+        self.assertIn("inline_custom", schema.model_fields)
+        self.assertIn("explicit_custom", schema.model_fields)
+
+    def test_serializer_get_fields_excludes_inline_customs(self):
+        """Test that get_fields() returns only string field names."""
+
+        class FieldsOnlySerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", ("custom", str, "val")]
+                )
+
+        fields = FieldsOnlySerializer.get_fields("read")
+        self.assertEqual(fields, ["id", "name"])
+        # Should not include tuples
+        self.assertNotIn(("custom", str, "val"), fields)
+
+    def test_serializer_get_inline_customs_returns_only_tuples(self):
+        """Test that get_inline_customs() returns only inline custom tuples."""
+
+        class InlineCustomsOnlySerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", ("custom1", str, "val"), ("custom2", int)]
+                )
+
+        inline_customs = InlineCustomsOnlySerializer.get_inline_customs("read")
+        self.assertEqual(len(inline_customs), 2)
+        # First is a 3-tuple
+        self.assertEqual(inline_customs[0], ("custom1", str, "val"))
+        # Second is normalized from 2-tuple to 3-tuple with Ellipsis
+        self.assertEqual(inline_customs[1], ("custom2", int, ...))
+
+    def test_serializer_detail_schema_with_inline_customs(self):
+        """Test that inline customs work in schema_detail."""
+
+        class DetailInlineCustomsSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_out = serializers.SchemaModelConfig(fields=["id", "name"])
+                schema_detail = serializers.SchemaModelConfig(
+                    fields=["id", "name", "description", ("detail_extra", str, "extra")]
+                )
+
+        read_schema = DetailInlineCustomsSerializer.generate_read_s()
+        detail_schema = DetailInlineCustomsSerializer.generate_detail_s()
+
+        # Read schema should NOT have detail_extra
+        self.assertNotIn("detail_extra", read_schema.model_fields)
+
+        # Detail schema should have all fields including inline custom
+        self.assertIn("id", detail_schema.model_fields)
+        self.assertIn("name", detail_schema.model_fields)
+        self.assertIn("description", detail_schema.model_fields)
+        self.assertIn("detail_extra", detail_schema.model_fields)
+
+    def test_serializer_related_schema_with_inline_customs(self):
+        """Test that inline customs are included in related schema for non-relation fields."""
+
+        class RelatedInlineCustomsSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", ("computed", str, "computed_value")]
+                )
+
+        related_schema = RelatedInlineCustomsSerializer.generate_related_s()
+        self.assertIsNotNone(related_schema)
+        self.assertIn("id", related_schema.model_fields)
+        self.assertIn("name", related_schema.model_fields)
+        self.assertIn("computed", related_schema.model_fields)
+
+    def test_inline_customs_only_schema(self):
+        """Test schema with only inline customs (no regular fields)."""
+
+        class OnlyInlineCustomsSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelForeignKey
+                schema_in = serializers.SchemaModelConfig(
+                    fields=[("custom_only", str, ...)]
+                )
+                schema_out = serializers.SchemaModelConfig(fields=["id"])
+
+        schema = OnlyInlineCustomsSerializer.generate_create_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("custom_only", schema.model_fields)
+        # Should NOT have any model fields auto-included
+        self.assertNotIn("name", schema.model_fields)
+        self.assertNotIn("description", schema.model_fields)
+
+
+@tag("serializers", "inline_customs", "model_serializer")
+class InlineCustomsModelSerializerTestCase(TestCase):
+    """Test cases for inline custom fields with ModelSerializer."""
+
+    def setUp(self):
+        warnings.simplefilter("ignore", UserWarning)
+
+    def test_model_serializer_read_schema_with_inline_customs(self):
+        """Test ModelSerializer ReadSerializer with inline customs."""
+        from tests.test_app.models import TestModelSerializerInlineCustoms
+
+        schema = TestModelSerializerInlineCustoms.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("id", schema.model_fields)
+        self.assertIn("name", schema.model_fields)
+        self.assertIn("inline_computed", schema.model_fields)
+
+    def test_model_serializer_create_schema_with_inline_customs(self):
+        """Test ModelSerializer CreateSerializer with inline customs."""
+        from tests.test_app.models import TestModelSerializerInlineCustoms
+
+        schema = TestModelSerializerInlineCustoms.generate_create_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("name", schema.model_fields)
+        self.assertIn("extra_create_input", schema.model_fields)
+
+    def test_model_serializer_get_inline_customs(self):
+        """Test get_inline_customs() works for ModelSerializer."""
+        from tests.test_app.models import TestModelSerializerInlineCustoms
+
+        inline_customs = TestModelSerializerInlineCustoms.get_inline_customs("read")
+        self.assertEqual(len(inline_customs), 1)
+        self.assertEqual(inline_customs[0][0], "inline_computed")
+
+    def test_model_serializer_get_fields_excludes_inline_customs(self):
+        """Test get_fields() excludes inline customs for ModelSerializer."""
+        from tests.test_app.models import TestModelSerializerInlineCustoms
+
+        fields = TestModelSerializerInlineCustoms.get_fields("read")
+        self.assertIn("id", fields)
+        self.assertIn("name", fields)
+        self.assertNotIn("inline_computed", fields)
+        # Should not contain tuples
+        for f in fields:
+            self.assertIsInstance(f, str)