django-spire 0.16.12__py3-none-any.whl → 0.17.0__py3-none-any.whl

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

@@ -1,29 +1,28 @@
-from dandy.llm import BaseLlmBot, LlmConfigOptions
-
+from dandy import Bot, LlmConfigOptions
 
 from django_spire.contrib.seeding.intelligence.intel import SourceIntel
+from django_spire.contrib.seeding.intelligence.prompts.generate_django_model_seeder_prompts import (
+    generate_django_model_seeder_user_prompt,
+    generate_django_model_seeder_system_prompt
+)
 
 
-from django_spire.contrib.seeding.intelligence.prompts.generate_django_model_seeder_prompts import \
-    generate_django_model_seeder_user_prompt, generate_django_model_seeder_system_prompt
-
-
-class SeederGeneratorBot(BaseLlmBot):
+class SeederGeneratorBot(Bot):
+    llm_config = 'PYTHON_MODULE'
 
-    config = 'PYTHON_MODULE'
-
-    config_options = LlmConfigOptions(
+    llm_config_options = LlmConfigOptions(
         temperature=0.3,
         randomize_seed=True
     )
 
-    @classmethod
+    llm_role = 'You are an expert Python developer specializing in Django model seeders.'
+
     def process(
-            cls,
-            model_import: str,
-            model_description: str
-    ):
-        return cls.process_prompt_to_intel(
+        self,
+        model_import: str,
+        model_description: str
+    ) -> SourceIntel:
+        return self.llm.prompt_to_intel(
             prompt=generate_django_model_seeder_user_prompt(
                 model_import,
                 model_description,

django_spire/contrib/seeding/intelligence/intel.py

@@ -1,4 +1,4 @@
-from dandy.intel import BaseIntel
+from dandy import BaseIntel
 
 
 class SeedingIntel(BaseIntel):

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

@@ -1,19 +1,17 @@
-from typing import Type
-
 from django.db.models.base import Model
 
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 class SeedingModelClassPromptFactory:
 
-    def __init__(self, model_class: Type[Model]):
+    def __init__(self, model_class: type[Model]):
         self.model_class = model_class
 
     def objective_prompt(
-            self,
-            model_description: str,
-            sector_description: str,
+        self,
+        model_description: str,
+        sector_description: str
     ) -> Prompt:
         model_name = self.model_class._meta.verbose_name_plural.title()
 

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

@@ -1,13 +1,11 @@
-from typing_extensions import Type
-
 from django.db.models import Model
 
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 def foreign_key_selection_prompt(
-    model_class: Type[Model],
-    related_model_class: Type[Model]
+    model_class: type[Model],
+    related_model_class: type[Model]
 ) -> Prompt:
     model_name = model_class._meta.verbose_name.title()
     related_model_name = related_model_class._meta.verbose_name.title()

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

@@ -1,7 +1,6 @@
-import os
 from pathlib import Path
 
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 _RELATIVE_BASE_DIR = Path(Path(__file__).parent.parent.parent.parent.parent.parent.resolve())

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

@@ -1,14 +1,12 @@
-from typing_extensions import List, Type
-
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Model
 
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 def generic_relationship_selection_prompt(
-    model_class: Type[Model],
-    related_model_classes: List[Type[Model]]
+    model_class: type[Model],
+    related_model_classes: list[type[Model]]
 ) -> Prompt:
     related_model_classes_map = {
         related_model_class._meta.verbose_name.title(): {

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

@@ -2,7 +2,7 @@ from random import shuffle
 
 from django.db.models import Model
 
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 def hierarchical_selection_prompt(

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

@@ -1,11 +1,11 @@
-from dandy.llm import Prompt
+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,
+    model_field: Field,
+    choices: TextChoices
 ) -> Prompt:
     model_name = model_field.field.model.__name__
     field_name = model_field.field.name

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

@@ -1,4 +1,4 @@
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 def negation_prompt(

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

@@ -1,12 +1,10 @@
 from django.db.models import Model
 
-from typing_extensions import Type
-
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 def objective_prompt(
-    model_class: Type[Model],
+    model_class: type[Model],
     model_description: str,
     sector_description: str,
 ) -> Prompt:

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

@@ -31,12 +31,15 @@ class Command(BaseCommand):
     # @recorder_to_html_file('seeding_generator')
     def handle(self, *args, **kwargs):
         if not kwargs['model_import'] or not kwargs['model_description']:
-            raise CommandError('You must provide a model import path and a 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'])
 
-        source_intel = SeederGeneratorBot.process(model_import, 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)
 

django_spire/contrib/seeding/model/base.py

@@ -1,8 +1,8 @@
 from abc import ABC, abstractmethod
 
 from dandy.recorder import recorder_to_html_file
-from dandy.cache import SqliteCache
-from dandy.cache.utils import generate_hash_key
+from dandy import SqliteCache
+from dandy.cache.utils import generate_cache_key
 
 from django_spire.contrib.seeding.field.override import FieldOverride
 from django_spire.contrib.seeding.model.config import FieldsConfig
@@ -59,10 +59,7 @@ class BaseModelSeeder(ABC):
 
     @classmethod
     def clear_cache(cls):
-        SqliteCache(
-            cache_name=cls.cache_name,
-            limit=cls.cache_limit
-        ).clear(cache_name=cls.cache_name)
+        SqliteCache.clear(cache_name=cls.cache_name)
 
     @classmethod
     @abstractmethod
@@ -80,9 +77,14 @@ class BaseModelSeeder(ABC):
         field_config = cls.get_field_config().override(fields) if fields else cls.get_field_config()
 
         if cls.cache_seed:
-            hash_key = generate_hash_key(cls.seed_data, count=count, field_config=field_config.fields)
+            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(hash_key)
+            formatted_seed_data = cache.get(cache_key)
 
             if formatted_seed_data:
                 return formatted_seed_data
@@ -95,13 +97,13 @@ class BaseModelSeeder(ABC):
             if len(seeder.seeder_fields) > 0:
                 seed_data.append(seeder.seed(cls, count))
 
-        formatted_seed_data = [dict() for _ in range(max(len(sublist) for sublist in seed_data))]
+        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(hash_key, formatted_seed_data)
+            cache.set(cache_key, formatted_seed_data)
 
         return formatted_seed_data
 

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

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-from typing import Type, TypeVar
+from typing import TypeVar, TYPE_CHECKING
 
-from dandy.llm import Prompt
 from django.db.models import ForeignKey
-
 from django.db.models.base import Model
 
 from django_spire.contrib.seeding.field.callable import CallableFieldSeeder
@@ -14,6 +12,9 @@ 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)
 
@@ -21,7 +22,7 @@ TypeModel = TypeVar('TypeModel', bound=Model)
 class DjangoModelSeeder(BaseModelSeeder):
     field_config_class = DjangoModelFieldsConfig
 
-    model_class: Type[Model]
+    model_class: type[Model]
     prompt: Prompt = None
     _field_seeders = [
         CustomFieldSeeder,
@@ -32,14 +33,16 @@ class DjangoModelSeeder(BaseModelSeeder):
     ]
 
     @classmethod
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs) -> None:
         super().__init_subclass__(**kwargs)
 
         if cls.model_class is None:
-            raise ValueError("Seeds must have a model class")
+            message = "Seeds must have a model class"
+            raise ValueError(message)
 
         if cls.fields is None:
-            raise ValueError("Seeds must have fields")
+            message = "Seeds must have fields"
+            raise ValueError(message)
 
     @classmethod
     def field_names(cls) -> list[str]:
@@ -51,9 +54,9 @@ class DjangoModelSeeder(BaseModelSeeder):
 
     @classmethod
     def seed_database(
-            cls,
-            count=1,
-            fields: dict | None = None
+        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/tests/test_seeding.py

@@ -1,4 +1,4 @@
-# from dandy.llm import Prompt
+# from dandy import Prompt
 # from django.test import TestCase
 #
 # from django_spire.seeding.processor import SeedingProcessor

django_spire/core/management/commands/spire_startapp.py

@@ -1,80 +1,118 @@
 from __future__ import annotations
 
-import django_spire
+from typing import TYPE_CHECKING
 
-from pathlib import Path
+from django.core.management.base import BaseCommand
 
-from django.conf import settings
-from django.core.management.base import BaseCommand, CommandError
-
-from django_spire.core.management.commands.spire_startapp_pkg.manager import (
-        AppManager,
-        HTMLTemplateManager,
+from django_spire.core.management.commands.spire_startapp_pkg.builder import TemplateBuilder
+from django_spire.core.management.commands.spire_startapp_pkg.config import (
+    AppConfigFactory,
+    PathConfig,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.filesystem import FileSystem
+from django_spire.core.management.commands.spire_startapp_pkg.generator import (
+    AppGenerator,
+    # TemplateGenerator,
 )
 from django_spire.core.management.commands.spire_startapp_pkg.processor import (
-        AppTemplateProcessor,
-        HTMLTemplateProcessor
+    TemplateEngine,
+    TemplateProcessor,
 )
+from django_spire.core.management.commands.spire_startapp_pkg.registry import AppRegistry
 from django_spire.core.management.commands.spire_startapp_pkg.reporter import Reporter
+from django_spire.core.management.commands.spire_startapp_pkg.resolver import PathResolver
+from django_spire.core.management.commands.spire_startapp_pkg.user_input import UserInputCollector
+from django_spire.core.management.commands.spire_startapp_pkg.validator import AppValidator
+
+if TYPE_CHECKING:
+    from typing import Any
 
 
 class Command(BaseCommand):
+    """
+    Django management command for creating custom Spire apps.
+
+    This command guides users through an interactive wizard to create a new Django app
+    with a pre-configured structure including models, views, forms, services, and templates.
+    It handles nested app structures (e.g., app.parent.child) and validates that all
+    parent apps are properly registered before creating child apps.
+    """
+
     help = 'Create a custom Spire app.'
 
-    def __init__(self):
-        super().__init__()
+    def handle(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Main entry point for the management command.
+
+        Orchestrates the entire app creation process by initializing helper classes,
+        collecting user input through an interactive wizard, validating the app structure,
+        generating app files and templates, and providing feedback to the user.
 
-        self.app_base = Path(settings.BASE_DIR)
-        self.app_template = Path(django_spire.__file__).parent / 'core/management/commands/spire_startapp_pkg/template/app'
+        :param args: Positional arguments (not used).
+        :param kwargs: Keyword arguments (not used).
+        """
 
-        self.template_base = self.app_base / 'templates'
-        self.html_template = Path(django_spire.__file__).parent / 'template/templates'
+        filesystem = FileSystem()
+        path_config = PathConfig.default()
+        path_resolver = PathResolver()
+        registry = AppRegistry()
+        reporter = Reporter(self)
 
-        self.app_manager = AppManager(self.app_base, self.app_template)
-        self.app_processor = AppTemplateProcessor()
+        template_engine = TemplateEngine()
+        template_processor = TemplateProcessor(template_engine, filesystem)
 
-        self.html_manager = HTMLTemplateManager(self.template_base, self.html_template)
-        self.html_processor = HTMLTemplateProcessor()
+        validator = AppValidator(reporter, registry, path_resolver, filesystem)
 
-        self.reporter = Reporter(self)
+        user_input_collector = UserInputCollector(reporter, validator)
 
-    def get_app_names(self) -> list[str]:
-        from django.apps import apps
-        return [config.name for config in apps.get_app_configs()]
+        config_factory = AppConfigFactory(path_resolver)
 
-    def handle(self, *_args, **kwargs) -> None:
-        app = input('Enter the path of the app (e.g., "app.maintenance.work_order"):')
+        template_builder = TemplateBuilder(reporter)
 
-        if not app:
-            raise CommandError(self.style.ERROR('The app name is missing'))
+        app_generator = AppGenerator(filesystem, template_processor, reporter, path_config)
+        # template_generator = TemplateGenerator(filesystem, template_processor, reporter, path_config)
 
-        self.app_manager.validate_app_name_format(app)
+        user_inputs = user_input_collector.collect_all_inputs()
+        app_path = user_inputs['app_path']
 
-        components = self.app_manager.parse_app_name(app)
-        self.app_manager.is_valid_root_apps(components)
+        validator.validate_app_format(app_path)
 
-        registry = self.get_app_names()
+        config = config_factory.create_config(app_path, user_inputs)
+        validator.validate_root_app(config.components)
 
-        self.reporter.write(
-            f'Checking app components: {components}\n\n',
-            self.style.NOTICE
+        reporter.write(
+            f'\nChecking app components: {config.components}\n',
+            reporter.style_notice
         )
 
-        missing = self.app_manager.get_missing_components(components, registry)
+        missing = registry.get_missing_components(config.components)
 
         if missing:
-            self.reporter.report_missing_components(missing)
-            self.reporter.report_app_tree_structure(self.app_base, components, registry, self.app_template)
-            # self.reporter.report_html_tree_structure(self.template_base, components, registry, self.html_template)
-
-            if not self.reporter.prompt_for_confirmation('\nProceed with app creation? (y/n): '):
-                self.reporter.write('App creation aborted.', self.style.ERROR)
+            reporter.report_missing_components(missing)
+
+            template_builder.build_app_tree_structure(
+                path_resolver.get_base_dir(),
+                config.components,
+                registry.get_installed_apps(),
+                path_config.app_template
+            )
+
+            # template_builder.build_html_tree_structure(
+            #     path_resolver.get_base_dir(),
+            #     config.components,
+            #     registry.get_installed_apps(),
+            #     path_config.html_template
+            # )
+
+            if not reporter.prompt_confirmation('\nProceed with app creation? (y/n): '):
+                reporter.write('App creation aborted.', reporter.style_error)
                 return
 
             for module in [missing[-1]]:
-                self.app_manager.create_custom_app(module, self.app_processor, self.reporter)
-                # self.html_manager.create_custom_templates(module, self.html_processor, self.reporter)
+                module_config = config_factory.create_config(module, user_inputs)
+                app_generator.generate(module_config)
+                # template_generator.generate(module_config)
 
-            self.reporter.report_installed_apps_suggestion(missing)
+            reporter.report_installed_apps_suggestion(missing)
         else:
-            self.reporter.write('All component(s) exist.', self.style.SUCCESS)
+            reporter.write('All component(s) exist.', reporter.style_success)

django_spire/core/management/commands/spire_startapp_pkg/__init__.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from django_spire.core.management.commands.spire_startapp_pkg.builder import TemplateBuilder
+from django_spire.core.management.commands.spire_startapp_pkg.config import (
+    AppConfig,
+    AppConfigFactory,
+    PathConfig,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.filesystem import (
+    FileSystem,
+    FileSystemInterface,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.generator import (
+    AppGenerator,
+    TemplateGenerator,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.maps import generate_replacement_map
+from django_spire.core.management.commands.spire_startapp_pkg.permissions import PermissionInheritanceHandler
+from django_spire.core.management.commands.spire_startapp_pkg.processor import (
+    TemplateEngine,
+    TemplateProcessor,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.registry import (
+    AppRegistry,
+    AppRegistryInterface,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.reporter import (
+    Reporter,
+    ReporterInterface,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.resolver import (
+    PathResolver,
+    PathResolverInterface,
+)
+from django_spire.core.management.commands.spire_startapp_pkg.user_input import UserInputCollector
+from django_spire.core.management.commands.spire_startapp_pkg.validator import AppValidator
+
+
+__all__ = [
+    'AppConfig',
+    'AppConfigFactory',
+    'AppGenerator',
+    'AppRegistry',
+    'AppRegistryInterface',
+    'AppValidator',
+    'FileSystem',
+    'FileSystemInterface',
+    'PathConfig',
+    'PathResolver',
+    'PathResolverInterface',
+    'PermissionInheritanceHandler',
+    'Reporter',
+    'ReporterInterface',
+    'TemplateBuilder',
+    'TemplateEngine',
+    'TemplateGenerator',
+    'TemplateProcessor',
+    'UserInputCollector',
+    'generate_replacement_map',
+]

django_spire/core/management/commands/spire_startapp_pkg/builder.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.core.management.commands.spire_startapp_pkg.maps import generate_replacement_map
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from django_spire.core.management.commands.spire_startapp_pkg.reporter import ReporterInterface
+
+
+class TemplateBuilder:
+    """
+    Builds and displays tree structures for app and template creation.
+
+    This class generates visual representations of the file structure
+    that will be created for new apps and their associated templates.
+    """
+
+    def __init__(self, reporter: ReporterInterface):
+        """
+        Initializes the TemplateBuilder with a reporter for output.
+
+        :param reporter: Reporter instance for displaying output to the user.
+        """
+
+        self._reporter = reporter
+
+    def build_app_tree_structure(
+        self,
+        base: Path,
+        components: list[str],
+        registry: list[str],
+        template: Path
+    ) -> None:
+        """
+        Displays a tree structure of the app files that will be created.
+
+        This method shows the user what Python files, directories, and modules
+        will be generated for the new Django app before creation.
+
+        :param base: Base directory where the app will be created.
+        :param components: List of app path components (e.g., ['app', 'human_resource', 'employee']).
+        :param registry: List of already registered apps in the Django project.
+        :param template: Path to the app template directory.
+        """
+
+        self._reporter.report_tree_structure(
+            title='\nThe following app(s) will be created:\n\n',
+            base=base,
+            components=components,
+            registry=registry,
+            template=template,
+            formatter=self._reporter.format_app_item,
+            transformation=self._reporter.transform_app_component,
+        )
+
+    def build_html_tree_structure(
+        self,
+        base: Path,
+        components: list[str],
+        registry: list[str],
+        template: Path
+    ) -> None:
+        """
+        Displays a tree structure of the HTML template files that will be created.
+
+        This method shows the user what HTML templates, cards, forms, and pages
+        will be generated for the new Django app before creation.
+
+        :param base: Base directory where templates will be created.
+        :param components: List of app path components.
+        :param registry: List of already registered apps in the Django project.
+        :param template: Path to the HTML template directory.
+        """
+
+        replacement = generate_replacement_map(components)
+
+        def html_formatter_with_replacement(item: Path) -> str:
+            return self._reporter.format_html_item(item, replacement)
+
+        self._reporter.report_tree_structure(
+            title='\nThe following template(s) will be created:\n\n',
+            base=base,
+            components=components,
+            registry=registry,
+            template=template,
+            formatter=html_formatter_with_replacement,
+            transformation=self._reporter.transform_html_component,
+        )