django-cfg 1.4.10__py3-none-any.whl → 1.4.13__py3-none-any.whl

django_cfg/management/commands/tree.py

@@ -1,390 +1,20 @@
 """
-🌳 Django CFG Tree Command
+Django-CFG wrapper for tree command.
 
-Display Django project structure in a tree format based on configuration.
-"""
-
-import os
-import subprocess
-from pathlib import Path
-from typing import List, Optional
-
-from django.core.management.base import BaseCommand, CommandError
-from django.conf import settings
-from django_cfg.modules.django_logging import get_logger
-
-
-from django_cfg.core.state import get_current_config
-from django_cfg.utils.path_resolution import PathResolver
+This is a simple alias for django_admin.management.commands.tree.
+All logic is in django_admin module.
 
+Usage:
+    python manage.py tree
+"""
 
-logger = get_logger('tree')
+from django_cfg.modules.django_admin.management.commands.tree import Command as TreeCommand
 
-class Command(BaseCommand):
-    """Display Django project structure in tree format."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
+class Command(TreeCommand):
+    """
+    Alias for tree command.
 
-    help = "Display Django project structure based on django-cfg configuration"
-    
-    def add_arguments(self, parser):
-        """Add command arguments."""
-        parser.add_argument(
-            '--depth', '-L',
-            type=int,
-            default=5,
-            help='Maximum depth to display (default: 5)'
-        )
-        parser.add_argument(
-            '--all', '-a',
-            action='store_true',
-            help='Show all files including hidden ones'
-        )
-        parser.add_argument(
-            '--dirs-only', '-d',
-            action='store_true',
-            help='Show directories only'
-        )
-        parser.add_argument(
-            '--no-ignore', '-n',
-            action='store_true',
-            help='Do not ignore common directories (node_modules, .git, etc.)'
-        )
-        parser.add_argument(
-            '--custom-ignore',
-            type=str,
-            help='Custom ignore pattern (pipe-separated, e.g., "*.pyc|temp|logs")'
-        )
-        parser.add_argument(
-            '--include-docs',
-            action='store_true',
-            help='Legacy option - @docs directories are now included by default'
-        )
-        parser.add_argument(
-            '--include-docker',
-            action='store_true', 
-            help='Include Docker configuration and volumes'
-        )
-        parser.add_argument(
-            '--include-logs',
-            action='store_true',
-            help='Include log files and directories'
-        )
-        parser.add_argument(
-            '--output', '-o',
-            type=str,
-            help='Output to file instead of stdout'
-        )
-        parser.add_argument(
-            '--format',
-            choices=['tree', 'json', 'xml'],
-            default='tree',
-            help='Output format (default: tree)'
-        )
-    
-    def handle(self, *args, **options):
-        """Execute the command."""
-        logger.info("Starting tree command")
-        try:
-            # Get django-cfg configuration
-            config = get_current_config()
-            
-            # Determine base directory
-            base_dir = self.get_base_directory(config)
-            
-            self.stdout.write(
-                self.style.SUCCESS(f"📁 Django Project Structure: {base_dir}")
-            )
-            
-            # Try to get environment info
-            try:
-                env_info = getattr(config, 'env_mode', 'unknown')
-                self.stdout.write(
-                    self.style.HTTP_INFO(f"🔧 Environment: {env_info}")
-                )
-            except Exception:
-                pass
-                
-            self.stdout.write("")
-            
-            # Check if tree command is available
-            if not self.is_tree_available():
-                self.stdout.write(
-                    self.style.WARNING("⚠️  'tree' command not found. Using fallback implementation.")
-                )
-                self.display_fallback_tree(base_dir, options)
-            else:
-                self.display_tree(base_dir, options)
-                
-        except Exception as e:
-            raise CommandError(f"Failed to display project tree: {e}")
-    
-    def get_base_directory(self, config) -> Path:
-        """Get the base directory for the Django project tree."""
-        try:
-            # First try to use PathResolver to find the actual Django project root
-            return PathResolver.find_project_root()
-        except Exception:
-            try:
-                # Try to get from config
-                if hasattr(config, 'base_dir') and config.base_dir:
-                    return Path(config.base_dir)
-                
-                # Fallback to Django BASE_DIR
-                if hasattr(settings, 'BASE_DIR'):
-                    return Path(settings.BASE_DIR)
-                
-                # Last resort: current working directory
-                return Path.cwd()
-                
-            except Exception as e:
-                self.stdout.write(
-                    self.style.WARNING(f"Could not determine base directory: {e}")
-                )
-                return Path.cwd()
-    
-    def is_tree_available(self) -> bool:
-        """Check if tree command is available."""
-        try:
-            subprocess.run(['tree', '--version'], 
-                         capture_output=True, 
-                         check=True)
-            return True
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            return False
-    
-    def build_ignore_pattern(self, options) -> str:
-        """Build ignore pattern for tree command."""
-        if options['no_ignore']:
-            return ""
-        
-        # Default ignore patterns
-        default_ignores = [
-            'node_modules',
-            '.git',
-            '.venv',
-            'venv',
-            '.env',
-            '.DS_Store',
-            '__pycache__',
-            '*.pyc',
-            '*.pyo',
-            '*.pyd',
-            '.pytest_cache',
-            '.coverage',
-            'htmlcov',
-            'coverage',
-            '.tox',
-            'dist',
-            'build',
-            '*.egg-info',
-            'staticfiles',
-            'media',
-            '@old*',
-            'parsers',
-            'openapi',
-            'modules',
-            'django_cfg',
-            # Package manager files
-            'package-lock.json',
-            'pnpm-lock.yaml', 
-            'poetry.lock',
-            'yarn.lock',
-            # Empty/system directories
-            'db',
-            'static'
-        ]
-        
-        # Conditionally add patterns based on options
-        # Note: @docs folders are now included by default to show documentation
-            
-        if not options.get('include_docker'):
-            default_ignores.extend([
-                'docker',
-                'devops'
-            ])
-            
-        if not options.get('include_logs'):
-            default_ignores.extend([
-                'logs',
-                '*.log',
-                'log'
-            ])
-        
-        # Add custom ignores
-        if options['custom_ignore']:
-            custom_ignores = options['custom_ignore'].split('|')
-            default_ignores.extend(custom_ignores)
-        
-        return '|'.join(default_ignores)
-    
-    def display_tree(self, base_dir: Path, options):
-        """Display tree using system tree command."""
-        try:
-            # Build tree command
-            cmd = ['tree']
-            
-            # Add ignore pattern
-            ignore_pattern = self.build_ignore_pattern(options)
-            if ignore_pattern:
-                cmd.extend(['-I', ignore_pattern])
-            
-            # Add options
-            cmd.append('--dirsfirst')  # Directories first
-            
-            if options['depth']:
-                cmd.extend(['-L', str(options['depth'])])
-            
-            if options['dirs_only']:
-                cmd.append('-d')
-            
-            if options['all']:
-                cmd.append('-a')
-            
-            # Add format options
-            if options['format'] == 'json':
-                cmd.append('-J')
-            elif options['format'] == 'xml':
-                cmd.append('-X')
-            
-            # Add base directory
-            cmd.append(str(base_dir))
-            
-            # Execute command
-            if options['output']:
-                with open(options['output'], 'w') as f:
-                    result = subprocess.run(cmd, stdout=f, stderr=subprocess.PIPE, text=True)
-                if result.returncode == 0:
-                    self.stdout.write(
-                        self.style.SUCCESS(f"✅ Tree output saved to: {options['output']}")
-                    )
-                else:
-                    self.stdout.write(
-                        self.style.ERROR(f"❌ Tree command failed: {result.stderr}")
-                    )
-            else:
-                result = subprocess.run(cmd, text=True)
-                if result.returncode != 0:
-                    self.stdout.write(
-                        self.style.ERROR("❌ Tree command failed")
-                    )
-                    
-        except Exception as e:
-            self.stdout.write(
-                self.style.ERROR(f"❌ Failed to execute tree command: {e}")
-            )
-            self.display_fallback_tree(base_dir, options)
-    
-    def display_fallback_tree(self, base_dir: Path, options):
-        """Fallback tree implementation using Python."""
-        self.stdout.write("🐍 Using Python fallback implementation:")
-        self.stdout.write("")
-        
-        ignore_patterns = self.build_ignore_pattern(options).split('|') if not options['no_ignore'] else []
-        
-        def should_ignore(path: Path) -> bool:
-            """Check if path should be ignored."""
-            name = path.name
-            for pattern in ignore_patterns:
-                if pattern.startswith('*'):
-                    if name.endswith(pattern[1:]):
-                        return True
-                elif pattern.endswith('*'):
-                    if name.startswith(pattern[:-1]):
-                        return True
-                elif pattern == name:
-                    return True
-            return False
-        
-        def print_tree(directory: Path, prefix: str = "", depth: int = 0):
-            """Recursively print directory tree."""
-            if options['depth'] and depth >= options['depth']:
-                return
-            
-            try:
-                items = []
-                for item in directory.iterdir():
-                    if not options['all'] and item.name.startswith('.'):
-                        continue
-                    if should_ignore(item):
-                        continue
-                    items.append(item)
-                
-                # Sort: directories first, then files
-                items.sort(key=lambda x: (not x.is_dir(), x.name.lower()))
-                
-                for i, item in enumerate(items):
-                    is_last = i == len(items) - 1
-                    current_prefix = "└── " if is_last else "├── "
-                    
-                    if item.is_dir():
-                        self.stdout.write(f"{prefix}{current_prefix}📁 {item.name}/")
-                        if not options['dirs_only']:
-                            next_prefix = prefix + ("    " if is_last else "│   ")
-                            print_tree(item, next_prefix, depth + 1)
-                    elif not options['dirs_only']:
-                        # Add file type emoji
-                        emoji = self.get_file_emoji(item)
-                        self.stdout.write(f"{prefix}{current_prefix}{emoji} {item.name}")
-                        
-            except PermissionError:
-                self.stdout.write(f"{prefix}❌ Permission denied")
-        
-        print_tree(base_dir)
-    
-    def get_file_emoji(self, file_path: Path) -> str:
-        """Get emoji for file type."""
-        suffix = file_path.suffix.lower()
-        
-        emoji_map = {
-            '.py': '🐍',
-            '.js': '📜',
-            '.ts': '📘',
-            '.html': '🌐',
-            '.css': '🎨',
-            '.scss': '🎨',
-            '.json': '📋',
-            '.yaml': '📄',
-            '.yml': '📄',
-            '.toml': '⚙️',
-            '.ini': '⚙️',
-            '.cfg': '⚙️',
-            '.conf': '⚙️',
-            '.md': '📝',
-            '.txt': '📄',
-            '.log': '📊',
-            '.sql': '🗄️',
-            '.db': '🗄️',
-            '.sqlite': '🗄️',
-            '.sqlite3': '🗄️',
-            '.png': '🖼️',
-            '.jpg': '🖼️',
-            '.jpeg': '🖼️',
-            '.gif': '🖼️',
-            '.svg': '🖼️',
-            '.ico': '🖼️',
-            '.pdf': '📕',
-            '.zip': '📦',
-            '.tar': '📦',
-            '.gz': '📦',
-            '.requirements': '📋',
-            'requirements.txt': '📋',
-            'Dockerfile': '🐳',
-            'docker-compose.yml': '🐳',
-            'manage.py': '⚙️',
-            'setup.py': '⚙️',
-            'pyproject.toml': '📦',
-            'poetry.lock': '🔒',
-            'Pipfile': '📦',
-            'Pipfile.lock': '🔒',
-        }
-        
-        # Check full filename first
-        if file_path.name in emoji_map:
-            return emoji_map[file_path.name]
-        
-        # Then check extension
-        return emoji_map.get(suffix, '📄')
+    Simply inherits from TreeCommand without any changes.
+    """
+    pass

