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

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

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import re
+
+from typing_extensions import TYPE_CHECKING
+
+from django.core.management.base import CommandError
+
+if TYPE_CHECKING:
+    from django_spire.core.management.commands.spire_startapp_pkg.reporter import Reporter
+    from django_spire.core.management.commands.spire_startapp_pkg.validator import AppValidator
+
+
+class UserInputCollector:
+    """
+    Collects user input for Django app creation through an interactive wizard.
+
+    This class guides users through a step-by-step process to gather all
+    necessary configuration for creating a new Django app.
+    """
+
+    def __init__(self, reporter: Reporter, validator: AppValidator):
+        """
+        Initializes the collector with a reporter and validator.
+
+        :param reporter: Reporter instance for displaying prompts and messages.
+        :param validator: Validator for checking user input validity.
+        """
+
+        self.reporter = reporter
+        self.validator = validator
+
+    def collect_all_inputs(self) -> dict[str, str]:
+        """
+        Collects all required user inputs for app creation.
+
+        Guides the user through an 8-step wizard to gather app path, names,
+        labels, and configuration options.
+
+        :return: Dictionary containing all collected user inputs.
+        """
+
+        self.reporter.write('\n[App Creation Wizard]\n\n', self.reporter.style_success)
+
+        app_path = self._collect_app_path()
+        components = app_path.split('.')
+
+        app_name = self._collect_app_name(components)
+        app_label = self._collect_app_label(components, app_name)
+        model_name = self._collect_model_name(app_name)
+        model_name_plural = self._collect_model_name_plural(model_name)
+        db_table_name = self._collect_db_table_name(app_label)
+        model_permission_path = self._collect_model_permission_path(app_path, model_name)
+
+        permission_data = self._collect_permission_inheritance(components)
+
+        verbose_name, verbose_name_plural = self._derive_verbose_names(model_name, model_name_plural)
+
+        return {
+            'app_path': app_path,
+            'app_name': app_name,
+            'model_name': model_name,
+            'model_name_plural': model_name_plural,
+            'app_label': app_label,
+            'db_table_name': db_table_name,
+            'model_permission_path': model_permission_path,
+            'verbose_name': verbose_name,
+            'verbose_name_plural': verbose_name_plural,
+            **permission_data,
+        }
+
+    def _collect_app_label(self, components: list[str], app_name: str) -> str:
+        """
+        Prompts the user for the Django app label.
+
+        :param components: List of app path components.
+        :param app_name: Name of the app.
+        :return: User-provided or default app label.
+        """
+
+        parent_parts = components[1:-1] if len(components) > 1 else []
+        default = '_'.join(parent_parts).lower() + '_' + app_name.lower() if parent_parts else app_name.lower()
+        return self._collect_input('Enter the app label', default, '3/8')
+
+    def _collect_app_name(self, components: list[str]) -> str:
+        """
+        Prompts the user for the app name.
+
+        :param components: List of app path components.
+        :return: User-provided or default app name.
+        """
+
+        default = components[-1]
+        return self._collect_input('Enter the app name', default, '2/8')
+
+    def _collect_app_path(self) -> str:
+        """
+        Prompts the user for the app path and validates it.
+
+        :return: Validated app path in dot notation.
+        :raises CommandError: If the app path is empty or invalid.
+        """
+
+        app_path = self._collect_simple_input('Enter the app path (e.g., "app.human_resource.employee.skill")', '1/8')
+
+        if not app_path:
+            self.reporter.write('\n', self.reporter.style_notice)
+
+            message = 'The app path is required'
+            raise CommandError(message)
+
+        components = app_path.split('.')
+        self.validator.validate_app_path(components)
+
+        return app_path
+
+    def _collect_db_table_name(self, app_label: str) -> str:
+        """
+        Prompts the user for the database table name.
+
+        :param app_label: App label to use as default.
+        :return: User-provided or default database table name.
+        """
+
+        return self._collect_input('Enter the database table name', app_label, '6/8')
+
+    def _collect_input(self, prompt: str, default: str, step_number: str) -> str:
+        """
+        Prompts the user for input with a default value.
+
+        :param prompt: Prompt message to display.
+        :param default: Default value if user presses Enter.
+        :param step_number: Step number in the wizard (e.g., '1/8').
+        :return: User-provided input or default value.
+        """
+
+        self.reporter.write(f'\n[{step_number}]: {prompt} (default: "{default}")', self.reporter.style_notice)
+        user_input = input('Press Enter to use default or type a custom value: ').strip()
+        return user_input if user_input else default
+
+    def _collect_model_name(self, app_name: str) -> str:
+        """
+        Prompts the user for the model class name.
+
+        :param app_name: App name to derive default from.
+        :return: User-provided or default model name in TitleCase.
+        """
+
+        default = ''.join(word.title() for word in app_name.split('_'))
+        return self._collect_input('Enter the model name', default, '4/8')
+
+    def _collect_model_name_plural(self, model_name: str) -> str:
+        """
+        Prompts the user for the plural form of the model name.
+
+        :param model_name: Singular model name.
+        :return: User-provided or default plural model name.
+        """
+
+        default = model_name + 's'
+        return self._collect_input('Enter the model name plural', default, '5/8')
+
+    def _collect_model_permission_path(self, app_path: str, model_name: str) -> str:
+        """
+        Prompts the user for the model permission path.
+
+        :param app_path: Dot-separated app path.
+        :param model_name: Model class name.
+        :return: User-provided or default model permission path.
+        """
+
+        default = f'{app_path}.models.{model_name}'
+        return self._collect_input('Enter the model permission path', default, '7/8')
+
+    def _collect_permission_inheritance(self, components: list[str]) -> dict[str, str]:
+        """
+        Collects permission inheritance configuration if applicable.
+
+        Prompts the user about inheriting permissions from parent apps
+        and collects necessary parent model information.
+
+        :param components: List of app path components.
+        :return: Dictionary containing permission inheritance settings.
+        """
+
+        if len(components) <= 2:
+            return {'inherit_permissions': False, 'parent_permission_prefix': '', 'parent_model_instance_name': ''}
+
+        if not self._should_inherit_permissions():
+            return {'inherit_permissions': False, 'parent_permission_prefix': '', 'parent_model_instance_name': ''}
+
+        parent_parts = components[1:-1]
+        parent_name = components[-2]
+        parent_model_class = ''.join(word.title() for word in parent_name.split('_'))
+
+        self.reporter.write('\n[Permission Inheritance Configuration]\n', self.reporter.style_notice)
+
+        return {
+            'inherit_permissions': True,
+            'parent_permission_prefix': self._collect_input(
+                'Enter the parent permission prefix',
+                '_'.join(parent_parts).lower(),
+                '1/3'
+            ),
+            'parent_model_instance_name': self._collect_input(
+                'Enter the parent model instance name',
+                parent_name.lower(),
+                '2/3'
+            ),
+            'parent_model_path': self._collect_input(
+                'Enter the parent model path',
+                '.'.join(components[:-1]) + f'.models.{parent_model_class}',
+                '3/3'
+            ),
+        }
+
+    def _collect_simple_input(self, prompt: str, step_number: str) -> str:
+        """
+        Prompts the user for simple input without a default value.
+
+        :param prompt: Prompt message to display.
+        :param step_number: Step number in the wizard.
+        :return: User-provided input.
+        """
+
+        return input(f'[{step_number}]: {prompt}: ').strip()
+
+    def _derive_verbose_names(self, model_name: str, model_name_plural: str) -> tuple[str, str]:
+        """
+        Derives human-readable verbose names from model names.
+
+        Converts CamelCase model names to space-separated words.
+
+        :param model_name: Singular model name in CamelCase.
+        :param model_name_plural: Plural model name in CamelCase.
+        :return: Tuple of (verbose_name, verbose_name_plural).
+        """
+
+        verbose_name = re.sub(r'(?<!^)(?=[A-Z])', ' ', model_name)
+        verbose_name_plural = re.sub(r'(?<!^)(?=[A-Z])', ' ', model_name_plural)
+        return verbose_name, verbose_name_plural
+
+    def _should_inherit_permissions(self) -> bool:
+        """
+        Prompts the user to confirm permission inheritance.
+
+        :return: True if user wants to inherit permissions, False otherwise.
+        """
+
+        self.reporter.write('\n[8/8]: Do you want this app to inherit permissions from its parent? (y/n)', self.reporter.style_notice)
+        user_input = input('Default is "n": ').strip().lower()
+        return user_input == 'y'

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

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.core.management.base import CommandError
+
+if TYPE_CHECKING:
+    from django_spire.core.management.commands.spire_startapp_pkg.filesystem import FileSystemInterface
+    from django_spire.core.management.commands.spire_startapp_pkg.registry import AppRegistryInterface
+    from django_spire.core.management.commands.spire_startapp_pkg.reporter import ReporterInterface
+    from django_spire.core.management.commands.spire_startapp_pkg.resolver import PathResolverInterface
+
+
+class AppValidator:
+    """
+    Validates Django app paths and configurations.
+
+    This class performs validation checks to ensure app paths are properly
+    formatted, don't conflict with existing apps, and use valid root apps.
+    """
+
+    def __init__(
+        self,
+        reporter: ReporterInterface,
+        registry: AppRegistryInterface,
+        path_resolver: PathResolverInterface,
+        filesystem: FileSystemInterface
+    ):
+        """
+        Initializes the validator with required dependencies.
+
+        :param reporter: Reporter for displaying error messages.
+        :param registry: Registry for checking installed apps.
+        :param path_resolver: Path resolver for determining file locations.
+        :param filesystem: File system interface for checking file existence.
+        """
+
+        self._filesystem = filesystem
+        self._path_resolver = path_resolver
+        self._registry = registry
+        self._reporter = reporter
+
+    def validate_app_format(self, app_path: str) -> None:
+        """
+        Validates that an app path uses dot notation.
+
+        :param app_path: App path to validate.
+        :raises CommandError: If the app path doesn't contain dots.
+        """
+
+        if '.' not in app_path:
+            self._reporter.write('\n', self._reporter.style_notice)
+
+            message = 'Invalid app name format. The app path must use dot notation (e.g., "parent.child").'
+            raise CommandError(message)
+
+    def validate_app_path(self, components: list[str]) -> None:
+        """
+        Validates that an app path doesn't already exist.
+
+        :param components: List of app path components.
+        :raises CommandError: If an app already exists at the destination path.
+        """
+
+        destination = self._path_resolver.get_app_destination(components)
+
+        if self._filesystem.has_content(destination):
+            self._reporter.write('\n', self._reporter.style_notice)
+
+            message = (
+                f'The app already exists at {destination}. '
+                'Please remove the existing app or choose a different name.'
+            )
+
+            raise CommandError(message)
+
+    def validate_root_app(self, components: list[str]) -> None:
+        """
+        Validates that the root app component is registered in Django.
+
+        :param components: List of app path components.
+        :raises CommandError: If the root app is not a valid registered app.
+        """
+
+        valid_roots = self._registry.get_valid_root_apps()
+        root = components[0]
+
+        if root not in valid_roots:
+            self._reporter.write('\n', self._reporter.style_notice)
+
+            message = (
+                f'Invalid root app "{root}". '
+                f'Valid root apps: {", ".join(sorted(valid_roots))}.'
+            )
+
+            raise CommandError(message)

