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

django_spire/contrib/seeding/model/config.py

@@ -1,15 +1,22 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django_spire.contrib.seeding.field.cleaners import normalize_seeder_fields
 from django_spire.contrib.seeding.model.enums import ModelSeederDefaultsEnum
 
+if TYPE_CHECKING:
+    from typing import Any, Self
+
 
 class FieldsConfig:
     def __init__(
-            self,
-            raw_fields: dict,
-            field_names: list[str],
-            default_to: str,
-            model_class
-    ):
+        self,
+        raw_fields: dict[str, Any],
+        field_names: list[str],
+        default_to: str,
+        model_class: Any
+    ) -> None:
         self.raw_fields = raw_fields or {}
         self.default_to = default_to
         self.field_names = set(field_names)
@@ -17,7 +24,7 @@ class FieldsConfig:
 
         self._excluded = {
             k for k, v in self.raw_fields.items()
-            if v == "exclude" or v == ("exclude",)
+            if v in ("exclude", ("exclude",))
         }
 
         self.fields = normalize_seeder_fields({
@@ -26,14 +33,18 @@ class FieldsConfig:
 
         self._validate()
         self._assign_defaults()
-        self._order_fields() # Fields need to be in order for caching hash
 
-    def _validate(self):
+        # Fields need to be in order for caching hash
+        self._order_fields()
+
+    def _validate(self) -> None:
         unknown = set(self.fields.keys()) - self.field_names
+
         if unknown:
-            raise ValueError(f"Invalid field name(s): {', '.join(unknown)}")
+            message = f"Invalid field name(s): {', '.join(unknown)}"
+            raise ValueError(message)
 
-    def _assign_defaults(self):
+    def _assign_defaults(self) -> None:
         if self.default_to == ModelSeederDefaultsEnum.INCLUDED:
             return
 
@@ -43,7 +54,7 @@ class FieldsConfig:
             if name not in self.fields and name not in self._excluded:
                 self.fields[name] = (method,)
 
-    def override(self, overrides: dict):
+    def override(self, overrides: dict) -> Self:
         merged = {**self.fields, **normalize_seeder_fields(overrides)}
         new_raw = {
             **{k: v for k, v in self.raw_fields.items() if k in self._excluded},
@@ -56,9 +67,14 @@ class FieldsConfig:
             model_class=self.model_class
         )
 
-    def _order_fields(self):
-        self.fields = {k: v for k, v in sorted(self.fields.items(), key=lambda x: x[0])}
+    def _order_fields(self) -> None:
+        self.fields = dict(
+            sorted(
+                self.fields.items(),
+                key=lambda x: x[0]
+            )
+        )
 
     @property
-    def excluded(self):
+    def excluded(self) -> set:
         return self._excluded

django_spire/contrib/seeding/model/django/config.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 from django_spire.contrib.seeding.model.config import FieldsConfig
 
 
 class DjangoModelFieldsConfig(FieldsConfig):
-
-    def _validate(self):
+    def _validate(self) -> None:
         valid_field_names = set(self.field_names)
 
         valid_field_names.update(f.attname for f in self.model_class._meta.fields)
@@ -11,18 +12,18 @@ class DjangoModelFieldsConfig(FieldsConfig):
         unknown = set(self.fields.keys()) - valid_field_names
 
         if unknown:
-            raise ValueError(f"Invalid field name(s): {', '.join(unknown)}")
+            message = f"Invalid field name(s): {', '.join(unknown)}"
+            raise ValueError(message)
 
         # fk_fields = {
         #     f.name: f.attname  # f.attname = "user_id"
         #     for f in self.model_class._meta.fields
         #     if isinstance(f, ForeignKey)
         # }
-        #
+
         # for name, value in self.fields.items():
         #     if name in fk_fields:
         #         valid_types = [int, None]
-        #
 
     # def map_foreign_keys(self):
     #     fk_fields = {
@@ -30,19 +31,20 @@ class DjangoModelFieldsConfig(FieldsConfig):
     #         for f in self.model_class._meta.fields
     #         if isinstance(f, ForeignKey)
     #     }
-    #
+
     #     # If asset_id and asset are passed, should I raise an error?
-    #
+
     #     {
     #         'asset' : ('custom', 'in_order', {'values': [a.id for a in assets]}),
     #         'asset_id': ('custom', 'in_order', {'values': [a.id for a in assets]}),
     #     }
-    #
+
     #     translated_fields = {}
+
     #     for name, value in self.fields.items():
     #         if name in fk_fields:
     #             translated_name = fk_fields[name]
-    #
+
     #             if translated_name in self.field_names:
     #                 # Do not want to override asset_id if the user has already pass it in.
     #                 continue
@@ -50,9 +52,7 @@ class DjangoModelFieldsConfig(FieldsConfig):
     #                 translated_fields[translated_name] = value
     #         else:
     #             translated_fields[name] = value
-    #
+
     #     return translated_fields
-    #
+
     #     # Update self.fields.
-    #
-    #

django_spire/contrib/seeding/model/django/seeder.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from typing import TypeVar, TYPE_CHECKING
 
-from django.db.models import ForeignKey
 from django.db.models.base import Model
+from django.db.models import ForeignKey
 
 from django_spire.contrib.seeding.field.callable import CallableFieldSeeder
 from django_spire.contrib.seeding.field.custom import CustomFieldSeeder
@@ -37,11 +37,11 @@ class DjangoModelSeeder(BaseModelSeeder):
         super().__init_subclass__(**kwargs)
 
         if cls.model_class is None:
-            message = "Seeds must have a model class"
+            message = 'Seeds must have a model class'
             raise ValueError(message)
 
         if cls.fields is None:
-            message = "Seeds must have fields"
+            message = 'Seeds must have fields'
             raise ValueError(message)
 
     @classmethod
@@ -55,7 +55,7 @@ class DjangoModelSeeder(BaseModelSeeder):
     @classmethod
     def seed_database(
         cls,
-        count=1,
+        count: int = 1,
         fields: dict | None = None
     ) -> list[TypeModel]:
         model_objects = cls.seed(count, fields)

django_spire/contrib/seeding/model/django/tests/test_seeder.py

@@ -1,5 +1,9 @@
-import unittest
+from __future__ import annotations
+
+import pytest
+
 from django.db import models
+from django.test import TestCase
 from django.utils.timezone import now
 
 from django_spire.contrib.seeding import DjangoModelSeeder
@@ -15,39 +19,46 @@ class Product(models.Model):
     updated_at = models.DateTimeField(null=True, blank=True)
 
     class Meta:
-        app_label = "tests"
+        app_label = 'tests'
         managed = False
 
+    def __str__(self) -> str:
+        return 'Product'
+
 
 class ProductSeeder(DjangoModelSeeder):
     model_class = Product
     fields = {
-        "name": ('llm', 'Clothing store'),
-        "description": ('static', 'A great product for testing.'),
-        "price": ('faker', 'pydecimal', {'left_digits': 2, 'right_digits': 2, 'positive': True}),
-        "in_stock": True,
-        "created_at": ("callable", now),
-        "updated_at": 'exclude',
+        'name': ('llm', 'Clothing store'),
+        'description': ('static', 'A great product for testing.'),
+        'price': ('faker', 'pydecimal', {'left_digits': 2, 'right_digits': 2, 'positive': True}),
+        'in_stock': True,
+        'created_at': ('callable', now),
+        'updated_at': 'exclude',
     }
 
 
-class TestProductSeeder(unittest.TestCase):
+class TestProductSeeder(TestCase):
+    def test_assign_defaults(self) -> None:
+        assert 'sku' in ProductSeeder.resolved_fields()
+
+    def test_field_override_applies(self) -> None:
+        override_time = now()
+
+        result = ProductSeeder.seed(count=1, fields={'updated_at': ('static', override_time)})
 
-    def test_assign_defaults(self):
-        self.assertIn('sku', ProductSeeder.resolved_fields().keys())
+        assert result[0].updated_at == override_time
 
-    def test_seeds_three_objects(self):
+    def test_raises_for_invalid_field(self) -> None:
+        with pytest.raises(Exception) as exc_info:
+            ProductSeeder.seed(count=1, fields={'not_a_field': ('static', 'value')})
+
+        assert 'not_a_field' in str(exc_info.value)
+
+    def test_seeds_three_objects(self) -> None:
         result = ProductSeeder.seed(count=3)
-        self.assertEqual(len(result), 3)
-        for obj in result:
-            self.assertIsInstance(obj, Product)
 
-    def test_raises_for_invalid_field(self):
-        with self.assertRaises(Exception) as context:
-            ProductSeeder.seed(count=1, fields={"not_a_field": ("static", "value")})
-        self.assertIn("not_a_field", str(context.exception))
+        assert len(result) == 3
 
-    def test_field_override_applies(self):
-        override_time = now()
-        result = ProductSeeder.seed(count=1, fields={"updated_at": ("static", override_time)})
-        self.assertEqual(result[0].updated_at, override_time)
+        for obj in result:
+            assert isinstance(obj, Product)

django_spire/contrib/seeding/model/enums.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from enum import Enum
 
 

django_spire/contrib/seeding/tests/test_config.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import pytest
+
+from unittest.mock import MagicMock
+
+from django.test import TestCase
+
+from django_spire.contrib.seeding.model.config import FieldsConfig
+
+
+class TestFieldsConfig(TestCase):
+    def setUp(self) -> None:
+        self.model_class = MagicMock()
+
+    def test_assign_defaults_adds_missing_fields(self) -> None:
+        config = FieldsConfig(
+            raw_fields={'name': ('static', 'test')},
+            field_names=['name', 'email'],
+            default_to='llm',
+            model_class=self.model_class
+        )
+
+        assert 'email' in config.fields
+        assert config.fields['email'] == ('llm',)
+
+    def test_excluded_property(self) -> None:
+        config = FieldsConfig(
+            raw_fields={'name': 'exclude', 'email': ('exclude',)},
+            field_names=['name', 'email', 'status'],
+            default_to='llm',
+            model_class=self.model_class
+        )
+
+        assert 'name' in config.excluded
+        assert 'email' in config.excluded
+        assert 'status' not in config.excluded
+
+    def test_fields_are_ordered(self) -> None:
+        config = FieldsConfig(
+            raw_fields={'zebra': ('static', 'z'), 'apple': ('static', 'a')},
+            field_names=['zebra', 'apple'],
+            default_to='included',
+            model_class=self.model_class
+        )
+
+        keys = list(config.fields.keys())
+
+        assert keys == ['apple', 'zebra']
+
+    def test_override_creates_new_config(self) -> None:
+        config = FieldsConfig(
+            raw_fields={'name': ('static', 'original')},
+            field_names=['name', 'email'],
+            default_to='llm',
+            model_class=self.model_class
+        )
+
+        new_config = config.override({'name': ('static', 'overridden')})
+
+        assert new_config is not config
+        assert new_config.fields['name'] == ('static', 'overridden')
+
+    def test_validate_raises_for_invalid_fields(self) -> None:
+        with pytest.raises(ValueError, match='Invalid field name'):
+            FieldsConfig(
+                raw_fields={'invalid_field': ('static', 'test')},
+                field_names=['name', 'email'],
+                default_to='llm',
+                model_class=self.model_class
+            )

django_spire/contrib/seeding/tests/test_custom.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import pytest
+
+from django.test import TestCase
+from django.utils import timezone
+
+from django_spire.contrib.seeding.field.custom import CustomFieldSeeder
+
+
+class TestCustomFieldSeeder(TestCase):
+    def test_date_time_between_returns_aware_datetime(self) -> None:
+        seeder = CustomFieldSeeder(fields={})
+
+        result = seeder.date_time_between(start_date='-30d', end_date='now')
+
+        assert timezone.is_aware(result)
+
+    def test_in_order_cycles_through_values(self) -> None:
+        seeder = CustomFieldSeeder(fields={})
+        values = ['a', 'b', 'c']
+
+        assert seeder.in_order(values, index=0) == 'a'
+        assert seeder.in_order(values, index=1) == 'b'
+        assert seeder.in_order(values, index=2) == 'c'
+        assert seeder.in_order(values, index=3) == 'a'
+
+    def test_in_order_raises_for_empty_list(self) -> None:
+        seeder = CustomFieldSeeder(fields={})
+
+        with pytest.raises(ValueError, match='Cannot select from empty values list'):
+            seeder.in_order(values=[], index=0)
+
+    def test_keyword_is_custom(self) -> None:
+        assert CustomFieldSeeder.keyword == 'custom'

django_spire/contrib/seeding/tests/test_enums.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
+from django_spire.contrib.seeding.model.enums import ModelSeederDefaultsEnum
+
+
+class TestFieldSeederTypesEnum(TestCase):
+    def test_callable_value(self) -> None:
+        assert FieldSeederTypesEnum.CALLABLE == 'callable'
+
+    def test_custom_value(self) -> None:
+        assert FieldSeederTypesEnum.CUSTOM == 'custom'
+
+    def test_faker_value(self) -> None:
+        assert FieldSeederTypesEnum.FAKER == 'faker'
+
+    def test_is_str_enum(self) -> None:
+        assert isinstance(FieldSeederTypesEnum.LLM, str)
+
+    def test_llm_value(self) -> None:
+        assert FieldSeederTypesEnum.LLM == 'llm'
+
+    def test_static_value(self) -> None:
+        assert FieldSeederTypesEnum.STATIC == 'static'
+
+
+class TestModelSeederDefaultsEnum(TestCase):
+    def test_faker_value(self) -> None:
+        assert ModelSeederDefaultsEnum.FAKER == 'faker'
+
+    def test_included_value(self) -> None:
+        assert ModelSeederDefaultsEnum.INCLUDED == 'included'
+
+    def test_is_str_enum(self) -> None:
+        assert isinstance(ModelSeederDefaultsEnum.LLM, str)
+
+    def test_llm_value(self) -> None:
+        assert ModelSeederDefaultsEnum.LLM == 'llm'

django_spire/contrib/seeding/tests/test_intel.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from django_spire.contrib.seeding.intelligence.intel import SeedingIntel, SourceIntel
+
+
+class TestSeedingIntel(TestCase):
+    def test_is_iterable(self) -> None:
+        intel = SeedingIntel(items=[{'name': 'test1'}, {'name': 'test2'}])
+
+        result = list(intel)
+
+        assert result == [{'name': 'test1'}, {'name': 'test2'}]
+
+    def test_items_attribute(self) -> None:
+        items = [{'name': 'test'}]
+        intel = SeedingIntel(items=items)
+
+        assert intel.items == items
+
+
+class TestSourceIntel(TestCase):
+    def test_file_name_attribute(self) -> None:
+        intel = SourceIntel(file_name='test.py', python_source_code='print("hello")')
+
+        assert intel.file_name == 'test.py'
+
+    def test_python_source_code_attribute(self) -> None:
+        intel = SourceIntel(file_name='test.py', python_source_code='print("hello")')
+
+        assert intel.python_source_code == 'print("hello")'

django_spire/contrib/seeding/tests/test_override.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.test import TestCase
+
+from django_spire.contrib.seeding.field.override import FieldOverride
+
+
+class TestFieldOverride(TestCase):
+    def setUp(self) -> None:
+        self.seeder_class = MagicMock()
+        self.seeder_class.seed.return_value = [{'name': 'test'}]
+
+    def test_filter_returns_self(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        result = override.filter(name='test')
+
+        assert result is override
+
+    def test_filter_updates_overrides(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        override.filter(name='test', status='active')
+
+        assert override.overrides == {'name': 'test', 'status': 'active'}
+
+    def test_getattr_delegates_to_seeder_class(self) -> None:
+        self.seeder_class.some_attribute = 'value'
+        override = FieldOverride(self.seeder_class)
+
+        result = override.some_attribute
+
+        assert result == 'value'
+
+    def test_init_sets_seeder_class(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        assert override.seeder_class is self.seeder_class
+
+    def test_init_sets_empty_overrides(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        assert override.overrides == {}
+
+    def test_seed_calls_seeder_class_seed(self) -> None:
+        override = FieldOverride(self.seeder_class)
+        override.filter(name='override_value')
+
+        override.seed(count=2)
+
+        self.seeder_class.seed.assert_called_once_with(
+            count=2,
+            fields={'name': 'override_value'}
+        )
+
+    def test_seed_returns_seeder_class_result(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        result = override.seed(count=1)
+
+        assert result == [{'name': 'test'}]

django_spire/contrib/service/__init__.py

@@ -1,7 +1,7 @@
-from django_spire.contrib.service.exceptions import ServiceException
+from django_spire.contrib.service.exceptions import ServiceError
 from django_spire.contrib.service.django_model_service import BaseDjangoModelService
 
 __all__ = [
     'BaseDjangoModelService',
-    'ServiceException',
+    'ServiceError',
 ]

django_spire/contrib/service/django_model_service.py

@@ -1,22 +1,26 @@
 from __future__ import annotations
 
 import logging
+
 from abc import ABC
-from typing import Type, Generic, TypeVar
+from typing import Generic, TypeVar
 
 from django.db import transaction
 from django.db.models import Model
 
 from django_spire.contrib.constructor.django_model_constructor import BaseDjangoModelConstructor
-from django_spire.contrib.service.exceptions import ServiceException
+from django_spire.contrib.service.exceptions import ServiceError
+
+
+log = logging.getLogger(__name__)
 
-TypeDjangoModel = TypeVar('TypeDjangoModel', bound=Model, covariant=True)
+TypeDjangoModel_co = TypeVar('TypeDjangoModel_co', bound=Model, covariant=True)
 
 
 class BaseDjangoModelService(
-    BaseDjangoModelConstructor[TypeDjangoModel],
+    BaseDjangoModelConstructor[TypeDjangoModel_co],
     ABC,
-    Generic[TypeDjangoModel]
+    Generic[TypeDjangoModel_co]
 ):
     def _get_concrete_fields(self) -> dict:
         return {
@@ -33,7 +37,7 @@ class BaseDjangoModelService(
 
         for field, value in field_data.items():
             if field not in allowed:
-                logging.warning(f'Field {field!r} is not valid for {self.obj.__class__.__name__}')
+                log.warning(f'Field {field!r} is not valid for {self.obj.__class__.__name__}')
                 continue
 
             model_field = concrete_fields.get(field.removesuffix("_id"), None)
@@ -51,12 +55,8 @@ class BaseDjangoModelService(
         concrete_fields = self._get_concrete_fields()
         touched_fields = self._get_touched_fields(concrete_fields, **field_data)
 
-        try:
-            self.obj.full_clean(
-                exclude=[field for field in concrete_fields if field not in touched_fields]
-            )
-        except:
-            raise
+        exclude = [field for field in concrete_fields if field not in touched_fields]
+        self.obj.full_clean(exclude=exclude)
 
         return touched_fields
 
@@ -65,7 +65,8 @@ class BaseDjangoModelService(
         new_model_obj_was_created = False
 
         if not field_data:
-            raise ServiceException(f'Field data is required to save on {self.obj.__class__.__name__}')
+            message = f'Field data is required to save on {self.obj.__class__.__name__}'
+            raise ServiceError(message)
 
         touched_fields = self.validate_model_obj(**field_data)
 
@@ -77,7 +78,7 @@ class BaseDjangoModelService(
             self.obj.save(update_fields=touched_fields)
 
         else:
-            logging.warning(
-                f'{self.obj.__class__.__name__} is not a new object or there was no touched fields to update.')
+            message = f'{self.obj.__class__.__name__} is not a new object or there was no touched fields to update.'
+            log.warning(message)
 
         return self.obj, new_model_obj_was_created

django_spire/contrib/service/exceptions.py

@@ -1,5 +1,7 @@
-from django_spire.exceptions import DjangoSpireException
+from __future__ import annotations
 
+from django_spire.exceptions import DjangoSpireError
 
-class ServiceException(DjangoSpireException):
-    pass
+
+class ServiceError(DjangoSpireError):
+    pass