feature: saving data into model from ModelSchema (#24)

## Missing Tests
## Generic Type Support

```python
class UserSchema(ModelSchema[User]):
    class Config:
        model = User
        include = ["id", "email", "profile"]
```

Inference type of Django model is supported in the schema class. This
allows for better IDE support and type checking. The `ModelSchema` class
can be used with any Django model, and the type of the model can be
specified as a generic type parameter.

inference in save method:

```python
from typing import TypeVar

from djantic import ModelSchema
from myapp.models import User


class UserSchema(ModelSchema[User]):

    class Config:
        model = User
        include = ("username", "email", "first_name", "last_name", "is_staff")


serialized_user = UserSchema(
    username="myusername",
    email="my@email.com",
    first_name="My First Name",
    last_name="My Last Name",
    is_staff=True,
)

new_user = serialized_user.save()
```

is optional, but it is recommended to use the `ModelSchema` class with
the Django model type as a generic type parameter. This allows for
better IDE support and type checking.

Also with generic type support, now it's not necessary to define `model`
in the `Config` class. The `ModelSchema` class will automatically infer
the model type from the generic type parameter. This allows to get model
type from the schema class itself.

```python

class UserSchema(ModelSchema[User]):

    class Config:
        include = ("username", "email", "first_name", "last_name", "is_staff")


serialized_user = UserSchema(
    username="myusername",
    email="my@email.com",
    first_name="My First Name",
    last_name="My Last Name",
    is_staff=True,
)

new_user = serialized_user.save()
```

Author: Izcarmt95

djantic/main.py

@@ -3,7 +3,7 @@
 from enum import Enum
 from functools import reduce
 from itertools import chain
-from typing import Any, Dict, List, Optional, Union, no_type_check
+from typing import Any, Dict, List, Optional, TypeVar, Union, no_type_check
 
 from django.core.serializers.json import DjangoJSONEncoder
 from django.db.models import Manager, Model
@@ -21,10 +21,16 @@
 else:
     from typing import Union as UnionType
 
+
+from django.db.models import Model as DjangoModel
+
 from .fields import ModelSchemaField
+from .mixin import ModelSchemaMixin
 
 _is_base_model_class_defined = False
 
+_M = TypeVar("_M", bound=DjangoModel)
+
 
 class ModelSchemaJSONEncoder(DjangoJSONEncoder):
     @no_type_check
@@ -48,14 +54,32 @@ class ModelSchemaMetaclass(ModelMetaclass):
     @no_type_check
     def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs):
         cls = super().__new__(mcs, name, bases, namespace, **kwargs)
+
+        config = namespace.get("model_config", {})
+
         for base in reversed(bases):
             if (
                 _is_base_model_class_defined
+                and not (config is None or config == {})
                 and issubclass(base, ModelSchema)
-                and base == ModelSchema
+                and
+                ## Start to ensure generic origin is ModelSchema
+                # When schema is inherited from another class with generic
+                # origin, we need to check if the base class is ModelSchema
+                (
+                    (
+                        hasattr(base, "__pydantic_generic_metadata__")
+                        and (
+                            issubclass(
+                                base.__pydantic_generic_metadata__.get("origin"),
+                                ModelSchema,
+                            )
+                        )
+                    )
+                    or base == ModelSchema
+                )
             ):
-
-                config = namespace["model_config"]
+                ## Finish to ensure generic origin is ModelSchema
                 include = config.get("include", None)
                 exclude = config.get("exclude", None)
 
@@ -69,12 +93,33 @@ def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs):
                 annotations = namespace.get("__annotations__", {})
 
                 try:
+                    ## Get from generic metadata if available
+                    #
+                    if "model" not in config:
+                        if hasattr(
+                            base, "__pydantic_generic_metadata__"
+                        ) and base.__pydantic_generic_metadata__.get("args"):
+                            config["model"] = base.__pydantic_generic_metadata__.get(
+                                "args"
+                            )[0]
+
                     fields = config["model"]._meta.get_fields()