django_spire/core/middleware/__init__.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from django_spire.core.middleware.maintenance import MaintenanceMiddleware
-from django_spire.core.middleware.profiling import ProfilingMiddleware
 
 
-__all__ = ['MaintenanceMiddleware', 'ProfilingMiddleware']
+__all__ = ['MaintenanceMiddleware']

django_spire/profiling/__init__.py

@@ -0,0 +1,13 @@
+import threading
+
+lock = threading.Lock()
+
+from django_spire.profiling.middleware.profiling import ProfilingMiddleware
+from django_spire.profiling.panel import ProfilingPanel
+
+
+__all__ = [
+    'ProfilingMiddleware',
+    'ProfilingPanel',
+    'lock'
+]

django_spire/profiling/middleware/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from django_spire.profiling.middleware.profiling import ProfilingMiddleware
+
+
+__all__ = ['ProfilingMiddleware']

django_spire/{core → profiling}/middleware/profiling.py

@@ -5,20 +5,42 @@ import threading
 import time
 
 from pathlib import Path
-from typing_extensions import Any, Callable, TYPE_CHECKING
+from typing_extensions import TYPE_CHECKING
 
 from django.conf import settings
 from django.utils.deprecation import MiddlewareMixin
 
+from django_spire.profiling import lock
+
 try:
     from pyinstrument import Profiler
 except ImportError:
     Profiler = None
 
 if TYPE_CHECKING:
+    from typing_extensions import Any, Callable
+
     from django.http import HttpRequest, HttpResponse
 
 
+IGNORE_EXTENSION = [
+    '.eot',
+    '.gif',
+    '.ico',
+    '.jpeg',
+    '.jpg',
+    '.js',
+    '.map',
+    '.pdf',
+    '.png',
+    '.svg',
+    '.ttf',
+    '.txt',
+    '.woff',
+    '.woff2',
+    '.zip',
+]
+
 IGNORE_PATH = [
     '/__',
     '/__debug__/',
@@ -36,12 +58,13 @@ IGNORE_PATH = [
     '/debug/',
     '/debug-toolbar/',
     '/django_glue/',
+    '/django_spire/theme/json/get_config/',
     '/docs/',
     '/favicon.ico',
     '/media/',
     '/openapi/',
     '/redoc/',
-    '/robots.txt',
+    '/robots.txt/',
     '/schema/',
     '/sitemap.xml',
     '/static/',
@@ -50,37 +73,15 @@ IGNORE_PATH = [
 ]
 
 
-IGNORE_EXTENSION = [
-    '.css',
-    '.eot',
-    '.gif',
-    '.ico',
-    '.jpeg',
-    '.jpg',
-    '.js',
-    '.map',
-    '.pdf',
-    '.png',
-    '.svg',
-    '.ttf',
-    '.txt',
-    '.woff',
-    '.woff2',
-    '.zip',
-]
-
-
 class ProfilingMiddleware(MiddlewareMixin):
     def __init__(self, get_response: Callable[[HttpRequest], HttpResponse]) -> None:
         super().__init__(get_response)
 
-        if Profiler is None:
-            message = 'pyinstrument is required for profiling.'
-            raise ImportError(message)
-
         configuration = {
             'PROFILING_DIR': os.getenv('PROFILING_DIR', '.profile'),
             'PROFILING_ENABLED': os.getenv('PROFILING_ENABLED', 'False') == 'True',
+            'PROFILING_MAX_FILES': int(os.getenv('PROFILING_MAX_FILES', '10')),
+            'PROFILE_THRESHOLD': float(os.getenv('PROFILE_THRESHOLD', '0')),
         }
 
         directory = configuration.get('PROFILING_DIR', '.profile')
@@ -97,32 +98,28 @@ class ProfilingMiddleware(MiddlewareMixin):
         self.directory.mkdir(exist_ok=True)
 
         self.enabled = configuration.get('PROFILING_ENABLED', False)
-        self.profile_threshold = configuration.get('PROFILE_THRESHOLD', 0)
+        self.threshold = configuration.get('PROFILE_THRESHOLD', 0)
+        self.maximum = configuration.get('PROFILING_MAX_FILES', 10)
 
         self.count = 0
         self.lock = threading.Lock()
 
-    def _remove_profile(self) -> None:
-        files = self.directory.glob('*.html')
-        profiles = list(files)
+    def _remove_profiles(self) -> None:
+        files = list(self.directory.glob('*.html'))
+
+        if len(files) <= self.maximum:
+            return
 
-        profiles.sort(
-            key=lambda p: p.stat().st_mtime,
+        files.sort(
+            key=lambda p: p.stat().st_mtime if p.exists() else 0,
             reverse=True
         )
 
-        maximum = 10
-
-        if len(profiles) > maximum:
-            for profile in profiles[maximum:]:
+        for profile in files[self.maximum:]:
+            if profile.exists():
                 profile.unlink()
 
-    def _save_profile(
-        self,
-        profiler: Profiler,
-        request: HttpRequest,
-        duration_ms: float
-    ) -> None:
+    def _save_profile(self, profiler: Profiler, request: HttpRequest, duration: float) -> None:
         with self.lock:
             timestamp = int(time.time() * 1000)
             method = request.method
@@ -131,21 +128,29 @@ class ProfilingMiddleware(MiddlewareMixin):
             if not path or path == '_':
                 path = 'root'
 
-            filename = f'{timestamp}_{method}_{path}_{duration_ms:.1f}ms_{request._profiling_id}.html'
-
-            path = str(self.directory / filename)
-            profiler.write_html(path)
+            profileid = request._profiling_id
+            filename = f'{timestamp}_{method}_{path}_{duration:.1f}ms_{profileid}.html'
+            filepath = self.directory / filename
 
-            self._remove_profile()
+            with lock:
+                profiler.write_html(str(filepath))
+                self._remove_profiles()
 
-    def _should_skip_profiling(self, request: HttpRequest) -> bool:
+    def _should_skip(self, request: HttpRequest) -> bool:
         path = request.path
 
-        return (
-            any(path.startswith(pattern) or pattern in path for pattern in IGNORE_PATH) or
-            any(path.endswith(extension) or extension in path for extension in IGNORE_EXTENSION)
+        path_match = any(
+            path.startswith(pattern) or pattern in path
+            for pattern in IGNORE_PATH
         )
 
+        extension_match = any(
+            path.endswith(extension) or extension in path
+            for extension in IGNORE_EXTENSION
+        )
+
+        return path_match or extension_match
+
     def process_view(
         self,
         request: HttpRequest,
@@ -159,7 +164,7 @@ class ProfilingMiddleware(MiddlewareMixin):
         if not self.enabled:
             return None
 
-        if self._should_skip_profiling(request):
+        if self._should_skip(request):
             return None
 
         with self.lock:
@@ -167,7 +172,7 @@ class ProfilingMiddleware(MiddlewareMixin):
             request._profiling_id = self.count
 
         profiler = Profiler(interval=0.001)
-        start_time = time.time()
+        start = time.time()
         profiler.start()
 
         try:
@@ -177,15 +182,15 @@ class ProfilingMiddleware(MiddlewareMixin):
                 response.render()
         except Exception:
             profiler.stop()
-            duration_ms = (time.time() - start_time) * 1000
-            self._save_profile(profiler, request, duration_ms)
+            duration = (time.time() - start) * 1000
+            self._save_profile(profiler, request, duration)
 
             raise
         else:
             profiler.stop()
-            duration_ms = (time.time() - start_time) * 1000
+            duration = (time.time() - start) * 1000
 
-            if duration_ms >= self.profile_threshold:
-                self._save_profile(profiler, request, duration_ms)
+            if duration >= self.threshold:
+                self._save_profile(profiler, request, duration)
 
             return response