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

django_spire/contrib/queryset/tests/test_queryset.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.db.models import QuerySet
+from django.test import RequestFactory, TestCase
+
+from django_spire.contrib.queryset.enums import SessionFilterActionEnum
+from django_spire.contrib.queryset.filter_tools import filter_by_lookup_map
+from django_spire.contrib.queryset.mixins import SearchQuerySetMixin, SessionFilterQuerySetMixin
+
+
+class TestSessionFilterActionEnum(TestCase):
+    def test_clear_value(self) -> None:
+        assert SessionFilterActionEnum.CLEAR == 'Clear'
+
+    def test_filter_value(self) -> None:
+        assert SessionFilterActionEnum.FILTER == 'Filter'
+
+    def test_is_str_enum(self) -> None:
+        assert isinstance(SessionFilterActionEnum.CLEAR, str)
+        assert isinstance(SessionFilterActionEnum.FILTER, str)
+
+
+class TestFilterByLookupMap(TestCase):
+    def setUp(self) -> None:
+        self.queryset = MagicMock(spec=QuerySet)
+        self.queryset.filter.return_value = self.queryset
+
+    def test_applies_filter_from_lookup_map(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test'}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_extra_filters_applied(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test'}
+        extra_filters = {'is_active': True}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data, extra_filters)
+
+        self.queryset.filter.assert_called_once_with(
+            name__icontains='test',
+            is_active=True
+        )
+
+    def test_extra_filters_defaults_to_empty_dict(self) -> None:
+        lookup_map = {}
+        data = {}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with()
+
+    def test_ignores_empty_string_values(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'email': 'email__icontains'}
+        data = {'name': 'test', 'email': ''}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_ignores_keys_not_in_lookup_map(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test', 'other': 'value'}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_ignores_none_values(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'email': 'email__icontains'}
+        data = {'name': 'test', 'email': None}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_ignores_empty_list_values(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'tags': 'tags__in'}
+        data = {'name': 'test', 'tags': []}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_multiple_filters_applied(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'status': 'status'}
+        data = {'name': 'test', 'status': 'active'}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(
+            name__icontains='test',
+            status='active'
+        )
+
+    def test_returns_filtered_queryset(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test'}
+
+        result = filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        assert result == self.queryset
+
+
+class TestSessionFilterQuerySetMixin(TestCase):
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
+    def _create_request_with_session(self, path: str = '/', data: dict | None = None):
+        request = self.factory.get(path, data or {})
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        return request
+
+    def test_has_bulk_filter_abstract_method(self) -> None:
+        assert hasattr(SessionFilterQuerySetMixin, 'bulk_filter')
+
+    def test_has_process_session_filter_method(self) -> None:
+        assert hasattr(SessionFilterQuerySetMixin, 'process_session_filter')
+
+    def test_is_queryset_subclass(self) -> None:
+        assert issubclass(SessionFilterQuerySetMixin, QuerySet)
+
+
+class TestSearchQuerySetMixin(TestCase):
+    def test_has_search_abstract_method(self) -> None:
+        assert hasattr(SearchQuerySetMixin, 'search')
+
+    def test_is_queryset_subclass(self) -> None:
+        assert issubclass(SearchQuerySetMixin, QuerySet)

django_spire/contrib/seeding/field/base.py

@@ -1,24 +1,30 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
 from django_spire.contrib.seeding.field.cleaners import normalize_seeder_fields
 from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class BaseFieldSeeder(ABC):
     keyword: str = None
     seed_keywords = FieldSeederTypesEnum._value2member_map_.keys()
 
     def __init__(
-            self,
-            fields: dict = None,
-            default_to: str = "llm"
-    ):
+        self,
+        fields: dict | None = None,
+        default_to: str = 'llm'
+    ) -> None:
 
         self.fields = self._normalize_fields(fields or {})
         self.default_to = default_to
 
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
 
         if cls.keyword is None:
@@ -35,9 +41,9 @@ class BaseFieldSeeder(ABC):
         }
 
     @property
-    def seeder_fields(self):
+    def seeder_fields(self) -> dict:
         return self.filter_fields(self.keyword)
 
     @abstractmethod
-    def seed(self, model_seeder_cls, count: int):
+    def seed(self, model_seeder_cls: Any, count: int) -> list[dict]:
         pass

django_spire/contrib/seeding/field/callable.py

@@ -1,11 +1,18 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django_spire.contrib.seeding.field.base import BaseFieldSeeder
 from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class CallableFieldSeeder(BaseFieldSeeder):
     keyword = FieldSeederTypesEnum.CALLABLE
 
-    def seed(self, manager = None, count = 1) -> list[dict]:
+    def seed(self, manager: Any = None, count: int = 1) -> list[dict]:
         return [
             {field_name: func[1]() for field_name, func in self.seeder_fields.items()}
             for _ in range(count)

django_spire/contrib/seeding/field/cleaners.py

@@ -1,7 +1,10 @@
-from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
+from __future__ import annotations
 
 import copy
 
+from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
+
+
 def normalize_seeder_fields(fields: dict) -> dict:
     normalized = {}
 
@@ -21,14 +24,11 @@ def normalize_seeder_fields(fields: dict) -> dict:
                 else:
                     extra = (extra_value,)
 
-            normalized[k] = (v[0],) + v[1:2] + extra
-
+            normalized[k] = (v[0], *v[1:2], *extra)
         elif callable(v):
             normalized[k] = ("callable", v)
-
         elif isinstance(v, str) and v.lower() in FieldSeederTypesEnum._value2member_map_:
             normalized[k] = (v.lower(),)
-
         else:
             normalized[k] = ("static", v)
 

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