django-spire 0.23.4__py3-none-any.whl

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

@@ -0,0 +1,17 @@
+from dandy import Prompt
+from django.db.models.enums import TextChoices
+from django.db.models.fields import Field
+
+
+def model_field_choices_prompt(
+    model_field: Field,
+    choices: TextChoices
+) -> Prompt:
+    model_name = model_field.field.model.__name__
+    field_name = model_field.field.name
+    return (
+        Prompt()
+        .heading(f'Generate values for {field_name} in {model_name} model')
+        .text(f'The value for the {field_name} field should only be selected from the following list of choices.')
+        .list([choice[0] for choice in choices])
+    )

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

@@ -0,0 +1,12 @@
+from dandy import Prompt
+
+
+def negation_prompt(
+    negation_rules: list[str]
+) -> Prompt:
+    return (
+        Prompt()
+        .text('This step is mission critical. Do NOT deviate from this requirement.')
+        .text('The following are strictly reserved and must never be used under any circumstances:')
+        .list(negation_rules)
+    )

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

@@ -0,0 +1,17 @@
+from django.db.models import Model
+
+from dandy import Prompt
+
+
+def objective_prompt(
+    model_class: type[Model],
+    model_description: str,
+    sector_description: str,
+) -> Prompt:
+    model_name = model_class._meta.verbose_name_plural.title()
+
+    return (
+        Prompt()
+        .text(f'You are generating "{model_name}" that are described as "{model_description}".')
+        .text(f'These {model_name} represent entities in our "{sector_description}" system.')
+    )

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

@@ -0,0 +1,49 @@
+from pathlib import Path
+
+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
+
+
+_SEEDING_OUTPUT_PATH = Path(settings.BASE_PATH, '.seeding_generator_output')
+
+
+class Command(BaseCommand):
+    help = 'Generate a Seeder'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'model_import',
+            type=str,
+            help='The import path to the Django model class',
+        )
+
+        parser.add_argument(
+            'model_description',
+            type=str,
+            help='A small descript of the model',
+            nargs='+',
+        )
+
+    # @recorder_to_html_file('seeding_generator')
+    def handle(self, *args, **kwargs):
+        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)
+
+        model_import = kwargs['model_import']
+        model_description = ' '.join(kwargs['model_description'])
+
+        # Instantiate the bot
+        bot = SeederGeneratorBot()
+        source_intel = bot.process(model_import, model_description)
+
+        Path(_SEEDING_OUTPUT_PATH).mkdir(parents=True, exist_ok=True)
+
+        with open(Path(_SEEDING_OUTPUT_PATH, source_intel.file_name), 'w') as f:
+            f.write(source_intel.python_source_code)
+
+        self.stdout.write(f'Done ... saved to "{Path(_SEEDING_OUTPUT_PATH, source_intel.file_name)}"')

django_spire/contrib/seeding/management/example.py

@@ -0,0 +1,17 @@
+from django_spire.contrib.seeding import DjangoModelSeeder
+from django_spire.contrib.seeding.model.django.tests.test_seeder import Product
+
+
+class ProductSeeder(DjangoModelSeeder):
+    model_class = Product
+
+    fields = {
+        'id': 'exclude',
+        'name': ('llm', 'Shirts for a upper end mens clothing store'),
+        'sku': 'llm',
+        'description': 'llm',
+        'price': ('faker', 'pydecimal', {'left_digits': 2, 'right_digits': 2, 'positive': True}),
+        'in_stock': True,
+        'created_at': ('custom', 'date_time_between', {'start_date': '-30d', 'end_date': 'now'}),
+        'updated_at': 'exclude',
+    }

django_spire/contrib/seeding/model/base.py

@@ -0,0 +1,119 @@
+from abc import ABC, abstractmethod
+
+from dandy.recorder import recorder_to_html_file
+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
+
+
+class classproperty:
+    def __init__(self, fget):
+        self.fget = fget
+
+    def __get__(self, instance, owner):
+        return self.fget(owner)
+
+
+class BaseModelSeeder(ABC):
+    model_class = None
+
+    fields = None
+    field_config_class = FieldsConfig
+
+    default_to = 'llm'
+
+    cache_seed = True
+    cache_name = 'model_seeder'
+    cache_limit = 1000
+
+    override_class = FieldOverride
+
+    _field_seeders = []
+    _field_config: FieldsConfig = None
+
+    @classproperty
+    def override(cls):
+        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.')
+
+            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):
+        return cls.get_field_config().fields
+
+    @classmethod
+    def clear_cache(cls):
+        SqliteCache.clear(cache_name=cls.cache_name)
+
+    @classmethod
+    @abstractmethod
+    def field_names(cls) -> list[str]:
+        pass
+
+    @classmethod
+    @recorder_to_html_file('model_seeder')
+    def seed_data(
+        cls,
+        count=1,
+        fields: dict | None = None,
+    ) -> list[dict]:
+        field_config = (
+            cls.get_field_config().override(fields)
+            if fields
+            else cls.get_field_config()
+        )
+
+        if cls.cache_seed:
+            cache_key = generate_cache_key(
+                cls.seed_data, count=count, fields=field_config.fields
+            )
+
+            cache = SqliteCache(cache_name=cls.cache_name, limit=cls.cache_limit)
+            formatted_seed_data = cache.get(cache_key)
+
+            if formatted_seed_data:
+                return formatted_seed_data
+
+        seed_data = []
+
+        for seeder_cls in cls._field_seeders:
+            seeder = seeder_cls(field_config.fields, field_config.default_to)
+
+            if len(seeder.seeder_fields) > 0:
+                seed_data.append(seeder.seed(cls, count))
+
+        formatted_seed_data = [
+            {} for _ in range(max(len(sublist) for sublist in seed_data))
+        ]
+        for sublist in seed_data:
+            for i, d in enumerate(sublist):
+                formatted_seed_data[i].update(d)
+
+        if cls.cache_seed:
+            cache.set(cache_key, formatted_seed_data)
+
+        return formatted_seed_data
+
+    @classmethod
+    def seed(
+        cls,
+        count: int = 1,
+        fields: dict | None = None,
+    ) -> list:
+        return [
+            cls.model_class(**seed_data) for seed_data in cls.seed_data(count, fields)
+        ]

