django-spire 0.23.7__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/core/converters/tests/test_to_pydantic.py

@@ -1,42 +1,44 @@
+from __future__ import annotations
+
+import enum
+
+from typing import get_args, get_origin, Union
 from unittest import TestCase
-from typing import get_origin, get_args, Union
 
 from pydantic import BaseModel
 
-from django.core.validators import MinValueValidator, MaxValueValidator
+from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
-import enum
 
 from django_spire.core.converters.to_pydantic import DjangoToPydanticFieldConverter, django_to_pydantic_model
 
 
-def is_optional(typ):
-    return get_origin(typ) is Union and type(None) in get_args(typ)
+def is_optional(t: type) -> bool:
+    return get_origin(t) is Union and type(None) in get_args(t)
 
 
 class TestDjangoModelToPydanticModel(TestCase):
-    def test_comprehensive_model_conversion(self):
+    def test_comprehensive_model_conversion(self) -> None:
         class ComprehensiveModel(models.Model):
-            # Django auto-adds an "id" primary key field.
             char_field_with_choices = models.CharField(
                 max_length=10,
-                choices=[("A", "Active"), ("I", "Inactive")],
-                default="A",
-                help_text="Status of the item",
+                choices=[('A', 'Active'), ('I', 'Inactive')],
+                default='A',
+                help_text='Status of the item',
                 unique=True,
                 null=False
             )
             char_field_no_choices = models.CharField(
                 max_length=20,
-                default="default",
-                help_text="Description",
+                default='default',
+                help_text='Description',
                 unique=False,
                 null=True
             )
             int_field = models.IntegerField(
                 validators=[MinValueValidator(0), MaxValueValidator(100)],
                 default=50,
-                help_text="Count",
+                help_text='Count',
                 unique=False,
                 null=True
             )
@@ -44,191 +46,218 @@ class TestDjangoModelToPydanticModel(TestCase):
                 max_digits=5,
                 decimal_places=2,
                 default=0.0,
-                help_text="Price",
+                help_text='Price',
                 unique=False,
                 null=False
             )
             boolean_field = models.BooleanField(
                 default=True,
-                help_text="Active",
+                help_text='Active',
                 null=False
             )
 
             class Meta:
                 managed = False
 
+            def __str__(self) -> str:
+                return 'model'
+
         PydanticModel = django_to_pydantic_model(ComprehensiveModel)
-        self.assertEqual(PydanticModel.__name__, "ComprehensiveModel")
+        assert PydanticModel.__name__ == 'ComprehensiveModel'
 
-    def test_conversion_with_custom_base_class(self):
+    def test_conversion_with_custom_base_class(self) -> None:
         class CustomBase(BaseModel):
-            extra_field: str = "extra"
+            extra_field: str = 'extra'
 
         class CustomModel(models.Model):
-            char_field = models.CharField(max_length=10, default="custom")
+            char_field = models.CharField(max_length=10, default='custom')
+
             class Meta:
                 managed = False
 
+            def __str__(self) -> str:
+                return 'model'
+
         PydanticModel = django_to_pydantic_model(CustomModel, base_class=CustomBase)
-        instance = PydanticModel(id=1, char_field="custom", extra_field="extra")
+        instance = PydanticModel(id=1, char_field='custom', extra_field='extra')
 
-        self.assertEqual(instance.char_field, "custom")
-        self.assertEqual(instance.extra_field, "extra")
+        assert instance.char_field == 'custom'
+        assert instance.extra_field == 'extra'
 
-    def test_include_fields_only(self):
-        class SimpleModel1(models.Model):
-            field1 = models.CharField(max_length=50, default="value1")
+    def test_exclude_fields(self) -> None:
+        class SimpleModel2(models.Model):
+            field1 = models.CharField(max_length=50, default='value1')
             field2 = models.IntegerField(default=10)
             field3 = models.BooleanField(default=True)
+
             class Meta:
                 managed = False
 
-        PydanticModel = django_to_pydantic_model(SimpleModel1, include_fields=["id", "field1", "field3"])
-        fields = PydanticModel.__fields__
-        self.assertIn("id", fields)
-        self.assertIn("field1", fields)
-        self.assertIn("field3", fields)
-        self.assertNotIn("field2", fields)
+            def __str__(self) -> str:
+                return 'model'
 
