v0.1.1: Support of direct model annotations

Now, instead specifying explicit schema, one could write:
```
from django.db import Model
from django_pydantic_field import SchemaField

class MyModel(models.Model):
    field: list[int] = SchemaField()
```

The schema will be inferred at the model freezing step.
It's not possible to specify not-yet resolved forward reference at the moment.

Author: surenkov

Makefile

@@ -9,7 +9,7 @@ install:
 
 .PHONY: activate
 activate:
-	. .env/bin/activate
+	@ . .env/bin/activate
 
 
 .PHONY: build
@@ -24,6 +24,12 @@ test: activate
 test:
 	pytest $(A)
 
+.PHONY: lint
+lint: A=.
+lint: activate
+lint:
+	mypy $(A)
+
 
 .PHONY: upload
 upload: activate

README.md

@@ -27,10 +27,15 @@ class Bar(pydantic.BaseModel):
 
 
 class MyModel(models.Model):
-    foo_field: Foo = SchemaField(schema=Foo)
-    bar_list: list[Bar] = SchemaField(schema=list[Bar])
-    raw_date_map: dict[date, int] = SchemaField(schema=dict[date, int])
-    raw_uids: set[UUID] = SchemaField(schema=set[UUID])
+    # Infer schema from field annotation
+    foo_field: Foo = SchemaField()
+
+    # or pecify schema explicitly
+    bar_list: typing.Sequence[Bar] = SchemaField(schema=list[Bar])
+
+    # Pydantic exportable types are supported
+    raw_date_map: dict[int, date] = SchemaField()
+    raw_uids: set[UUID] = SchemaField()
 
 ...
 

django_pydantic_field/base.py

@@ -42,14 +42,14 @@ def default_error_handler(obj, err):
 
 
 class SchemaEncoder(DjangoJSONEncoder):
-    def __init__(self, *args, schema: "ModelType", export_cfg=None, **kwargs):
+    def __init__(self, *args, schema: "ModelType", export=None, **kwargs):
         self.schema = schema
-        self.export_cfg = export_cfg or {}
+        self.export_params = export or {}
         super().__init__(*args, **kwargs)
 
     def encode(self, obj):
         try:
-            data = self.schema(__root__=obj).json(**self.export_cfg)
+            data = self.schema(__root__=obj).json(**self.export_params)
         except pydantic.ValidationError:
             # This branch used for expressions like .filter(data__contains={}).
             # We don't want that {} to be parsed as a schema.

django_pydantic_field/fields.py

@@ -3,6 +3,7 @@
 
 from functools import partial
 
+from django.core.exceptions import FieldError
 from django.db.models.fields import NOT_PROVIDED
 from django.db.models.query_utils import DeferredAttribute
 from django.db.models import JSONField
@@ -12,7 +13,7 @@
 
 from . import base
 
-__all__ = "SchemaField",
+__all__ = ("SchemaField",)
 
 
 class SchemaDeferredAttribute(DeferredAttribute):
@@ -38,30 +39,35 @@ class PydanticSchemaField(base.SchemaWrapper["base.ST"], JSONField):
 
     def __init__(
         self,
-        schema: t.Union[t.Type["base.ST"], "GenericContainer"],
-        config: "base.ConfigType" = None,
         *args,
+        schema: t.Union[t.Type["base.ST"], "GenericContainer"] = None,
+        config: "base.ConfigType" = None,
         error_handler=base.default_error_handler,
         **kwargs
     ):
-        if isinstance(schema, GenericContainer):
-            schema = t.cast(t.Type["base.ST"], schema.reconstruct_type())
+        super().__init__(*args, **kwargs)
 
-        self.schema = schema
         self.config = config
-        self.export_cfg = self._extract_export_kwargs(kwargs, dict.pop)
-
-        field_schema = self._wrap_schema(schema, config)
-        decoder = partial(base.SchemaDecoder, schema=field_schema, error_handler=error_handler)
-        encoder = partial(base.SchemaEncoder, schema=field_schema, export_cfg=self.export_cfg)
-
-        kwargs.update(decoder=decoder, encoder=encoder)
-        super().__init__(*args, **kwargs)
+        self.export_params = self._extract_export_kwargs(kwargs, dict.pop)
+        self.error_handler = error_handler
+        self._init_schema(schema)
 
     def __copy__(self):
         _, _, args, kwargs = self.deconstruct()
         return type(self)(*args, **kwargs)
 