django_spire/contrib/seeding/model/config.py

@@ -0,0 +1,64 @@
+from django_spire.contrib.seeding.field.cleaners import normalize_seeder_fields
+from django_spire.contrib.seeding.model.enums import ModelSeederDefaultsEnum
+
+
+class FieldsConfig:
+    def __init__(
+            self,
+            raw_fields: dict,
+            field_names: list[str],
+            default_to: str,
+            model_class
+    ):
+        self.raw_fields = raw_fields or {}
+        self.default_to = default_to
+        self.field_names = set(field_names)
+        self.model_class = model_class
+
+        self._excluded = {
+            k for k, v in self.raw_fields.items()
+            if v == "exclude" or v == ("exclude",)
+        }
+
+        self.fields = normalize_seeder_fields({
+            k: v for k, v in self.raw_fields.items() if k not in self._excluded
+        })
+
+        self._validate()
+        self._assign_defaults()
+        self._order_fields() # Fields need to be in order for caching hash
+
+    def _validate(self):
+        unknown = set(self.fields.keys()) - self.field_names
+        if unknown:
+            raise ValueError(f"Invalid field name(s): {', '.join(unknown)}")
+
+    def _assign_defaults(self):
+        if self.default_to == ModelSeederDefaultsEnum.INCLUDED:
+            return
+
+        method = self.default_to.lower()
+
+        for name in self.field_names:
+            if name not in self.fields and name not in self._excluded:
+                self.fields[name] = (method,)
+
+    def override(self, overrides: dict):
+        merged = {**self.fields, **normalize_seeder_fields(overrides)}
+        new_raw = {
+            **{k: v for k, v in self.raw_fields.items() if k in self._excluded},
+            **merged
+        }
+        return self.__class__(
+            raw_fields=new_raw,
+            field_names=list(self.field_names),
+            default_to=self.default_to,
+            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])}
+
+    @property
+    def excluded(self):
+        return self._excluded

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

@@ -0,0 +1,58 @@
+from django_spire.contrib.seeding.model.config import FieldsConfig
+
+
+class DjangoModelFieldsConfig(FieldsConfig):
+
+    def _validate(self):
+        valid_field_names = set(self.field_names)
+
+        valid_field_names.update(f.attname for f in self.model_class._meta.fields)
+
+        unknown = set(self.fields.keys()) - valid_field_names
+
+        if unknown:
+            raise ValueError(f"Invalid field name(s): {', '.join(unknown)}")
+
+        # 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 = {
+    #         f.name: f.attname  # f.attname = "user_id"
+    #         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
+    #             else:
+    #                 translated_fields[translated_name] = value
+    #         else:
+    #             translated_fields[name] = value
+    #
+    #     return translated_fields
+    #
+    #     # Update self.fields.
+    #
+    #

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

@@ -0,0 +1,62 @@
+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_spire.contrib.seeding.field.callable import CallableFieldSeeder
+from django_spire.contrib.seeding.field.custom import CustomFieldSeeder
+from django_spire.contrib.seeding.field.django.seeder import DjangoFieldFakerSeeder, DjangoFieldLlmSeeder
+from django_spire.contrib.seeding.field.static import StaticFieldSeeder
+from django_spire.contrib.seeding.model.base import BaseModelSeeder
+from django_spire.contrib.seeding.model.django.config import DjangoModelFieldsConfig
+
+if TYPE_CHECKING:
+    from dandy import Prompt
+
+
+TypeModel = TypeVar('TypeModel', bound=Model)
+
+
+class DjangoModelSeeder(BaseModelSeeder):
+    field_config_class = DjangoModelFieldsConfig
+
+    model_class: type[Model]
+    prompt: Prompt = None
+    _field_seeders = [
+        CustomFieldSeeder,
+        CallableFieldSeeder,
+        StaticFieldSeeder,
+        DjangoFieldFakerSeeder,
+        DjangoFieldLlmSeeder
+    ]
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if cls.model_class is None:
+            message = "Seeds must have a model class"
+            raise ValueError(message)
+
+        if cls.fields is None:
+            message = "Seeds must have fields"
+            raise ValueError(message)
+
+    @classmethod
+    def field_names(cls) -> list[str]:
+        # All foreign keys must be _id
+        return [
+            f.attname if isinstance(f, ForeignKey) else f.name
+            for f in cls.model_class._meta.fields
+        ]
+
+    @classmethod
+    def seed_database(
+        cls,
+        count=1,
+        fields: dict | None = None
+    ) -> list[TypeModel]:
+        model_objects = cls.seed(count, fields)
+        return cls.model_class.objects.bulk_create(model_objects)

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