-    def test_exclude_fields(self):
-        class SimpleModel2(models.Model):
-            field1 = models.CharField(max_length=50, default="value1")
+        PydanticModel = django_to_pydantic_model(SimpleModel2, exclude_fields=['field2'])
+        fields = PydanticModel.model_fields
+        assert 'id' in fields
+        assert 'field1' in fields
+        assert 'field3' in fields
+        assert 'field2' not in fields
+
+    def test_include_and_exclude(self) -> None:
+        class SimpleModel3(models.Model):
+            field1 = models.CharField(max_length=50, default='value1')
             field2 = models.IntegerField(default=10)
             field3 = models.BooleanField(default=True)
+            field4 = models.CharField(max_length=100, default='value4')
+
             class Meta:
                 managed = False
 
-        PydanticModel = django_to_pydantic_model(SimpleModel2, exclude_fields=["field2"])
-        fields = PydanticModel.__fields__
-        self.assertIn("id", fields)
-        self.assertIn("field1", fields)
-        self.assertIn("field3", fields)
-        self.assertNotIn("field2", fields)
+            def __str__(self) -> str:
+                return 'model'
 
-    def test_include_and_exclude(self):
-        # Define a simple model with multiple fields.
-        class SimpleModel3(models.Model):
-            field1 = models.CharField(max_length=50, default="value1")
+        PydanticModel = django_to_pydantic_model(
+            SimpleModel3,
+            include_fields=['id', 'field1', 'field2', 'field3'],
+            exclude_fields=['field2']
+        )
+
+        fields = PydanticModel.model_fields
+        assert 'id' in fields
+        assert 'field1' in fields
+        assert 'field3' in fields
+        assert 'field2' not in fields
+        assert 'field4' not in fields
+
+    def test_include_fields_only(self) -> None:
+        class SimpleModel1(models.Model):
+            field1 = models.CharField(max_length=50, default='value1')
             field2 = models.IntegerField(default=10)
             field3 = models.BooleanField(default=True)
-            field4 = models.CharField(max_length=100, default="value4")
+
             class Meta:
                 managed = False
 
-        PydanticModel = django_to_pydantic_model(
-            SimpleModel3,
-            include_fields=["id", "field1", "field2", "field3"],
-            exclude_fields=["field2"]
-        )
-        fields = PydanticModel.__fields__
-        self.assertIn("id", fields)
-        self.assertIn("field1", fields)
-        self.assertIn("field3", fields)
-        self.assertNotIn("field2", fields)
-        self.assertNotIn("field4", fields)
+            def __str__(self) -> str:
+                return 'model'
+
+        PydanticModel = django_to_pydantic_model(SimpleModel1, include_fields=['id', 'field1', 'field3'])
+        fields = PydanticModel.model_fields
+        assert 'id' in fields
+        assert 'field1' in fields
+        assert 'field3' in fields
+        assert 'field2' not in fields
 
 
 class TestDjangoToPydanticFieldConverter(TestCase):
     # def test_nullable_field_is_optional(self):
     #     class Model(models.Model):
     #         char_field = models.CharField(max_length=10, null=True)
-    #
+
     #         class Meta:
     #             managed = False
-    #
+
+    #         def __str__(self) -> str:
+    #             return 'model'
+
     #     field = Model._meta.get_field('char_field')
     #     field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
-    #
-    #     self.assertTrue(is_optional(field_type))
 
-    def test_field_with_no_default_sets_none(self):
-        class Model1(models.Model):
-            char_field = models.CharField(max_length=10, null=True)
+    #     assert is_optional(field_type)
+
+    def test_charfield_constraints_applied(self) -> None:
+        class Model4(models.Model):
+            name = models.CharField(max_length=30)
 
             class Meta:
                 managed = False
 
-        field = Model1._meta.get_field('char_field')
-        _, field_info = DjangoToPydanticFieldConverter(field).build_field()
+            def __str__(self) -> str:
+                return 'model'
 
-        self.assertIsNone(field_info.default)
+        field = Model4._meta.get_field('name')
+        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
 
-    # def test_field_with_default(self):
-    #     class Model(models.Model):
-    #         char_field = models.CharField(max_length=10, default="abc")
-    #
-    #         class Meta:
-    #             managed = False
-    #
-    #     field = Model._meta.get_field('char_field')
-    #     _, field_info = DjangoToPydanticFieldConverter(field).build_field()
-    #
-    #     self.assertEqual(field_info.default, "abc")
+        assert 'max_length=30' in str(field_type)
 
