django-spire 0.23.4__py3-none-any.whl

django_spire/core/converters/to_data.py

@@ -0,0 +1,131 @@
+from django.db import models
+from django.core.validators import MinValueValidator, MaxValueValidator
+from faker import Faker
+import random
+import os
+
+
+class DjangoFieldToFakerData:
+    def __init__(
+            self,
+            model_field: models.Field,
+            faker_method: tuple | None = None
+    ):
+        if isinstance(faker_method, str):
+            faker_method = (faker_method,)
+        self.model_field = model_field
+        self.faker_method = faker_method
+        self.faker = Faker()
+
+    @property
+    def field_converters(self):
+        return {
+            'CharField': self._char_field_data,
+            'TextField': self._char_field_data,
+            'IntegerField': self._integer_field_data,
+            'SmallIntegerField': self._integer_field_data,
+            'PositiveIntegerField': self._positive_integer_field_data,
+            'DecimalField': self._decimal_field_data,
+            'DateField': self._date_field_data,
+            'DateTimeField': self._date_time_field_data,
+            'BooleanField': self._boolean_field_data,
+            'EmailField': self._email_field_data,
+            'URLField': self._url_field_data,
+            'SlugField': self._slug_field_data,
+            'UUIDField': self._uuid_field_data,
+            'TimeField': self._time_field_data,
+            'BinaryField': self._binary_field_data,
+        }
+
+    def convert(self):
+        if self.faker_method:
+            result = self._use_faker_with_method()
+            if result is not None:
+                return result
+
+        converter = self.field_converters.get(self.model_field.get_internal_type())
+        if converter is None:
+            raise Exception(f'No handler for {self.model_field.get_internal_type()}')
+        return converter()
+
+    def _get_min_max_from_validators(self):
+        min_value = 0
+        max_value = 10000
+        for validator in self.model_field.validators:
+            if isinstance(validator, MinValueValidator):
+                min_value = validator.limit_value
+            elif isinstance(validator, MaxValueValidator):
+                max_value = validator.limit_value
+        return min_value, max_value
+
+    def _use_faker_with_method(self):
+        if isinstance(self.faker_method, tuple):
+            method_name = self.faker_method[0]
+            kwargs = self.faker_method[1] if len(self.faker_method) > 1 and isinstance(self.faker_method[1], dict) else {}
+
+            method = getattr(self.faker, method_name, None)
+            if callable(method):
+                return method(**kwargs)
+
+        return None
+
+    def _char_field_data(self):
+        max_length = getattr(self.model_field, 'max_length', 255)
+
+        if max_length is None:
+            max_length = 255
+
+        if self.model_field.choices:
+            choices = [choice[0] for choice in self.model_field.choices]
+            return self.faker.random_element(elements=choices)
+
+
+
+        return self.faker.text(max_nb_chars=max_length)
+
+    def _integer_field_data(self):
+        min_value, max_value = self._get_min_max_from_validators()
+        return random.randint(min_value, max_value)
+
+    def _positive_integer_field_data(self):
+        _, max_value = self._get_min_max_from_validators()
+        return random.randint(0, max_value)
+
+    def _decimal_field_data(self):
+        max_digits = getattr(self.model_field, 'max_digits', 5)
+        decimal_places = getattr(self.model_field, 'decimal_places', 2)
+        max_value = 10 ** (max_digits - decimal_places) - 1
+        value = random.uniform(0, max_value)
+        return round(value, decimal_places)
+
+    def _date_field_data(self):
+        return self.faker.date_between(start_date='-5y', end_date='today')
+
+    def _date_time_field_data(self):
+        return self.faker.date_time_between(start_date='-5y', end_date='now')
+
+    def _boolean_field_data(self):
+        return random.choice([True, False])
+
+    def _email_field_data(self):
+        return self.faker.email()
+
+    def _url_field_data(self):
+        return self.faker.url()
+
+    def _slug_field_data(self):
+        return self.faker.slug()
+
+    def _uuid_field_data(self):
+        return self.faker.uuid4()
+
+    def _time_field_data(self):
+        return self.faker.time()
+
+    def _binary_field_data(self):
+        return os.urandom(16)
+
+
+def fake_model_field_value(model_class, field_name: str, faker_method=None):
+    field = model_class._meta.get_field(field_name)
+    return DjangoFieldToFakerData(field, faker_method).convert()

