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

django_spire/core/converters/tests/test_to_enums.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from enum import Enum
 from unittest import TestCase
 
@@ -5,9 +7,9 @@ from django_spire.core.converters.to_enums import django_choices_to_enums
 
 
 class TestDjangoChoicesToEnums(TestCase):
-
-    def test_basic_conversion(self):
+    def test_basic_conversion(self) -> None:
         """Test basic conversion with simple choices"""
+
         choices = [
             ('ACTIVE', 'Active'),
             ('INACTIVE', 'Inactive'),
@@ -16,60 +18,78 @@ class TestDjangoChoicesToEnums(TestCase):
 
         ResultEnum = django_choices_to_enums('Status', choices)
 
-        # Check if enum is created correctly
-        self.assertTrue(issubclass(ResultEnum, Enum))
-        self.assertEqual(ResultEnum.__name__, 'Status')
+        assert issubclass(ResultEnum, Enum)
+        assert ResultEnum.__name__ == 'Status'
 
-        # Check enum members
-        self.assertEqual(ResultEnum.ACTIVE.value, 'ACTIVE')
-        self.assertEqual(ResultEnum.INACTIVE.value, 'INACTIVE')
-        self.assertEqual(ResultEnum.PENDING.value, 'PENDING')
+        assert ResultEnum.ACTIVE.value == 'ACTIVE'
+        assert ResultEnum.INACTIVE.value == 'INACTIVE'
+        assert ResultEnum.PENDING.value == 'PENDING'
 
-        # Check number of members
-        self.assertEqual(len(ResultEnum), 3)
+        assert len(ResultEnum) == 3
 
-    def test_empty_choices(self):
-        """Test function with empty choices list"""
-        choices = []
-        ResultEnum = django_choices_to_enums('EmptyStatus', choices)
+    def test_different_key_value(self) -> None:
+        """Test when keys and values differ"""
 
-        self.assertTrue(issubclass(ResultEnum, Enum))
-        self.assertEqual(ResultEnum.__name__, 'EmptyStatus')
-        self.assertEqual(len(ResultEnum), 0)
+        choices = [
+            ('A', 'Alpha'),
+            ('B', 'Beta'),
+            ('G', 'Gamma')
+        ]
 
-    def test_single_choice(self):
-        """Test with a single choice"""
-        choices = [('OPEN', 'Open')]
-        ResultEnum = django_choices_to_enums('SingleStatus', choices)
+        ResultEnum = django_choices_to_enums('Greek', choices)
 
-        self.assertTrue(issubclass(ResultEnum, Enum))
-        self.assertEqual(ResultEnum.__name__, 'SingleStatus')
-        self.assertEqual(ResultEnum.OPEN.value, 'OPEN')
-        self.assertEqual(len(ResultEnum), 1)
+        assert issubclass(ResultEnum, Enum)
+        assert ResultEnum.A.value == 'A'
+        assert ResultEnum.B.value == 'B'
+        assert ResultEnum.G.value == 'G'
+        assert len(ResultEnum) == 3
 
-    def test_duplicate_keys(self):
+    def test_duplicate_keys(self) -> None:
         """Test behavior with duplicate keys (should use last occurrence)"""
+
         choices = [
             ('STATUS', 'First'),
             ('STATUS', 'Second')
         ]
+
         ResultEnum = django_choices_to_enums('DuplicateStatus', choices)
 
-        self.assertTrue(issubclass(ResultEnum, Enum))
-        self.assertEqual(ResultEnum.STATUS.value, 'STATUS')
-        self.assertEqual(len(ResultEnum), 1)
+        assert issubclass(ResultEnum, Enum)
+        assert ResultEnum.STATUS.value == 'STATUS'
+        assert len(ResultEnum) == 1
+
+    def test_empty_choices(self) -> None:
+        """Test function with empty choices list"""
+
+        choices = []
+        ResultEnum = django_choices_to_enums('EmptyStatus', choices)
+
+        assert issubclass(ResultEnum, Enum)
+        assert ResultEnum.__name__ == 'EmptyStatus'
+        assert len(ResultEnum) == 0
+
+    def test_lowercase_keys_converted_to_uppercase(self) -> None:
+        """Test that lowercase keys are converted to uppercase"""
 
-    def test_different_key_value(self):
-        """Test when keys and values differ"""
         choices = [
-            ('A', 'Alpha'),
-            ('B', 'Beta'),
-            ('G', 'Gamma')
+            ('active', 'Active'),
+            ('inactive', 'Inactive')
         ]
-        ResultEnum = django_choices_to_enums('Greek', choices)
 
-        self.assertTrue(issubclass(ResultEnum, Enum))
-        self.assertEqual(ResultEnum.A.value, 'A')
-        self.assertEqual(ResultEnum.B.value, 'B')
-        self.assertEqual(ResultEnum.G.value, 'G')
-        self.assertEqual(len(ResultEnum), 3)
+        ResultEnum = django_choices_to_enums('Status', choices)
+
+        assert hasattr(ResultEnum, 'ACTIVE')
+        assert hasattr(ResultEnum, 'INACTIVE')
+        assert ResultEnum.ACTIVE.value == 'active'
+        assert ResultEnum.INACTIVE.value == 'inactive'
+
+    def test_single_choice(self) -> None:
+        """Test with a single choice"""
+
+        choices = [('OPEN', 'Open')]
+        ResultEnum = django_choices_to_enums('SingleStatus', choices)
+
+        assert issubclass(ResultEnum, Enum)
+        assert ResultEnum.__name__ == 'SingleStatus'
+        assert ResultEnum.OPEN.value == 'OPEN'
+        assert len(ResultEnum) == 1

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)