Merge pull request #43 from eadwinCode/generic_updates

feat: support for generic class

Author: eadwinCode

README.md

@@ -16,7 +16,7 @@ Starting version `0.13.4`, Ninja schema will support both v1 and v2 of pydantic
 Python >= 3.8
 django >= 3
 pydantic >= 1.6
-
+ 
 **Key features:**
 - **Custom Field Support**: Ninja Schema converts django model to native pydantic types which gives you quick field validation out of the box. eg Enums, email, IPAddress, URLs, JSON, etc
 - **Field Validator**: Fields can be validated with **model_validator** just like pydantic **[validator](https://pydantic-docs.helpmanual.io/usage/validators/)** or **[root_validator](https://pydantic-docs.helpmanual.io/usage/validators/)**. 
@@ -63,7 +63,6 @@ class CreateUserSchema(ModelSchema):
 ##  `from_orm(cls, obj: Any)`
 You can generate a schema instance from your django model instance
 ```Python
-from typings import Optional
 from django.contrib.auth import get_user_model
 from ninja_schema import ModelSchema, model_validator
 
@@ -90,15 +89,14 @@ print(schema.json(indent=2)
 }
 ```
 
-## `apply(self, model_instance, **kwargs)`
+## `apply_to_model(self, model_instance, **kwargs)`
 You can transfer data from your ModelSchema to Django Model instance using the `apply` function.
-The `apply` function uses Pydantic model `.dict` function, `dict` function filtering that can be passed as `kwargs` to the `.apply` function.
+The `apply_to_model` function uses Pydantic model `.dict` function, `dict` function filtering that can be passed as `kwargs` to the `.apply` function.
 
 For more info, visit [Pydantic model export](https://pydantic-docs.helpmanual.io/usage/exporting_models/)
 ```Python
-from typings import Optional
 from django.contrib.auth import get_user_model
-from ninja_schema import ModelSchema, model_validator
+from ninja_schema import ModelSchema
 
 UserModel = get_user_model()
 new_user = UserModel.objects.create_user(username='eadwin', email='[email protected]', password='password')
@@ -111,7 +109,7 @@ class UpdateUserSchema(ModelSchema):
         optional = ['username']  # `username` is now optional
 
 schema = UpdateUserSchema(first_name='Emeka', last_name='Okoro')
-schema.apply(new_user, exclude_none=True)
+schema.apply_to_model(new_user, exclude_none=True)
 
 assert new_user.first_name == 'Emeka' # True
 assert new_user.username == 'eadwin' # True
@@ -269,4 +267,3 @@ print(UserSchema.schema())
     }
 }
 ```
-

ninja_schema/orm/model_schema.py

@@ -320,11 +320,12 @@ def __new__(
         name: str,
         bases: tuple,
         namespace: dict,
+        **kwargs: Any,
     ):
         if bases == (SchemaBaseModel,) or not namespace.get(
             "Config", namespace.get("model_config")
         ):
-            return super().__new__(mcs, name, bases, namespace)
+            return super().__new__(mcs, name, bases, namespace, **kwargs)
 
         config = namespace.get("Config")
         if not config:
@@ -407,16 +408,20 @@ def __new__(
 
                 field_values[field_name] = (python_type, pydantic_field)
             if IS_PYDANTIC_V1:
-                cls = super().__new__(mcs, name, bases, namespace)
+                cls = super().__new__(mcs, name, bases, namespace, **kwargs)
                 return update_class_missing_fields(
                     cls,
                     list(bases),
                     compute_field_annotations(namespace, **field_values),
                 )
             return super().__new__(
-                mcs, name, bases, compute_field_annotations(namespace, **field_values)
+                mcs,
+                name,
+                bases,
+                compute_field_annotations(namespace, **field_values),
+                **kwargs,
             )
-        return super().__new__(mcs, name, bases, namespace)
+        return super().__new__(mcs, name, bases, namespace, **kwargs)
 
 
 class SchemaBaseModel(SchemaMixins, BaseModel):

ninja_schema/orm/schema_registry.py

@@ -31,11 +31,11 @@ def register_model(self, model: Type[Model], schema: Type["ModelSchema"]) -> Non
         from ninja_schema.orm.model_schema import ModelSchema
 
         assert is_valid_class(schema) and issubclass(schema, (ModelSchema,)), (
-            "Only Schema can be" 'registered, received "{}"'.format(schema.__name__)
+            'Only Schema can beregistered, received "{}"'.format(schema.__name__)
+        )
+        assert is_valid_django_model(model), (
+            "Only Django Models are allowed. {}".format(model.__name__)
         )
-        assert is_valid_django_model(
-            model
-        ), "Only Django Models are allowed. {}".format(model.__name__)
         # TODO: register model as module_name.model_name
         self.register_schema(model, schema)
 

ninja_schema/orm/utils/converter.py

@@ -39,9 +39,9 @@
 
 def assert_valid_name(name: str) -> None:
     """Helper to assert that provided names are valid."""
-    assert COMPILED_NAME_PATTERN.match(
-        name
-    ), 'Names must match /{}/ but "{}" does not.'.format(NAME_PATTERN, name)
+    assert COMPILED_NAME_PATTERN.match(name), (
+        'Names must match /{}/ but "{}" does not.'.format(NAME_PATTERN, name)
+    )
 
 
 def convert_choice_name(name: str) -> str:

ninja_schema/py.typed

@@ -0,0 +1 @@
+

tests/test_v1_pydantic/test_custom_fields.py

@@ -33,7 +33,7 @@ class Config:
                     "title": "SemesterEnum",
                     "description": "An enumeration.",
                     "enum": ["1", "2", "3"],
-                    "type": "string"
+                    "type": "string",
                 }
             },
         }

tests/test_v2_pydantic/test_model_schema.py

@@ -1,13 +1,17 @@
 import json
+import typing as t
 
 import pydantic
 import pytest
+from django.db.models import Model as DjangoModel
 
 from ninja_schema import ModelSchema, SchemaFactory, model_validator
 from ninja_schema.errors import ConfigError
 from ninja_schema.pydanticutils import IS_PYDANTIC_V1
 from tests.models import Event
 
+T = t.TypeVar("T", bound=DjangoModel)
+
 
 class TestModelSchema:
     @pytest.mark.skipif(IS_PYDANTIC_V1, reason="requires pydantic == 2.1.x")
@@ -514,3 +518,38 @@ def validate_title(cls, value):
 
         event = EventWithNewModelConfig(start_date="2021-06-12", title="PyConf 2021")
         assert "value cleaned" in event.title
+
+    @pytest.mark.django_db
+    @pytest.mark.skipif(IS_PYDANTIC_V1, reason="requires pydantic == 2.1.x")
+    def test_schema_with_mixin_generic_class(self):
+        """
+        Test that a schema with a generic mixin class works correctly.
+        """
+
+        class GenericMixin(t.Generic[T]):
+            def save(self, instance: t.Optional[T] = None) -> T:
+                """
+                Save the model instance and return it.
+                """
+                if instance:
+                    self.apply_to_model(instance, **self.dict())
+                    instance.save()
+                    return instance
+
+                instance = self.Config.model(**self.dict())
+                instance.save()
+                return instance
+
+        class BaseModelSchema(ModelSchema, GenericMixin[T]): ...
+
+        class EventGenericSchema(BaseModelSchema[Event]):
+            class Config:
+                model = Event
+                include = ("title",)
+
+        event = EventGenericSchema(title="PyConf 2021")
+        assert event.title == "PyConf 2021"
+
+        instance_event = event.save()
+        assert isinstance(instance_event, Event)
+        assert instance_event.title == "PyConf 2021"