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

django_spire/contrib/seeding/field/custom.py

@@ -1,36 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django.utils import timezone
 from faker import Faker
 
 from django_spire.contrib.seeding.field.base import BaseFieldSeeder
 from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
 
+if TYPE_CHECKING:
+    from datetime import datetime
+    from typing import Any
+
+    from django.db.models import Model
+
 
 class CustomFieldSeeder(BaseFieldSeeder):
     keyword = FieldSeederTypesEnum.CUSTOM
 
-    def in_order(self, values: list, index: int) -> any:
+    def in_order(self, values: list, index: int) -> Any:
         if not values:
-            raise ValueError(
-                "Cannot select from empty values list. "
-                "Make sure the related model has existing records before seeding foreign keys."
-            )
-        index = index % len(values)  # Index loops back on itself
+            message = 'Cannot select from empty values list. Make sure the related model has existing records before seeding foreign keys.'
+            raise ValueError(message)
+
+        # Index loops back on itself
+        index = index % len(values)
         return values[index]
 
-    def date_time_between(self, start_date: str, end_date: str):
+    def date_time_between(self, start_date: str, end_date: str) -> datetime:
         faker = Faker()
         naive_dt = faker.date_time_between(start_date=start_date, end_date=end_date)
         return timezone.make_aware(naive_dt)
 
-    def fk_random(self, model_class, ids: list[int]):
+    def fk_random(self, model_class: type[Model], ids: list[int]) -> int:
         faker = Faker()
         return faker.random_element(elements=ids)
 
-    def fk_in_order(self, model_class, index: int, ids: list[int]):
+    def fk_in_order(self, model_class: type[Model], index: int, ids: list[int]) -> int:
         """Takes a queryset, calls it then returns a random id"""
         return self.in_order(values=ids, index=index)
 
-    def seed(self, manager, count) -> list[dict]:
+    def seed(self, manager: Any, count: int) -> list[dict]:
         data = []
 
         foreign_keys = {}

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

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from dandy import BaseIntel, Prompt
 
 from django_spire.core.converters import django_to_pydantic_model, fake_model_field_value
@@ -7,11 +9,14 @@ from django_spire.contrib.seeding.field.base import BaseFieldSeeder
 from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
 from django_spire.contrib.seeding.intelligence.bots.field_seeding_bots import LlmFieldSeedingBot
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class DjangoFieldLlmSeeder(BaseFieldSeeder):
     keyword = FieldSeederTypesEnum.LLM
 
-    def seed(self, model_seeder, count: int = 1,) -> list[dict]:
+    def seed(self, model_seeder: Any, count: int = 1) -> list[dict]:
 
         include_fields = list(self.seeder_fields.keys())
 
@@ -31,10 +36,7 @@ class DjangoFieldLlmSeeder(BaseFieldSeeder):
         base_prompt = (
             Prompt()
             .heading('General Seeding Rules')
-            .list(
-                [
-                    'Create data for each field provided.'
-                ])
+            .list(['Create data for each field provided.'])
             .heading('Field Rules & Context')
             .prompt(self.field_prompt)
         )
@@ -115,7 +117,7 @@ class DjangoFieldLlmSeeder(BaseFieldSeeder):
 class DjangoFieldFakerSeeder(BaseFieldSeeder):
     keyword = FieldSeederTypesEnum.FAKER
 
-    def seed(self, model_seeder, count = 1) -> list[dict]:
+    def seed(self, model_seeder: Any, count: int = 1) -> list[dict]:
         data = []
 
         for _ in range(count):

django_spire/contrib/seeding/field/enums.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 from enum import Enum
 
 
 class FieldSeederTypesEnum(str, Enum):
-    LLM = "llm"
-    FAKER = "faker"
-    STATIC = "static"
-    CALLABLE = "callable"
-    CUSTOM = "custom"
+    LLM = 'llm'
+    FAKER = 'faker'
+    STATIC = 'static'
+    CALLABLE = 'callable'
+    CUSTOM = 'custom'

django_spire/contrib/seeding/field/override.py

@@ -1,18 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
 class FieldOverride:
-    def __init__(self, seeder_class):
+    def __init__(self, seeder_class: Any) -> None:
         self.seeder_class = seeder_class
         self.overrides = {}
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Any:
         """
         Delegate attribute lookup to self.seeder_class if the attribute isn't found
         in this FieldOverride instance.
         """
 
         attr = getattr(self.seeder_class, name)
+
         if callable(attr):
-            def wrapper(*args, **kwargs):
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
                 # TODO: Error here if fields is passed as an arg.
+
                 # Pass the overrides field to the seed method
                 if 'fields' in kwargs and isinstance(kwargs['fields'], dict):
                     kwargs['fields'] = {**kwargs['fields'], **self.overrides}