@@ -0,0 +1,53 @@
+import unittest
+from django.db import models
+from django.utils.timezone import now
+
+from django_spire.contrib.seeding import DjangoModelSeeder
+
+
+class Product(models.Model):
+    name = models.CharField(max_length=100)
+    description = models.TextField()
+    sku = models.CharField(max_length=20, unique=True)
+    price = models.DecimalField(max_digits=6, decimal_places=2)
+    in_stock = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        app_label = "tests"
+        managed = False
+
+
+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',
+    }
+
+
+class TestProductSeeder(unittest.TestCase):
+
+    def test_assign_defaults(self):
+        self.assertIn('sku', ProductSeeder.resolved_fields().keys())
+
+    def test_seeds_three_objects(self):
+        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))
+
+    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)

django_spire/contrib/seeding/model/enums.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ModelSeederDefaultsEnum(str, Enum):
+    LLM = "llm"
+    FAKER = "faker"
+    INCLUDED = "included"
+

django_spire/contrib/seeding/tests/test_seeding.py

@@ -0,0 +1,25 @@
+# from dandy import Prompt
+# from django.test import TestCase
+#
+# from django_spire.seeding.processor import SeedingProcessor
+# from django_spire.seeding.models import PersonSeedingModel
+#
+#
+# class SeedingTestCase(TestCase):
+#     def setUp(self):
+#         self.person_seed_processor = SeedingProcessor(
+#             model_class=PersonSeedingModel,
+#             seeding_prompt=(
+#                 Prompt()
+#                 .text('Create a bunch of unique people to be used for seeding.')
+#             ),
+#             count=5,
+#             exclude_fields=['phone_number'],
+#         )
+#
+#     def tearDown(self):
+#         pass
+#
+#     def test_seeding_helper_intel_class(self):
+#         person_intel_class = self.person_seed_processor.build_intel_class()
+#

django_spire/contrib/service/__init__.py

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

django_spire/contrib/service/django_model_service.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC
+from typing import Type, 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
+
+TypeDjangoModel = TypeVar('TypeDjangoModel', bound=Model, covariant=True)
+
+
+class BaseDjangoModelService(
+    BaseDjangoModelConstructor[TypeDjangoModel],
+    ABC,
+    Generic[TypeDjangoModel]
+):
+    def _get_concrete_fields(self) -> dict:
+        return {
+            field.name: field
+            for field in self.obj._meta.get_fields()
+            if field.concrete and not field.many_to_many and not field.one_to_many
+        }
+
+    def _get_touched_fields(self, concrete_fields: dict, **field_data: dict) -> list[str]:
+        foreign_key_id_aliases = {f"{name}_id" for name, field in concrete_fields.items() if field.many_to_one}
+        allowed = set(concrete_fields) | foreign_key_id_aliases
+
+        touched_fields: list[str] = []
+
+        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__}')
+                continue
+
+            model_field = concrete_fields.get(field.removesuffix("_id"), None)
+
+            if model_field and (getattr(model_field, 'auto_created', False) or not model_field.editable):
+                continue
+
+            setattr(self.obj, field, value)
+
+            touched_fields.append(field.removesuffix('_id'))
+
+        return touched_fields
+
+    def validate_model_obj(self, **field_data: dict) -> list[str]:
+        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
+
+        return touched_fields
+
+    @transaction.atomic
+    def save_model_obj(self, **field_data: dict) -> tuple[Model, bool]:
+        new_model_obj_was_created = False
+
+        if not field_data:
+            raise ServiceException(f'Field data is required to save on {self.obj.__class__.__name__}')
+
+        touched_fields = self.validate_model_obj(**field_data)
+
+        if self.model_obj_is_new:
+            new_model_obj_was_created = True
+            self.obj.save()
+
+        elif touched_fields:
+            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.')
+
+        return self.obj, new_model_obj_was_created

django_spire/contrib/service/exceptions.py

@@ -0,0 +1,5 @@
+from django_spire.exceptions import DjangoSpireException
+
+
+class ServiceException(DjangoSpireException):
+    pass

django_spire/contrib/session/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class DjangoSpireSessionConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    label = 'django_spire_contrib_session'
+    name = 'django_spire.contrib.session'