+
                 except (AttributeError, KeyError) as exc:
                     raise PydanticUserError(
-                        f'{exc} (Is `model_config["model"]` a valid Django model class?)',
+                        (
+                            f'{exc} (Is model_config["model"] a valid Django model class?) '
+                            '\nPlease set the model_config["model"] or a generic type with a '
+                            "Django model class as the first argument. \n\n"
+                            "Example: \n\n"
+                            "- class MyModelSchema(ModelSchema):\n"
+                            '\n      model_config = {"model": MyModel}\n\n'
+                            "or\n\n"
+                            "- class MyModelSchema(ModelSchema[MyModel]):\n"
+                            "    ...\n"
+                        ),
                         code="class-not-valid",
-                    )
+                    ) from None
 
                 if include == "__annotations__":
                     include = list(annotations.keys())
@@ -103,7 +148,6 @@ def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs):
                     python_type = None
                     pydantic_field = None
                     if field_name in annotations and field_name in namespace:
-
                         python_type = annotations.pop(field_name)
                         pydantic_field = namespace[field_name]
                         if (
@@ -135,6 +179,7 @@ def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs):
                     __doc__=cls.__doc__,
                     **field_values,
                 )
+
                 return model_schema
 
         return cls
@@ -143,10 +188,10 @@ def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs):
 def _is_optional_field(annotation) -> bool:
     args = get_args(annotation)
     return (
-            (get_origin(annotation) is Union or get_origin(annotation) is UnionType)
-            and type(None) in args
-            and len(args) == 2
-            and any(inspect.isclass(arg) and issubclass(arg, ModelSchema) for arg in args)
+        (get_origin(annotation) is Union or get_origin(annotation) is UnionType)
+        and type(None) in args
+        and len(args) == 2
+        and any(inspect.isclass(arg) and issubclass(arg, ModelSchema) for arg in args)
     )
 
 
@@ -157,7 +202,7 @@ def __init__(self, obj: Any, schema_class):
 
     def get(self, key: Any, default: Any = None) -> Any:
         if "__" in key:
-            # Allow double underscores aliases: `first_name: str = Field(alias="user__first_name")`
+            # Allow double underscores aliases: first_name: str = Field(alias="user__first_name")
             keys_map = key.split("__")
             attr = reduce(lambda a, b: getattr(a, b, default), keys_map, self._obj)
         else:
@@ -221,7 +266,9 @@ def dict(self) -> dict:
                     non_none_type_annotation = next(
                         arg for arg in get_args(annotation) if arg is not type(None)
                     )
-                    data[key] = self._get_annotation_objects(value, non_none_type_annotation)
+                    data[key] = self._get_annotation_objects(
+                        value, non_none_type_annotation
+                    )
 
             elif inspect.isclass(annotation) and issubclass(annotation, ModelSchema):
                 data[key] = self._get_annotation_objects(self.get(key), annotation)
@@ -231,8 +278,7 @@ def dict(self) -> dict:
         return data
 
 
-class ModelSchema(BaseModel, metaclass=ModelSchemaMetaclass):
-
+class ModelSchema(BaseModel, ModelSchemaMixin[_M], metaclass=ModelSchemaMetaclass):
     def __eq__(self, other: Any) -> bool:
         result = super().__eq__(other)
         if isinstance(result, bool):

djantic/mixin.py