django_spire/core/converters/to_enums.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+def django_choices_to_enums(
+        class_name: str,
+        choices: list[tuple[str, str]]
+):
+    choices_dict = {str(k).upper(): k for k, _ in choices}
+    return Enum(class_name, choices_dict)

django_spire/core/converters/to_pydantic.py

@@ -0,0 +1,169 @@
+from pydantic import constr, condecimal, create_model
+from pydantic.fields import Field
+
+from typing import Tuple, Type, Any, Optional
+
+from django.db import models
+from django.core import validators
+
+from django_spire.core.converters.to_enums import django_choices_to_enums
+from django_spire.core.maps import MODEL_FIELD_TYPE_TO_TYPE_MAP
+
+
+def django_to_pydantic_model(
+        model_class: Type[models.Model],
+        base_class: Type | None = None,
+        include_fields: str | list| tuple | None = None,
+        exclude_fields: str | list | tuple | None = None
+):
+    if not issubclass(model_class, models.Model):
+        raise ValueError("model_class must be a subclass of django.db.models.Model")
+
+    if include_fields is None:
+        include_fields = []
+
+    if exclude_fields is None:
+        exclude_fields = []
+
+    pydantic_fields = {}
+
+    for model_field in model_class._meta.fields:
+        field_name = model_field.attname
+
+        if len(include_fields) > 0 and field_name not in include_fields:
+            continue
+
+        if len(exclude_fields) > 0 and field_name in exclude_fields:
+            continue
+
+        converter = DjangoToPydanticFieldConverter(model_field)
+        pydantic_fields[field_name] = converter.build_field()
+
+    return create_model(
+        f'{model_class.__name__}',
+        __base__=base_class,
+        **pydantic_fields
+    )
+
+
+class DjangoToPydanticFieldConverter:
+
+    def __init__(self, model_field: models.Field):
+        self.model_field = model_field
+        self.kwargs = {}
+
+        self._build_metadata()
+        self.field_type = self._get_pydantic_type()
+        self._wrap_nullable()
+
+    @staticmethod
+    def bool_to_json_schema(value: bool):
+        if value:
+            return "true"
+        else:
+            return "false"
+
+    @property
+    def field_handlers(self):
+        return {
+            'CharField': self._build_char_field,
+            'IntegerField': self._build_integer_field,
+            'SmallIntegerField': self._build_integer_field,
+            'DecimalField': self._build_decimal_field,
+            'DateField': self._build_date_field,
+            'DateTimeField': self._build_date_time_field,
+        }
+
+    def _base_type(self):
+        return MODEL_FIELD_TYPE_TO_TYPE_MAP.get(
+            self.model_field.get_internal_type(),
+            str
+        )
+
+    def _build_char_field(self) -> Type:
+        if self.model_field.max_length:
+            return constr(max_length=self.model_field.max_length)
+        return str
+
+    def _build_date_field(self) -> Type:
+        self.kwargs['example'] = '2022-01-01'
+        self.kwargs['json_schema_extra']['example'] = '2022-01-01'
+        return self._base_type()
+
+    def _build_date_time_field(self) -> Type:
+        self.kwargs['example'] = '2022-01-01 13:37:00'
+        self.kwargs['json_schema_extra']['example'] = '2022-01-01 13:37:00'
+        return self._base_type()
+
+    def _build_integer_field(self) -> Type:
+        for validator in self.model_field.validators:
+            if isinstance(validator, validators.MinValueValidator):
+                self.kwargs['json_schema_extra']['greater_than'] = validator.limit_value
+            elif isinstance(validator, validators.MaxValueValidator):
+                self.kwargs['json_schema_extra']['less_than'] = validator.limit_value
+
+        return self._base_type()
+
+    def _build_decimal_field(self) -> Type:
+        self.kwargs['json_schema_extra']['example'] = '0.00'
+        self.kwargs['json_schema_extra']['max_digits'] = self.model_field.max_digits
+        self.kwargs['json_schema_extra']['decimal_places'] = self.model_field.decimal_places
+
+        return condecimal(
+            max_digits=self.model_field.max_digits,
+            decimal_places=self.model_field.decimal_places
+        )
+
+    def _build_enum_type(self):
+        enum_name = f"{self.model_field.name.capitalize()}Enum"
+        return django_choices_to_enums(enum_name, self.model_field.choices)
+
+    def build_field(self) -> Tuple[Type, Any]:
+        """Build and return the Pydantic field type and Field object."""
+        return self.field_type, Field(**self.kwargs)
+
+    def _build_metadata(self):
+
+        # Cannot set a default when providing option to the LLM
+        # if self.model_field.default is not models.NOT_PROVIDED:
+        #     if callable(self.model_field.default):
+        #         self.kwargs['default'] = self.model_field.default()
+        #     else:
+        #         self.kwargs['default'] = self.model_field.default
+
+        self.kwargs['required'] = not self.model_field.null
+
+        if self.model_field.null and self.model_field.default is models.NOT_PROVIDED:
+            self.kwargs['default'] = None
+
+        if self.model_field.help_text:
+            self.kwargs['description'] = str(self.model_field.help_text)
+
+        self.kwargs['json_schema_extra'] = {
+            'is_unique': self.bool_to_json_schema(self.model_field.unique),
+            # 'is_required': self.bool_to_json_schema(not self.model_field.null),
+            'field_name': self.model_field.name
+        }
+
+        if self.model_field.choices:
+            self.kwargs['json_schema_extra']['enum'] = [choice[0] for choice in self.model_field.choices]
+            self.kwargs['description'] = f"Select a {self.model_field.name.lower()} category. Options: " + ", ".join(
+                f"{value} ({label})" for value, label in self.model_field.choices
+            ) + "."
+
+    def _get_pydantic_type(self) -> Type:
+        if self.model_field.choices:
+            return self._build_enum_type()
+
+        handler = self.field_handlers.get(self.model_field.get_internal_type())
+
+        if handler:
+            return handler()
+
+        return self._base_type()
+
+    def _wrap_nullable(self):
+        pass
+        # This works better for the LLM
+        # if self.model_field.null:
+        #     self.field_type = Optional[self.field_type]

