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

django_spire/contrib/seeding/intelligence/intel.py

@@ -1,10 +1,14 @@
+from __future__ import annotations
+
+from typing import Iterator
+
 from dandy import BaseIntel
 
 
 class SeedingIntel(BaseIntel):
     items: list[dict]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[dict]:
         return iter(self.items)
 
 

django_spire/contrib/seeding/intelligence/prompts/factory.py

@@ -1,7 +1,12 @@
-from django.db.models.base import Model
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from dandy import Prompt
 
+if TYPE_CHECKING:
+    from django.db.models.base import Model
+
 
 class SeedingModelClassPromptFactory:
 

django_spire/contrib/seeding/intelligence/prompts/foreign_key_selection_prompt.py

@@ -1,7 +1,12 @@
-from django.db.models import Model
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from dandy import Prompt
 
+if TYPE_CHECKING:
+    from django.db.models import Model
+
 
 def foreign_key_selection_prompt(
     model_class: type[Model],

django_spire/contrib/seeding/intelligence/prompts/generate_django_model_seeder_prompts.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 
 from dandy import Prompt

django_spire/contrib/seeding/intelligence/prompts/generic_relationship_selection_prompt.py

@@ -1,8 +1,14 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import Model
 
 from dandy import Prompt
 
+if TYPE_CHECKING:
+    from django.db.models import Model
+
 
 def generic_relationship_selection_prompt(
     model_class: type[Model],

django_spire/contrib/seeding/intelligence/prompts/hierarchical_selection_prompt.py

@@ -1,9 +1,13 @@
-from random import shuffle
+from __future__ import annotations
 
-from django.db.models import Model
+from random import shuffle
+from typing import TYPE_CHECKING
 
 from dandy import Prompt
 
+if TYPE_CHECKING:
+    from django.db.models import Model
+
 
 def hierarchical_selection_prompt(
     model_class: type[Model],

django_spire/contrib/seeding/intelligence/prompts/model_field_choices_prompt.py

@@ -1,6 +1,12 @@
+from __future__ import annotations
+
 from dandy import Prompt
-from django.db.models.enums import TextChoices
-from django.db.models.fields import Field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from django.db.models.fields import Field
+    from django.db.models.enums import TextChoices
 
 
 def model_field_choices_prompt(

django_spire/contrib/seeding/intelligence/prompts/negation_prompt.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dandy import Prompt
 
 

django_spire/contrib/seeding/intelligence/prompts/objective_prompt.py

@@ -1,7 +1,12 @@
-from django.db.models import Model
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from dandy import Prompt
 
+if TYPE_CHECKING:
+    from django.db.models import Model
+
 
 def objective_prompt(
     model_class: type[Model],

django_spire/contrib/seeding/management/commands/seeding.py

@@ -1,12 +1,18 @@
+from __future__ import annotations
+
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from django.core.management.base import BaseCommand, CommandError
 
 from dandy.conf import settings
-from dandy.recorder import recorder_to_html_file
 
 from django_spire.contrib.seeding.intelligence.bots.seeder_generator_bot import SeederGeneratorBot
 
+if TYPE_CHECKING:
+    from argparse import ArgumentParser
+    from typing import Any
+
 
 _SEEDING_OUTPUT_PATH = Path(settings.BASE_PATH, '.seeding_generator_output')
 
@@ -14,7 +20,7 @@ _SEEDING_OUTPUT_PATH = Path(settings.BASE_PATH, '.seeding_generator_output')
 class Command(BaseCommand):
     help = 'Generate a Seeder'
 
-    def add_arguments(self, parser):
+    def add_arguments(self, parser: ArgumentParser) -> None:
         parser.add_argument(
             'model_import',
             type=str,
@@ -29,7 +35,7 @@ class Command(BaseCommand):
         )
 
     # @recorder_to_html_file('seeding_generator')
-    def handle(self, *args, **kwargs):
+    def handle(self, *args: Any, **kwargs: Any) -> None:
         if not kwargs['model_import'] or not kwargs['model_description']:
             message = 'You must provide a model import path and a model description'
             raise CommandError(message)

django_spire/contrib/seeding/management/example.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django_spire.contrib.seeding import DjangoModelSeeder
 from django_spire.contrib.seeding.model.django.tests.test_seeder import Product
 

django_spire/contrib/seeding/model/base.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
 from dandy.recorder import recorder_to_html_file
 from dandy import SqliteCache, generate_cache_key
@@ -6,12 +9,15 @@ from dandy import SqliteCache, generate_cache_key
 from django_spire.contrib.seeding.field.override import FieldOverride
 from django_spire.contrib.seeding.model.config import FieldsConfig
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class classproperty:
-    def __init__(self, fget):
+    def __init__(self, fget: Any) -> None:
         self.fget = fget
 
-    def __get__(self, instance, owner):
+    def __get__(self, instance: Any, owner: Any) -> Any:
         return self.fget(owner)
 
 
@@ -33,30 +39,33 @@ class BaseModelSeeder(ABC):
     _field_config: FieldsConfig = None
 
     @classproperty
-    def override(cls):
+    def override(cls) -> FieldOverride:
         return cls.override_class(seeder_class=cls)
 
     @classmethod
     def get_field_config(cls) -> FieldsConfig:
         if cls._field_config is None:
             if cls.model_class is None:
-                raise ValueError('model_class must be defined before using seeder.')
+                message = 'model_class must be defined before using seeder.'
+                raise ValueError(message)
 
             raw_fields = cls.__dict__.get('fields', {})
+
             cls._field_config = cls.field_config_class(
                 raw_fields=raw_fields,
                 field_names=cls.field_names(),
                 default_to=cls.default_to,
                 model_class=cls.model_class,
             )
+
         return cls._field_config
 
     @classmethod
-    def resolved_fields(cls):
+    def resolved_fields(cls) -> dict:
         return cls.get_field_config().fields
 
     @classmethod
-    def clear_cache(cls):
+    def clear_cache(cls) -> None:
         SqliteCache.clear(cache_name=cls.cache_name)
 
     @classmethod
@@ -68,7 +77,7 @@ class BaseModelSeeder(ABC):
     @recorder_to_html_file('model_seeder')
     def seed_data(
         cls,
-        count=1,
+        count: int = 1,
         fields: dict | None = None,
     ) -> list[dict]:
         field_config = (

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'