@@ -0,0 +1,71 @@
+from typing import Any, Generic, Optional, TypeVar, Union
+
+from django.db.models import Model as DjangoModel
+
+_M = TypeVar("_M", bound=DjangoModel)
+
+
+class ModelSchemaMixin(Generic[_M]):
+    def create(self, *args: Any, **kwargs: Any) -> _M:
+        ModelDjangoClass: type[_M] = self.model_config["model"]
+
+        record: _M = ModelDjangoClass._default_manager.create(**self.model_dump())
+
+        return record
+
+    def update(
+        self, instance: _M, partial: Optional[bool] = None, *args: Any, **kwargs: Any
+    ) -> _M:
+        if not isinstance(instance, self.model_config["model"]):
+            raise TypeError(
+                "instance is not of the type {0}".format(self.model_config["model"])  # noqa
+            )
+
+        data = self.model_dump() if not partial else self.model_dump(exclude_unset=True)
+
+        if instance:
+            # Update the existing instance with the new data
+            for key, value in data.items():
+                if hasattr(instance, key):
+                    setattr(instance, key, value)
+                else:
+                    raise ValueError(f"Field {key} does not exist on the model.")
+            instance.save(*args, **kwargs)
+
+            return instance
+
+    def save(
+        self,
+        instance: Optional[_M] = None,
+        partial: Union[bool, None] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> _M:
+        """Save the model instance to the database.
+
+        This method saves the current model data to the database. If an instance is
+        provided, it updates the existing instance with the data from the current object.
+        If no instance is provided, it creates a new instance in the database.
+
+        Args:
+            instance: An optional model instance to update. If provided, the instance will be
+                updated with the current model data. If None, a new instance will be created.
+            partial: If True, only fields that have been explicitly set will be updated.
+                If Unset, all fields will be updated/saved.
+            *args: Additional positional arguments to pass to the model's save method.
+            **kwargs: Additional keyword arguments to pass to the model's save method.
+
+        Returns:
+            The saved model instance.
+
+        Raises:
+            ValueError: If a field in the model data does not exist on the provided instance.
+        """
+
+        if instance:
+            record = self.update(instance, partial, *args, *kwargs)
+            assert record is not None, "`update()` did not return an object instance."
+        else:
+            record = self.create(*args, **kwargs)
+            assert record is not None, "`create()` did not return an object instance."
+        return record

docs/usage.md

@@ -456,3 +456,65 @@ Output:
   "updated_at": "2021-04-04T08:47:39.567455+00:00"
 }
 ```
+## Generic Type Support
+
+```python
+class UserSchema(ModelSchema[User]):
+    class Config:
+        model = User
+        include = ["id", "email", "profile"]
+```
+
+Inference type of Django model is supported in the schema class. This allows for better IDE support and type checking. The `ModelSchema` class can be used with any Django model, and the type of the model can be specified as a generic type parameter.
+
+inference in save method:
+
+```python
+from typing import TypeVar
+
+from djantic import ModelSchema
+from myapp.models import User
+
+
+class UserSchema(ModelSchema[User]):
+
+    class Config:
+        model = User
+        include = ("username", "email", "first_name", "last_name", "is_staff")
+
+
+serialized_user = UserSchema(
+    username="myusername",
+    email="my@email.com",
+    first_name="My First Name",
+    last_name="My Last Name",
+    is_staff=True,
+)
+
+new_user = serialized_user.save()
+```
+
+is optional, but it is recommended to use the `ModelSchema` class with the Django model type as a generic type parameter. This allows for better IDE support and type checking.
+
+Also with generic type support, now it's not necessary to define `model` in the `Config` class. The `ModelSchema` class will automatically infer the model type from the generic type parameter. This allows to get model type from the schema class itself.
+
+```python
+
+class UserSchema(ModelSchema[User]):
+
+    class Config:
+        include = ("username", "email", "first_name", "last_name", "is_staff")
+
+
+serialized_user = UserSchema(
+    username="myusername",
+    email="my@email.com",
+    first_name="My First Name",
+    last_name="My Last Name",
+    is_staff=True,
+)
+
+new_user = serialized_user.save()
+```
+
+IDE SUPPORT

tests/test_main.py

@@ -1,19 +1,21 @@
 import pytest
+from pydantic import ConfigDict
 from pydantic.errors import PydanticUserError
-from testapp.models import User
 
-from pydantic import ConfigDict
 from djantic import ModelSchema
+from testapp.models import User
 
 
 @pytest.mark.django_db
 def test_model_config_contains_valid_model():
-    error_msg = r"(Is `model_config\[\"model\"\]` a valid Django model class?)"
-    with pytest.raises(PydanticUserError, match=error_msg):
+    error_msg = "(Is model_config[\"model\"] a valid Django model class?)"  # fmt: skip
+    with pytest.raises(PydanticUserError) as exc_info:
 
         class InvalidModelErrorSchema2(ModelSchema):
             model_config = ConfigDict(model="Ok")
 
+    assert error_msg in str(exc_info.value)
+
 
 @pytest.mark.django_db
 def test_include_and_exclude_mutually_exclusive():