-    def test_help_text_becomes_description(self):
-        class Model2(models.Model):
-            char_field = models.CharField(max_length=10, help_text="hello")
+    def test_decimalfield_constraints_applied(self) -> None:
+        class Model6(models.Model):
+            amount = models.DecimalField(max_digits=5, decimal_places=2)
 
             class Meta:
                 managed = False
 
-        field = Model2._meta.get_field('char_field')
-        _, field_info = DjangoToPydanticFieldConverter(field).build_field()
+            def __str__(self) -> str:
+                return 'model'
 
-        self.assertEqual(field_info.description, "hello")
+        field = Model6._meta.get_field('amount')
+        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+
+        assert 'max_digits=5' in str(field_type)
+        assert 'decimal_places=2' in str(field_type)
 
-    def test_enum_created_for_choices(self):
+    def test_enum_created_for_choices(self) -> None:
         class Model3(models.Model):
             status = models.CharField(
                 max_length=10,
-                choices=[("A", "Active"), ("I", "Inactive")],
-                default="A"
+                choices=[('A', 'Active'), ('I', 'Inactive')],
+                default='A'
             )
 
             class Meta:
                 managed = False
 
+            def __str__(self) -> str:
+                return 'model'
+
         field = Model3._meta.get_field('status')
         field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
 
-        self.assertTrue(issubclass(field_type, enum.Enum))
-        self.assertEqual(set(field_type.__members__), {"A", "I"})
+        assert issubclass(field_type, enum.Enum)
+        assert set(field_type.__members__) == {'A', 'I'}
 
-    def test_charfield_constraints_applied(self):
-        class Model4(models.Model):
-            name = models.CharField(max_length=30)
+    def test_field_with_no_default_sets_none(self) -> None:
+        class Model1(models.Model):
+            char_field = models.CharField(max_length=10, null=True)
 
             class Meta:
                 managed = False
 
-        field = Model4._meta.get_field('name')
-        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+            def __str__(self) -> str:
+                return 'model'
 
-        self.assertIn("max_length=30", str(field_type))
+        field = Model1._meta.get_field('char_field')
+        _, field_info = DjangoToPydanticFieldConverter(field).build_field()
 
-    def test_integerfield_validators_become_constraints(self):
-        # Todo: test needs to be corrected.
-        from django.core.validators import MinValueValidator, MaxValueValidator
+        assert field_info.default is None
 
-        class Model5(models.Model):
-            count = models.IntegerField(validators=[MinValueValidator(1), MaxValueValidator(10)])
+    def test_help_text_becomes_description(self) -> None:
+        class Model2(models.Model):
+            char_field = models.CharField(max_length=10, help_text='hello')
 
             class Meta:
                 managed = False
 
-        field = Model5._meta.get_field('count')
-        field_type, field_info = DjangoToPydanticFieldConverter(field).build_field()
-        self.assertIn("int", str(field_type))
+            def __str__(self) -> str:
+                return 'model'
 
-    def test_decimalfield_constraints_applied(self):
-        class Model6(models.Model):
-            amount = models.DecimalField(max_digits=5, decimal_places=2)
+        field = Model2._meta.get_field('char_field')
+        _, field_info = DjangoToPydanticFieldConverter(field).build_field()
+
+        assert field_info.description == 'hello'
+
+    def test_integerfield_validators_become_constraints(self) -> None:
+        # TODO(Nathan): test needs to be corrected.
+
+        class Model5(models.Model):
+            count = models.IntegerField(validators=[MinValueValidator(1), MaxValueValidator(10)])
 
             class Meta:
                 managed = False
 
-        field = Model6._meta.get_field('amount')
-        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+            def __str__(self) -> str:
+                return 'model'
 
-        self.assertIn("max_digits=5", str(field_type))
-        self.assertIn("decimal_places=2", str(field_type))
+        field = Model5._meta.get_field('count')
+        field_type, _ = DjangoToPydanticFieldConverter(field).build_field()
+        assert 'int' in str(field_type)

django_spire/core/converters/to_data.py

@@ -1,18 +1,28 @@
-from django.db import models
+from __future__ import annotations
+
+import os
+import random
+
+from typing import TYPE_CHECKING
+
 from django.core.validators import MinValueValidator, MaxValueValidator
 from faker import Faker
-import random
-import os
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from django.db import models
 
 
 class DjangoFieldToFakerData:
     def __init__(
-            self,
-            model_field: models.Field,
-            faker_method: tuple | None = None
+        self,
+        model_field: models.Field,
+        faker_method: tuple | None = None
     ):
         if isinstance(faker_method, str):
             faker_method = (faker_method,)