+    def contribute_to_class(self, cls, name, private_only=False):
+        if self.schema is None:
+            annotated_schema = t.get_type_hints(cls).get(name, None)
+            if annotated_schema is None:
+                raise FieldError(
+                    f"{cls._meta.label}.{name} needs to be either annotated "
+                    "or `schema=` field attribute should be explicitly passed"
+                )
+            self._init_schema(annotated_schema)
+
+        super().contribute_to_class(cls, name, private_only)
+
     def get_default(self):
         value = super().get_default()
         return self.to_python(value)
@@ -81,6 +87,19 @@ def to_python(self, value) -> "base.SchemaT":
         assert self.decoder is not None
         return self.decoder().decode(value)
 
+    def _init_schema(
+        self,
+        schema: t.Union[t.Type["base.ST"], "GenericContainer", None],
+    ):
+        if isinstance(schema, GenericContainer):
+            schema = t.cast(t.Type["base.ST"], schema.reconstruct_type())
+
+        self.schema = schema
+        if schema is not None:
+            serializer = self._wrap_schema(schema, self.config)
+            self.decoder = partial(base.SchemaDecoder, serializer, self.error_handler)  # type: ignore
+            self.encoder = partial(base.SchemaEncoder, schema=serializer, export=self.export_params)  # type: ignore
+
     def _deconstruct_default(self, kwargs):
         default = kwargs.get("default", NOT_PROVIDED)
 
@@ -99,17 +118,20 @@ def _deconstruct_schema(self, kwargs):
         kwargs.update(schema=schema)
 
     def _deconstruct_config(self, kwargs):
-        kwargs.update(self.export_cfg, config=self.config)
+        kwargs.update(self.export_params, config=self.config)
+
+        if self.error_handler is not base.default_error_handler:
+            kwargs.update(error_handler=self.error_handler)
 
 
 def SchemaField(
-    schema: t.Union[t.Type["base.ST"], "GenericContainer"],
-    config: "base.ConfigType" = None,
     *args,
+    schema: t.Type["base.ST"] = None,
+    config: "base.ConfigType" = None,
     error_handler=base.default_error_handler,
     **kwargs
 ) -> t.Any:
-    return PydanticSchemaField(schema, config, *args, error_handler=error_handler, **kwargs)
+    return PydanticSchemaField(*args, schema=schema, config=config, error_handler=error_handler, **kwargs)
 
 
 # Django Migration serializer helpers

django_pydantic_field/rest_framework.py

@@ -69,15 +69,15 @@ def __init__(
     ):
         self.schema = field_schema = self._wrap_schema(schema, config)
         self.decoder = base.SchemaDecoder[base.ST](field_schema, serializer_error_handler)
-        self.export_cfg = self._extract_export_kwargs(kwargs, dict.pop)
+        self.export_params = self._extract_export_kwargs(kwargs, dict.pop)
         super().__init__(**kwargs)
 
     def to_internal_value(self, data) -> t.Optional["base.ST"]:
         return self.decoder.decode(data)
 
     def to_representation(self, value):
         obj = self.schema.parse_obj(value)
-        raw_obj = obj.dict(**self.export_cfg)
+        raw_obj = obj.dict(**self.export_params)
         return raw_obj["__root__"]
 
 

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = django-pydantic-field
-version = 0.1.0
+version = 0.1.1
 url = https://github.com/surenkov/django-pydantic-field
 
 description = Django JSONField with Pydantic models as a Schema

tests/sample_app/migrations/0001_initial.py

@@ -21,7 +21,7 @@ class Migration(migrations.Migration):
                 ('meta_builtin_list', django_pydantic_field.fields.PydanticSchemaField(config=None, default=list, schema=django_pydantic_field.fields.GenericContainer(list, (tests.sample_app.models.BuildingMeta,)))),
                 ('meta_typing_list', django_pydantic_field.fields.PydanticSchemaField(config=None, default=list, schema=django_pydantic_field.fields.GenericContainer(list, (tests.sample_app.models.BuildingMeta,)))),
                 ('meta_untyped_list', django_pydantic_field.fields.PydanticSchemaField(config=None, default=list, schema=list)),