@@ -22,12 +32,12 @@ class FieldOverride:
                 return attr(*args, **kwargs)
 
             return wrapper
+
         return attr
 
-    def filter(self, **kwargs):
+    def filter(self, **kwargs: Any) -> FieldOverride:
         self.overrides.update(kwargs)
         return self
 
-    def seed(self, count=1):
+    def seed(self, count: int = 1) -> list:
         return self.seeder_class.seed(count=count, fields=self.overrides)
-

django_spire/contrib/seeding/field/static.py

@@ -1,10 +1,17 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django_spire.contrib.seeding.field.base import BaseFieldSeeder
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class StaticFieldSeeder(BaseFieldSeeder):
-    keyword = "static"
+    keyword = 'static'
 
-    def seed(self, manager = None, count = 1) -> list:
+    def seed(self, manager: Any = None, count: int = 1) -> list[dict]:
         return [
             {field_name: value[1] for field_name, value in self.seeder_fields.items()}
             for _ in range(count)

django_spire/contrib/seeding/field/tests/test_base.py

@@ -1,24 +1,28 @@
-import unittest
+from __future__ import annotations
+
+from django.test import TestCase
+
 from django_spire.contrib.seeding.field.base import BaseFieldSeeder
 
 
 class DummyFieldSeeder(BaseFieldSeeder):
-    keyword = "faker"
-
-    def seed(self, model_seeder_cls=None, count: int = 1):
-        return [{"fake": True} for _ in range(count)]
+    keyword = 'faker'
 
+    def seed(self, model_seeder_cls=None, count: int = 1) -> list[dict]:
+        return [{'fake': True} for _ in range(count)]
 
-class TestBaseFieldSeeder(unittest.TestCase):
 
-    def test_filter_fields(self):
+class TestBaseFieldSeeder(TestCase):
+    def test_filter_fields(self) -> None:
         fields = {
-            "name": ("faker", "name"),
-            "email": ("faker", "email"),
-            "description": ("llm", "prompt")
+            'name': ('faker', 'name'),
+            'email': ('faker', 'email'),
+            'description': ('llm', 'prompt')
         }
         seeder = DummyFieldSeeder(fields=fields)
-        faker_fields = seeder.filter_fields("faker")
-        self.assertIn("name", faker_fields)
-        self.assertIn("email", faker_fields)
-        self.assertNotIn("description", faker_fields)
+
+        faker_fields = seeder.filter_fields('faker')
+
+        assert 'name' in faker_fields
+        assert 'email' in faker_fields
+        assert 'description' not in faker_fields

django_spire/contrib/seeding/field/tests/test_callable.py

@@ -1,18 +1,22 @@
-import unittest
-from django_spire.contrib.seeding.field.callable import CallableFieldSeeder
+from __future__ import annotations
+
+from django.test import TestCase
 
+from django_spire.contrib.seeding.field.callable import CallableFieldSeeder
 
-class TestCallableFieldSeeder(unittest.TestCase):
 
-    def test_seeds_callable_fields(self):
+class TestCallableFieldSeeder(TestCase):
+    def test_seeds_callable_fields(self) -> None:
         fields = {
-            "timestamp": lambda: "2024-01-01 12:00:00",
-            "status": lambda: "active"
+            'timestamp': lambda: '2024-01-01 12:00:00',
+            'status': lambda: 'active'
         }
         seeder = CallableFieldSeeder(fields=fields)
+
         result = seeder.seed(None, count=3)
 
-        self.assertEqual(len(result), 3)
+        assert len(result) == 3
+
         for row in result:
-            self.assertEqual(row["timestamp"], "2024-01-01 12:00:00")
-            self.assertEqual(row["status"], "active")
+            assert row['timestamp'] == '2024-01-01 12:00:00'
+            assert row['status'] == 'active'

django_spire/contrib/seeding/field/tests/test_cleaners.py

@@ -1,61 +1,74 @@
-import unittest
+from __future__ import annotations
+
 from copy import copy
+
+from django.test import TestCase
+
 from django_spire.contrib.seeding.field.cleaners import normalize_seeder_fields
 
 
 FIELDS = {
-    "faker_tuple": ("faker", "name"),
-    "llm_type": "llm",
-    "faker_type": "faker",
-    "static_type": "static",
-    "callable_type": "callable",
-    "custom_type": "custom",
-    "static_bool": True,
-    "static_str": "approved",
-    "static_int": 10,
-    "callable_func": lambda: "now",
-    "exclude_str": "exclude",
-    "exclude_tuple": ("exclude",)
+    'faker_tuple': ('faker', 'name'),
+    'llm_type': 'llm',
+    'faker_type': 'faker',
+    'static_type': 'static',
+    'callable_type': 'callable',
+    'custom_type': 'custom',
+    'static_bool': True,
+    'static_str': 'approved',
+    'static_int': 10,
+    'callable_func': lambda: 'now',
+    'exclude_str': 'exclude',
+    'exclude_tuple': ('exclude',)
 }
 
 
-class TestNormalizeSeederFields(unittest.TestCase):
+class TestNormalizeSeederFields(TestCase):
+    def test_excludes_fields(self) -> None:
+        fields = copy(FIELDS)
 
-    def test_normalizes_faker_tuple(self):
-        fields = {"faker_tuple": FIELDS["faker_tuple"]}
         normalized = normalize_seeder_fields(fields)
-        self.assertEqual(normalized["faker_tuple"], ("faker", "name"))
 
-    def test_excludes_fields(self):
-        fields = copy(FIELDS)
+        assert 'exclude_str' not in normalized
+        assert 'exclude_tuple' not in normalized
+        assert 'static_str' in normalized
+
+    def test_normalizes_callable(self) -> None:
+        fields = {'callable_func': FIELDS['callable_func']}
+
+        normalized = normalize_seeder_fields(fields)
+
+        assert normalized['callable_func'][0] == 'callable'
+        assert callable(normalized['callable_func'][1])
+
+    def test_normalizes_faker_tuple(self) -> None:
+        fields = {'faker_tuple': FIELDS['faker_tuple']}
+
         normalized = normalize_seeder_fields(fields)
-        self.assertNotIn("exclude_str", normalized)
-        self.assertNotIn("exclude_tuple", normalized)
-        self.assertIn("static_str", normalized)
 
-    def test_normalizes_single_value_strings_to_tuples(self):
+        assert normalized['faker_tuple'] == ('faker', 'name')
+
+    def test_normalizes_single_value_strings_to_tuples(self) -> None:
         fields = {
             k: FIELDS[k] for k in (
-                "llm_type", "faker_type", "static_type", "callable_type", "custom_type"
+                'llm_type', 'faker_type', 'static_type', 'callable_type', 'custom_type'
             )
         }
-        normalized = normalize_seeder_fields(fields)
-        for key, value in fields.items():
-            self.assertEqual(normalized[key], (value,))
 
-    def test_normalizes_callable(self):
-        fields = {"callable_func": FIELDS["callable_func"]}
         normalized = normalize_seeder_fields(fields)
-        self.assertEqual(normalized["callable_func"][0], "callable")
-        self.assertTrue(callable(normalized["callable_func"][1]))
 
-    def test_normalizes_static_values(self):
+        for key, value in fields.items():
+            assert normalized[key] == (value,)
+
+    def test_normalizes_static_values(self) -> None:
         fields = {
-            "static_bool": FIELDS["static_bool"],
-            "static_str": FIELDS["static_str"],
-            "static_int": FIELDS["static_int"]
+            'static_bool': FIELDS['static_bool'],
+            'static_str': FIELDS['static_str'],
+            'static_int': FIELDS['static_int']
         }
+
         normalized = normalize_seeder_fields(fields)
-        self.assertEqual(normalized["static_bool"], ("static", True))
-        self.assertEqual(normalized["static_str"], ("static", "approved"))
-        self.assertEqual(normalized["static_int"], ("static", 10))
+
+        assert normalized['static_bool'] == ('static', True)
+        assert normalized['static_str'] == ('static', 'approved')
+        assert normalized['static_int'] == ('static', 10)

django_spire/contrib/seeding/field/tests/test_static.py

@@ -1,18 +1,22 @@
-import unittest
-from django_spire.contrib.seeding.field.static import StaticFieldSeeder
+from __future__ import annotations
+
+from django.test import TestCase
 
+from django_spire.contrib.seeding.field.static import StaticFieldSeeder
 
-class TestStaticFieldSeeder(unittest.TestCase):
 
-    def test_seeds_static_fields(self):
+class TestStaticFieldSeeder(TestCase):
+    def test_seeds_static_fields(self) -> None:
         fields = {
-            "category": ("static", "books"),
-            "in_stock": ("static", True)
+            'category': ('static', 'books'),
+            'in_stock': ('static', True)
         }
         seeder = StaticFieldSeeder(fields=fields)
+
         result = seeder.seed(count=3)
 
-        self.assertEqual(len(result), 3)
+        assert len(result) == 3
+
         for row in result:
-            self.assertEqual(row["category"], "books")
-            self.assertEqual(row["in_stock"], True)
+            assert row['category'] == 'books'
+            assert row['in_stock'] is True

django_spire/contrib/seeding/intelligence/bots/seeder_generator_bot.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dandy import Bot, LlmConfigOptions
 
 from django_spire.contrib.seeding.intelligence.intel import SourceIntel

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 = (