+
         self.model_field = model_field
         self.faker_method = faker_method
         self.faker = Faker()
@@ -40,22 +50,28 @@ class DjangoFieldToFakerData:
     def convert(self):
         if self.faker_method:
             result = self._use_faker_with_method()
+
             if result is not None:
                 return result
 
         converter = self.field_converters.get(self.model_field.get_internal_type())
+
         if converter is None:
-            raise Exception(f'No handler for {self.model_field.get_internal_type()}')
+            message = f'No handler for {self.model_field.get_internal_type()}'
+            raise Exception(message)
+
         return converter()
 
     def _get_min_max_from_validators(self):
         min_value = 0
         max_value = 10000
+
         for validator in self.model_field.validators:
             if isinstance(validator, MinValueValidator):
                 min_value = validator.limit_value
             elif isinstance(validator, MaxValueValidator):
                 max_value = validator.limit_value
+
         return min_value, max_value
 
     def _use_faker_with_method(self):
@@ -64,6 +80,7 @@ class DjangoFieldToFakerData:
             kwargs = self.faker_method[1] if len(self.faker_method) > 1 and isinstance(self.faker_method[1], dict) else {}
 
             method = getattr(self.faker, method_name, None)
+
             if callable(method):
                 return method(**kwargs)
 
@@ -79,8 +96,6 @@ class DjangoFieldToFakerData:
             choices = [choice[0] for choice in self.model_field.choices]
             return self.faker.random_element(elements=choices)
 
-
-
         return self.faker.text(max_nb_chars=max_length)
 
     def _integer_field_data(self):
@@ -126,6 +141,10 @@ class DjangoFieldToFakerData:
         return os.urandom(16)
 
 
-def fake_model_field_value(model_class, field_name: str, faker_method=None):
+def fake_model_field_value(
+    model_class: type[models.Model],
+    field_name: str,
+    faker_method: str | tuple | None = None
+) -> Any:
     field = model_class._meta.get_field(field_name)
     return DjangoFieldToFakerData(field, faker_method).convert()

django_spire/core/converters/to_enums.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 from enum import Enum
 
 
 def django_choices_to_enums(
-        class_name: str,
-        choices: list[tuple[str, str]]
+    class_name: str,
+    choices: list[tuple[str, str]]
 ):
     choices_dict = {str(k).upper(): k for k, _ in choices}
     return Enum(class_name, choices_dict)

django_spire/core/converters/to_pydantic.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 from pydantic import constr, condecimal, create_model
 from pydantic.fields import Field
 
-from typing import Tuple, Type, Any, Optional
+from typing import Any
 
 from django.db import models
 from django.core import validators
@@ -11,13 +13,14 @@ from django_spire.core.maps import MODEL_FIELD_TYPE_TO_TYPE_MAP
 
 
 def django_to_pydantic_model(
-        model_class: Type[models.Model],
-        base_class: Type | None = None,
-        include_fields: str | list| tuple | None = None,
-        exclude_fields: str | list | tuple | None = None
+    model_class: type[models.Model],
+    base_class: type | None = None,
+    include_fields: str | list| tuple | None = None,
+    exclude_fields: str | list | tuple | None = None
 ):
     if not issubclass(model_class, models.Model):
-        raise ValueError("model_class must be a subclass of django.db.models.Model")
+        message = 'model_class must be a subclass of django.db.models.Model'
+        raise TypeError(message)
 
     if include_fields is None:
         include_fields = []
@@ -47,7 +50,6 @@ def django_to_pydantic_model(
 
 
 class DjangoToPydanticFieldConverter:
-
     def __init__(self, model_field: models.Field):
         self.model_field = model_field
         self.kwargs = {}
@@ -60,8 +62,8 @@ class DjangoToPydanticFieldConverter:
     def bool_to_json_schema(value: bool):
         if value:
             return "true"
-        else:
-            return "false"
+
+        return "false"
 
     @property
     def field_handlers(self):
@@ -80,22 +82,20 @@ class DjangoToPydanticFieldConverter:
             str
         )
 
-    def _build_char_field(self) -> Type:
+    def _build_char_field(self) -> type:
         if self.model_field.max_length:
             return constr(max_length=self.model_field.max_length)
         return str
 
-    def _build_date_field(self) -> Type:
-        self.kwargs['example'] = '2022-01-01'
+    def _build_date_field(self) -> type:
         self.kwargs['json_schema_extra']['example'] = '2022-01-01'
         return self._base_type()
 