django_cfg/management/commands/validate_openapi.py

@@ -0,0 +1,10 @@
+"""
+Alias for validate_openapi command.
+
+This is an alias that delegates to the actual implementation in
+django_cfg.modules.django_client.management.commands.validate_openapi
+
+For backward compatibility and discoverability.
+"""
+
+from django_cfg.modules.django_client.management.commands.validate_openapi import Command  # noqa: F401

django_cfg/middleware/README.md

@@ -47,7 +47,7 @@ The middleware intelligently detects API requests using:
 3. **REST methods** (POST, PUT, PATCH, DELETE) on non-admin paths
 
 4. **Configured API prefixes**
-   - Django Revolution API: `/{api_prefix}/` (from config)
+   - Django Client API: `/{api_prefix}/` (from config)
    - Django CFG API: `/cfg/` (always)
 
 ### 📊 Statistics

django_cfg/middleware/user_activity.py

@@ -103,9 +103,9 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
         try:
             config = self.get_config()
             if config:
-                # Check Django Revolution API prefix
-                if hasattr(config, 'revolution') and config.revolution:
-                    api_prefix = f"/{getattr(config.revolution, 'api_prefix', 'api')}/"
+                # Check Django Client (OpenAPI) API prefix
+                if hasattr(config, 'openapi_client') and config.openapi_client:
+                    api_prefix = f"/{getattr(config.openapi_client, 'api_prefix', 'api')}/"
                     if path.startswith(api_prefix):
                         return True
                 