django_spire/core/decorators.py

@@ -0,0 +1,25 @@
+from django.db import connections
+from functools import wraps
+
+from django.http import JsonResponse
+
+
+def close_db_connections(func):
+    @wraps(func)
+    def inner(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        finally:
+            connections.close_all()
+    return inner
+
+
+def valid_ajax_request_required(method):
+    @wraps(method)
+    def wrapper(request, *args, **kwargs):
+        if request.method != 'POST' and request.content_type != 'application/json':
+            return JsonResponse(
+                {'type': 'error', 'message': 'Invalid Request'}
+            )
+        return method(request, *args, **kwargs)
+    return wrapper

django_spire/core/forms/widgets.py

@@ -0,0 +1,21 @@
+import json
+import uuid
+
+from django import forms
+
+
+class JsonTreeWidget(forms.Textarea):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.template_name = 'django_spire/forms/widgets/json_tree_widget.html'
+
+    def get_context(self, *args, **kwargs):
+        context = super().get_context(*args, **kwargs)
+        context['open_dropdowns'] = True
+        context['widget_render_uuid'] = uuid.uuid4()
+        if context['widget']['value'] is None:
+            context['json_tree_dict'] = {}
+        else:
+            context['json_tree_dict'] = json.loads(context['widget']['value'])
+
+        return context

django_spire/core/management/commands/spire_remove_migration.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = 'Remove all migration(s) and delete SQLite database.'
+
+    def handle(self, *_args, **_kwargs) -> None:
+        is_migration_removed = self.remove_migration()
+
+        if is_migration_removed:
+            message = self.style.SUCCESS('The migration file(s) removed.')
+            self.stdout.write(message)
+        else:
+            message = self.style.SUCCESS('The migration file(s) removed.')
+            self.stdout.write(message)
+
+        is_database_removed = self.remove_sqlite_database()
+
+        if is_database_removed:
+            message = self.style.SUCCESS('The test database was removed.')
+            self.stdout.write(message)
+        else:
+            message = self.style.SUCCESS('The test database was removed.')
+            self.stdout.write(message)
+
+    def remove_migration(self) -> bool:
+        found = False
+
+        for app in settings.INSTALLED_APPS:
+            path = settings.BASE_DIR / app.replace('.', '/') / 'migrations'
+
+            if path.exists():
+                for file in path.glob('*.py'):
+                    if file.name == '__init__.py':
+                        continue
+
+                    file.unlink()
+                    found = True
+
+        return found
+
+    def remove_sqlite_database(self) -> bool:
+        path = settings.DATABASES.get('default')
+
+        if not path:
+            return False
+
+        name = path.get('NAME')
+
+        if name is None:
+            return False
+
+        path = settings.BASE_DIR / name
+
+        if path.exists() and path.is_file():
+            path.unlink()
+            return True
+
+        return False

django_spire/core/management/commands/spire_startapp.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.core.management.base import BaseCommand
+
+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 (
+    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 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.
+
+        :param args: Positional arguments (not used).
+        :param kwargs: Keyword arguments (not used).
+        """
+
+        filesystem = FileSystem()
+        path_config = PathConfig.default()
+        path_resolver = PathResolver()
+        registry = AppRegistry()
+        reporter = Reporter(self)
+
+        template_engine = TemplateEngine()
+        template_processor = TemplateProcessor(template_engine, filesystem)
+
+        validator = AppValidator(reporter, registry, path_resolver, filesystem)
+
+        user_input_collector = UserInputCollector(reporter, validator)
+
+        config_factory = AppConfigFactory(path_resolver)
+
+        template_builder = TemplateBuilder(reporter)
+
+        app_generator = AppGenerator(filesystem, template_processor, reporter, path_config)
+        # template_generator = TemplateGenerator(filesystem, template_processor, reporter, path_config)
+
+        user_inputs = user_input_collector.collect_all_inputs()
+        app_path = user_inputs['app_path']
+
+        validator.validate_app_format(app_path)
+
+        config = config_factory.create_config(app_path, user_inputs)
+        validator.validate_root_app(config.components)
+
+        reporter.write(
+            f'\nChecking app components: {config.components}\n',
+            reporter.style_notice
+        )
+
+        missing = registry.get_missing_components(config.components)
+
+        if missing:
+            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]]:
+                module_config = config_factory.create_config(module, user_inputs)
+                app_generator.generate(module_config)
+                # template_generator.generate(module_config)
+
+            reporter.report_installed_apps_suggestion(missing)
+        else:
+            reporter.write('All component(s) exist.', reporter.style_success)

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

@@ -0,0 +1,44 @@
+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
+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
+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
+
+
+__all__ = [
+    'AppConfig',
+    'AppConfigFactory',
+    'AppGenerator',
+    'AppRegistry',
+    'AppValidator',
+    'FileSystem',
+    'PathConfig',
+    'PathResolver',
+    'PermissionInheritanceHandler',
+    'Reporter',
+    '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 Reporter
+
+
+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: Reporter):
+        """
+        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,
+        )