-    def _build_date_time_field(self) -> Type:
-        self.kwargs['example'] = '2022-01-01 13:37:00'
+    def _build_date_time_field(self) -> type:
         self.kwargs['json_schema_extra']['example'] = '2022-01-01 13:37:00'
         return self._base_type()
 
-    def _build_integer_field(self) -> Type:
+    def _build_integer_field(self) -> type:
         for validator in self.model_field.validators:
             if isinstance(validator, validators.MinValueValidator):
                 self.kwargs['json_schema_extra']['greater_than'] = validator.limit_value
@@ -104,7 +104,7 @@ class DjangoToPydanticFieldConverter:
 
         return self._base_type()
 
-    def _build_decimal_field(self) -> Type:
+    def _build_decimal_field(self) -> type:
         self.kwargs['json_schema_extra']['example'] = '0.00'
         self.kwargs['json_schema_extra']['max_digits'] = self.model_field.max_digits
         self.kwargs['json_schema_extra']['decimal_places'] = self.model_field.decimal_places
@@ -118,21 +118,19 @@ class DjangoToPydanticFieldConverter:
         enum_name = f"{self.model_field.name.capitalize()}Enum"
         return django_choices_to_enums(enum_name, self.model_field.choices)
 
-    def build_field(self) -> Tuple[Type, Any]:
+    def build_field(self) -> tuple[type, Any]:
         """Build and return the Pydantic field type and Field object."""
         return self.field_type, Field(**self.kwargs)
 
     def _build_metadata(self):
-
         # Cannot set a default when providing option to the LLM
+
         # if self.model_field.default is not models.NOT_PROVIDED:
         #     if callable(self.model_field.default):
         #         self.kwargs['default'] = self.model_field.default()
         #     else:
         #         self.kwargs['default'] = self.model_field.default
 
-        self.kwargs['required'] = not self.model_field.null
-
         if self.model_field.null and self.model_field.default is models.NOT_PROVIDED:
             self.kwargs['default'] = None
 
@@ -140,6 +138,7 @@ class DjangoToPydanticFieldConverter:
             self.kwargs['description'] = str(self.model_field.help_text)
 
         self.kwargs['json_schema_extra'] = {
+            'required': self.bool_to_json_schema(not self.model_field.null),
             'is_unique': self.bool_to_json_schema(self.model_field.unique),
             # 'is_required': self.bool_to_json_schema(not self.model_field.null),
             'field_name': self.model_field.name
@@ -151,7 +150,7 @@ class DjangoToPydanticFieldConverter:
                 f"{value} ({label})" for value, label in self.model_field.choices
             ) + "."
 
-    def _get_pydantic_type(self) -> Type:
+    def _get_pydantic_type(self) -> type:
         if self.model_field.choices:
             return self._build_enum_type()
 
@@ -164,6 +163,7 @@ class DjangoToPydanticFieldConverter:
 
     def _wrap_nullable(self):
         pass
+
         # This works better for the LLM
         # if self.model_field.null:
-        #     self.field_type = Optional[self.field_type]
+        #     self.field_type = Optional[self.field_type]

django_spire/core/decorators.py

@@ -1,25 +1,38 @@
-from django.db import connections
+from __future__ import annotations
+
 from functools import wraps
 
-from django.http import JsonResponse
+from typing import Callable, ParamSpec, TypeVar
+
+from django.db import connections
+from django.http import HttpRequest, HttpResponse, JsonResponse
+
 
+P = ParamSpec('P')
+T = TypeVar('T')
 
-def close_db_connections(func):
+
+def close_db_connections(func: Callable[P, T]) -> Callable[P, T]:
     @wraps(func)
-    def inner(*args, **kwargs):
+    def inner(*args: P.args, **kwargs: P.kwargs) -> T:
         try:
             return func(*args, **kwargs)
         finally:
             connections.close_all()
+
     return inner
 
 
-def valid_ajax_request_required(method):
+def valid_ajax_request_required(
+    method: Callable[..., HttpResponse]
+) -> Callable[..., HttpResponse]:
     @wraps(method)
-    def wrapper(request, *args, **kwargs):
+    def wrapper(request: HttpRequest, *args, **kwargs) -> HttpResponse:
         if request.method != 'POST' and request.content_type != 'application/json':
             return JsonResponse(
                 {'type': 'error', 'message': 'Invalid Request'}
             )
+
         return method(request, *args, **kwargs)
+
     return wrapper