-                ('meta_untyped_builtim_list', django_pydantic_field.fields.PydanticSchemaField(config=None, default=list, schema=list)),
+                ('meta_untyped_builtin_list', django_pydantic_field.fields.PydanticSchemaField(config=None, default=list, schema=list)),
             ],
         ),
     ]

tests/sample_app/models.py

@@ -19,7 +19,7 @@ class BuildingMeta(pydantic.BaseModel):
 default_meta = BuildingMeta(type=BuildingTypes.FRAME)
 
 class Building(models.Model):
-    meta: BuildingMeta = SchemaField(schema=BuildingMeta, default=default_meta)
+    meta: BuildingMeta = SchemaField(default=default_meta)
     meta_builtin_list: list[BuildingMeta] = SchemaField(schema=list[BuildingMeta], default=list)
     meta_typing_list: t.List[BuildingMeta] = SchemaField(schema=t.List[BuildingMeta], default=list)
     meta_untyped_list: list = SchemaField(schema=t.List, default=list)

tests/test_base_marshalling.py

@@ -28,7 +28,7 @@ def test_schema_encoder_with_raw_dict():
 
 
 def test_schema_encoder_with_custom_config():
-    encoder = base.SchemaEncoder(schema=SampleSchema, export_cfg={"exclude": {"__root__": {"stub_list"}}})
+    encoder = base.SchemaEncoder(schema=SampleSchema, export={"exclude": {"__root__": {"stub_list"}}})
     existing_raw = {"stub_str": "abc", "stub_list": [date(2022, 7, 1)]}
     expected_encoded = '{"stub_str": "abc", "stub_int": 1}'
     assert encoder.encode(existing_raw) == expected_encoded

tests/test_django_model_field.py

@@ -10,11 +10,11 @@
 
 from django.db import models
 from django.db.migrations.writer import MigrationWriter
+from django.core.exceptions import FieldError
 
 from .conftest import InnerSchema, SampleDataclass
 
 
-
 def test_sample_field():
     sample_field = fields.PydanticSchemaField(schema=InnerSchema)
     existing_instance = InnerSchema(stub_str="abc", stub_list=[date(2022, 7, 1)])
@@ -35,12 +35,21 @@ def test_sample_field_with_raw_data():
 
 def test_simple_model_field():
     class SampleModel(models.Model):
-        sample_field = fields.PydanticSchemaField(schema=InnerSchema)
-        sample_list = fields.PydanticSchemaField(schema=t.List[InnerSchema])
+        sample_field: InnerSchema = fields.SchemaField()
+        sample_list: t.List[InnerSchema] = fields.SchemaField()
+        sample_seq: t.Sequence[InnerSchema] = fields.SchemaField(schema=t.List[InnerSchema])
 
         class Meta:
             app_label = "sample_app"
 
+    sample_field = SampleModel._meta.get_field("sample_field")
+    assert sample_field.schema == InnerSchema
+
+    sample_list_field = SampleModel._meta.get_field("sample_list")
+    assert sample_list_field.schema == t.List[InnerSchema]
+
+    sample_seq_field = SampleModel._meta.get_field("sample_seq")
+    assert sample_seq_field.schema == t.List[InnerSchema]
 
     existing_raw_field = {"stub_str": "abc", "stub_list": [date(2022, 7, 1)]}
     existing_raw_list = [{"stub_str": "abc", "stub_list": []}]
@@ -54,6 +63,15 @@ class Meta:
     assert instance.sample_list == expected_list
 
 
+def test_untyped_model_field_raises():
+    with pytest.raises(FieldError):
+        class SampleModel(models.Model):
+            sample_field = fields.SchemaField()
+
+            class Meta:
+                app_label = "sample_app"
+
+
 @pytest.mark.parametrize("field", [
     fields.PydanticSchemaField(schema=InnerSchema, default=InnerSchema(stub_str="abc", stub_list=[date(2022, 7, 1)])),
     fields.PydanticSchemaField(schema=InnerSchema, default=(("stub_str", "abc"), ("stub_list", [date(2022, 7, 1)]))),