django_cfg/models/__init__.py

@@ -38,7 +38,7 @@ from .api.drf.redoc import RedocUISettings
 # Django-specific
 from .django.environment import EnvironmentConfig
 from .django.constance import ConstanceConfig, ConstanceField
-from .django.revolution import RevolutionConfig
+from .django.openapi import OpenAPIClientConfig
 
 # Services
 from .services.email import EmailConfig
@@ -80,7 +80,7 @@ __all__ = [
     "EnvironmentConfig",
     "ConstanceConfig",
     "ConstanceField",
-    "RevolutionConfig",
+    "OpenAPIClientConfig",
     "UnfoldConfig",
     # Services
     "EmailConfig",

django_cfg/models/api/drf/spectacular.py

@@ -54,8 +54,8 @@ class SpectacularConfig(BaseModel):
         description="Post-processing hooks"
     )
 
-    # NOTE: Enum generation settings are handled by django-revolution
-    # Only override if you need different values than Revolution defaults
+    # NOTE: Enum generation settings are handled by django-client (OpenAPI)
+    # Only override if you need different values than django-client defaults
 
     # Enum overrides
     enum_name_overrides: Dict[str, str] = Field(
@@ -69,7 +69,7 @@ class SpectacularConfig(BaseModel):
         """
         Get django-cfg Spectacular extensions.
 
-        NOTE: This extends Revolution's base settings, not replaces them.
+        NOTE: This extends django-client's base settings, not replaces them.
         Only include settings that are unique to django-cfg or critical fixes.
 
         Args:
@@ -77,13 +77,13 @@ class SpectacularConfig(BaseModel):
         """
         settings = {
             # django-cfg specific UI enhancements
-            "REDOC_UI_SETTINGS": self.redoc_ui_settings.to_dict(),  # Revolution doesn't have custom Redoc settings
+            "REDOC_UI_SETTINGS": self.redoc_ui_settings.to_dict(),  # django-client doesn't have custom Redoc settings
 
             # django-cfg specific processing extensions
             "ENUM_NAME_OVERRIDES": self.enum_name_overrides,  # Custom enum overrides
 
-            # CRITICAL: Ensure enum generation is always enabled (fix Revolution gaps)
-            # These settings ensure proper enum generation even if Revolution config changes
+            # CRITICAL: Ensure enum generation is always enabled (fix django-client gaps)
+            # These settings ensure proper enum generation even if django-client config changes
             "GENERATE_ENUM_FROM_CHOICES": True,
             "ENUM_GENERATE_CHOICE_FROM_PATH": True,
             "ENUM_NAME_SUFFIX": "Enum",

django_cfg/models/django/__init__.py

@@ -6,11 +6,11 @@ Django integrations and extensions.
 
 from .environment import EnvironmentConfig
 from .constance import ConstanceConfig, ConstanceField
-from .revolution import RevolutionConfig
+from .openapi import OpenAPIClientConfig
 
 __all__ = [
     "EnvironmentConfig",
     "ConstanceConfig",
     "ConstanceField",
-    "RevolutionConfig",
+    "OpenAPIClientConfig",
 ]

django_cfg/models/django/openapi.py

@@ -0,0 +1,162 @@
+"""
+Django Client (OpenAPI) Configuration with DRF Integration
+
+Extended configuration model that integrates openapi_client for automatic
+TypeScript and Python client generation from Django REST Framework endpoints.
+
+This replaces django-revolution with a cleaner, faster, type-safe implementation.
+"""
+
+from typing import Dict, Any, Optional
+from pydantic import Field
+from django_cfg.modules.django_client.core.config import OpenAPIConfig, OpenAPIGroupConfig
+
+
+class OpenAPIClientConfig(OpenAPIConfig):
+    """
+    Extended OpenAPI configuration with DRF parameters for django-cfg integration.
+
+    This extends the base OpenAPIConfig to include DRF-specific
+    parameters and django-cfg integration helpers.
+
+    Example:
+        ```python
+        from django_cfg import OpenAPIClientConfig, OpenAPIGroupConfig
+
+        config = OpenAPIClientConfig(
+            enabled=True,
+            groups=[
+                OpenAPIGroupConfig(
+                    name='api',
+                    apps=['users', 'posts'],
+                    title='Main API',
+                    version='v1',
+                ),
+            ],
+            drf_title='My API',
+            drf_description='REST API for my project',
+        )
+        ```
+    """
+
+    # DRF Configuration parameters for automatic DRF setup
+    drf_title: str = Field(
+        default="API",
+        description="API title for DRF Spectacular"
+    )
+    drf_description: str = Field(
+        default="RESTful API",
+        description="API description for DRF Spectacular"
+    )
+    drf_version: str = Field(
+        default="1.0.0",
+        description="API version for DRF Spectacular"
+    )
+    drf_schema_path_prefix: Optional[str] = Field(
+        default=None,  # Will default to "/api/" if None
+        description="Schema path prefix for DRF Spectacular"
+    )
+    drf_enable_browsable_api: bool = Field(
+        default=False,
+        description="Enable DRF browsable API"
+    )
+    drf_enable_throttling: bool = Field(
+        default=False,
+        description="Enable DRF throttling"
+    )
+    drf_serve_include_schema: bool = Field(
+        default=False,
+        description="Include schema in Spectacular UI"
+    )
+
+    # Django-cfg specific integration
+    api_prefix: str = Field(
+        default="api",
+        description="API prefix for URL routing (e.g., 'api' -> /api/...)"
+    )
+
+    def get_drf_schema_path_prefix(self) -> str:
+        """Get the schema path prefix, defaulting to api_prefix if not set."""
+        if self.drf_schema_path_prefix:
+            return self.drf_schema_path_prefix
+        return f"/{self.api_prefix}/"
+
+    def get_drf_config_kwargs(self) -> Dict[str, Any]:
+        """
+        Get kwargs for DRF configuration from this config.
+
+        Returns:
+            Dict of parameters for DRF + Spectacular setup
+        """
+        return {
+            "title": self.drf_title,
+            "description": self.drf_description,
+            "version": self.drf_version,
+            "schema_path_prefix": self.get_drf_schema_path_prefix(),
+            "enable_browsable_api": self.drf_enable_browsable_api,
+            "enable_throttling": self.drf_enable_throttling,
+            "serve_include_schema": self.drf_serve_include_schema,
+            # REQUIRED by django-client for correct Request/Response split
+            "component_split_request": True,
+            "component_split_patch": True,
+        }
+
+    def get_groups_with_defaults(self) -> Dict[str, OpenAPIGroupConfig]:
+        """
+        Get groups with django-cfg default groups automatically added.
+
+        Returns:
+            Dict of groups including default django-cfg groups
+        """
+        # Convert list to dict for compatibility
+        groups_dict = {group.name: group for group in self.groups}
+
+        # Add default django-cfg groups if enabled
+        try:
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
+
+            support_enabled = base_module.is_support_enabled()
+            accounts_enabled = base_module.is_accounts_enabled()
+            newsletter_enabled = base_module.is_newsletter_enabled()
+            leads_enabled = base_module.is_leads_enabled()
+            knowbase_enabled = base_module.is_knowbase_enabled()
+            agents_enabled = base_module.is_agents_enabled()
+            tasks_enabled = base_module.should_enable_tasks()
+            payments_enabled = base_module.is_payments_enabled()
+
+            # Collect all enabled django-cfg apps for unified group
+            enabled_cfg_apps = []
+            if support_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.support")
+            if accounts_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.accounts")
+            if newsletter_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.newsletter")
+            if leads_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.leads")
+            if knowbase_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.knowbase")
+            if agents_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.agents")
+            if tasks_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.tasks")
+            if payments_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.payments")
+
+            # Add unified 'cfg' group with all enabled apps
+            if enabled_cfg_apps and 'cfg' not in groups_dict:
+                groups_dict['cfg'] = OpenAPIGroupConfig(
+                    name="cfg",
+                    apps=enabled_cfg_apps,
+                    title="Django-CFG API",
+                    description="All django-cfg built-in applications",
+                )
+
+            return groups_dict
+
+        except Exception:
+            pass
+
+        return groups_dict
+