django-cfg 1.1.82__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/management/commands/auto_generate.py

@@ -0,0 +1,482 @@
+"""
+Auto Generation Command for Django Config Toolkit
+Generate configuration files, models, and other Django components.
+"""
+
+import os
+import json
+from pathlib import Path
+from django.core.management.base import BaseCommand
+from django.core.management import call_command
+from django.conf import settings
+import questionary
+from datetime import datetime
+
+from django_cfg import ConfigToolkit
+
+
+class Command(BaseCommand):
+    help = 'Auto-generate configuration files and Django components'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--config',
+            action='store_true',
+            help='Generate configuration files only'
+        )
+        parser.add_argument(
+            '--models',
+            action='store_true',
+            help='Generate model files only'
+        )
+        parser.add_argument(
+            '--all',
+            action='store_true',
+            help='Generate all components'
+        )
+
+    def handle(self, *args, **options):
+        if options['all']:
+            self.generate_all()
+        elif options['config']:
+            self.generate_config_files()
+        elif options['models']:
+            self.generate_model_files()
+        else:
+            self.show_interactive_menu()
+
+    def show_interactive_menu(self):
+        """Show interactive menu with generation options"""
+        self.stdout.write(self.style.SUCCESS('\n🚀 Auto Generation Tool - Django Config Toolkit\n'))
+
+        choices = [
+            questionary.Choice('⚙️  Generate Configuration Files', value='config'),
+            questionary.Choice('📊 Generate Model Files', value='models'),
+            questionary.Choice('🔄 Generate All Components', value='all'),
+            questionary.Choice('📝 Generate Environment Template', value='env'),
+            questionary.Choice('🔧 Generate Settings Template', value='settings'),
+            questionary.Choice('❌ Exit', value='exit')
+        ]
+
+        choice = questionary.select(
+            'Select generation option:',
+            choices=choices
+        ).ask()
+
+        if choice == 'config':
+            self.generate_config_files()
+        elif choice == 'models':
+            self.generate_model_files()
+        elif choice == 'all':
+            self.generate_all()
+        elif choice == 'env':
+            self.generate_env_template()
+        elif choice == 'settings':
+            self.generate_settings_template()
+        elif choice == 'exit':
+            self.stdout.write('Goodbye! 👋')
+            return
+
+    def generate_all(self):
+        """Generate all components"""
+        self.stdout.write(self.style.SUCCESS('🔄 Generating all components...'))
+        
+        self.generate_config_files()
+        self.generate_model_files()
+        self.generate_env_template()
+        self.generate_settings_template()
+        
+        self.stdout.write(self.style.SUCCESS('✅ All components generated!'))
+
+    def generate_config_files(self):
+        """Generate configuration files"""
+        self.stdout.write(self.style.SUCCESS('⚙️  Generating configuration files...'))
+        
+        # Generate config.py
+        self.generate_config_py()
+        
+        # Generate database config
+        self.generate_database_config()
+        
+        # Generate security config
+        self.generate_security_config()
+        
+        self.stdout.write(self.style.SUCCESS('✅ Configuration files generated!'))
+
+    def generate_model_files(self):
+        """Generate model files"""
+        self.stdout.write(self.style.SUCCESS('📊 Generating model files...'))
+        
+        # Generate base models
+        self.generate_base_models()
+        
+        # Generate API models
+        self.generate_api_models()
+        
+        self.stdout.write(self.style.SUCCESS('✅ Model files generated!'))
+
+    def generate_config_py(self):
+        """Generate main config.py file"""
+        config_content = '''"""
+Configuration file for Django Config Toolkit
+Auto-generated configuration with smart defaults.
+"""
+
+from django_cfg import ConfigToolkit
+
+# Initialize configuration
+config = ConfigToolkit()
+
+# Export all settings
+globals().update(config.get_django_settings())
+
+# Type-safe access to configuration
+DEBUG = config.debug
+SECRET_KEY = config.secret_key
+DATABASE_URL = config.database_url
+ALLOWED_HOSTS = config.allowed_hosts
+'''
+        
+        config_path = Path('config.py')
+        if not config_path.exists():
+            with open(config_path, 'w') as f:
+                f.write(config_content)
+            self.stdout.write(f'  📄 Created {config_path}')
+
+    def generate_database_config(self):
+        """Generate database configuration"""
+        db_config_content = '''"""
+Database Configuration
+Auto-generated database settings.
+"""
+
+from django_cfg import DatabaseConfig
+
+# Database configuration
+db_config = DatabaseConfig(
+    database_url="sqlite:///db.sqlite3",
+    max_connections=20,
+    conn_max_age=600,
+    conn_health_checks=True,
+    ssl_require=False,
+    ssl_mode="prefer",
+    query_timeout=30,
+)
+
+# Additional databases (uncomment and configure as needed)
+# db_config.read_replica_url = "postgresql://user:pass@host:port/db"
+# db_config.cache_db_url = "redis://localhost:6379/1"
+# db_config.analytics_db_url = "postgresql://user:pass@host:port/analytics"
+
+# Export database settings
+globals().update(db_config.to_django_settings())
+'''
+        
+        db_config_path = Path('database_config.py')
+        if not db_config_path.exists():
+            with open(db_config_path, 'w') as f:
+                f.write(db_config_content)
+            self.stdout.write(f'  📄 Created {db_config_path}')
+
+    def generate_security_config(self):
+        """Generate security configuration"""
+        security_config_content = '''"""
+Security Configuration
+Auto-generated security settings.
+"""
+
+from django_cfg import SecurityConfig
+
+# Security configuration
+security_config = SecurityConfig(
+    secret_key="your-secret-key-here",
+    debug=False,
+    allowed_hosts=["localhost", "127.0.0.1"],
+    csrf_trusted_origins=["http://localhost:3000"],
+    cors_allowed_origins=["http://localhost:3000"],
+    cors_allowed_methods=["GET", "POST", "PUT", "DELETE"],
+    cors_allowed_headers=["*"],
+)
+
+# Export security settings
+globals().update(security_config.to_django_settings())
+'''
+        
+        security_config_path = Path('security_config.py')
+        if not security_config_path.exists():
+            with open(security_config_path, 'w') as f:
+                f.write(security_config_content)
+            self.stdout.write(f'  📄 Created {security_config_path}')
+
+    def generate_base_models(self):
+        """Generate base model files"""
+        base_models_content = '''"""
+Base Models
+Auto-generated base model classes.
+"""
+
+from django.db import models
+from django.utils import timezone
+
+
+class BaseModel(models.Model):
+    """Base model with common fields."""
+    
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    is_active = models.BooleanField(default=True)
+    
+    class Meta:
+        abstract = True
+    
+    def __str__(self):
+        return f"{self.__class__.__name__} {self.id}"
+
+
+class TimestampedModel(BaseModel):
+    """Model with timestamps."""
+    
+    created_by = models.ForeignKey(
+        'auth.User',
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='%(class)s_created'
+    )
+    updated_by = models.ForeignKey(
+        'auth.User',
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='%(class)s_updated'
+    )
+    
+    class Meta:
+        abstract = True
+'''
+        
+        base_models_path = Path('models/base.py')
+        base_models_path.parent.mkdir(exist_ok=True)
+        
+        if not base_models_path.exists():
+            with open(base_models_path, 'w') as f:
+                f.write(base_models_content)
+            self.stdout.write(f'  📄 Created {base_models_path}')
+
+    def generate_api_models(self):
+        """Generate API model files"""
+        api_models_content = '''"""
+API Models
+Auto-generated API model classes.
+"""
+
+from django.db import models
+from .base import BaseModel
+
+
+class APIModel(BaseModel):
+    """Base model for API resources."""
+    
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True)
+    slug = models.SlugField(max_length=255, unique=True)
+    
+    class Meta:
+        abstract = True
+    
+    def __str__(self):
+        return self.name
+
+
+class ConfigModel(APIModel):
+    """Configuration model for storing settings."""
+    
+    key = models.CharField(max_length=255, unique=True)
+    value = models.JSONField()
+    value_type = models.CharField(
+        max_length=50,
+        choices=[
+            ('string', 'String'),
+            ('integer', 'Integer'),
+            ('float', 'Float'),
+            ('boolean', 'Boolean'),
+            ('json', 'JSON'),
+        ],
+        default='string'
+    )
+    
+    class Meta:
+        verbose_name = 'Configuration'
+        verbose_name_plural = 'Configurations'
+'''
+        
+        api_models_path = Path('models/api.py')
+        api_models_path.parent.mkdir(exist_ok=True)
+        
+        if not api_models_path.exists():
+            with open(api_models_path, 'w') as f:
+                f.write(api_models_content)
+            self.stdout.write(f'  📄 Created {api_models_path}')
+
+    def generate_env_template(self):
+        """Generate environment template file"""
+        env_template_content = '''# Environment Configuration Template
+# Copy this file to .env and configure your settings
+
+# Django Settings
+DEBUG=True
+SECRET_KEY=your-secret-key-here
+ALLOWED_HOSTS=localhost,127.0.0.1
+
+# Database Settings
+DATABASE_URL=sqlite:///db.sqlite3
+# DATABASE_URL=postgresql://user:password@localhost:5432/dbname
+# DATABASE_URL=mysql://user:password@localhost:3306/dbname
+
+# Additional Databases (optional)
+# DATABASE_URL_CARS=postgresql://user:password@localhost:5432/cars_db
+# DATABASE_URL_ANALYTICS=postgresql://user:password@localhost:5432/analytics_db
+# DATABASE_URL_CACHE=redis://localhost:6379/1
+
+# Email Settings
+EMAIL_BACKEND=django.core.mail.backends.console.EmailBackend
+EMAIL_HOST=smtp.gmail.com
+EMAIL_PORT=587
+EMAIL_USE_TLS=True
+EMAIL_HOST_USER=your-email@gmail.com
+EMAIL_HOST_PASSWORD=your-app-password
+
+# Cache Settings
+CACHE_BACKEND=django.core.cache.backends.locmem.LocMemCache
+# CACHE_BACKEND=django.core.cache.backends.redis.RedisCache
+# CACHE_LOCATION=redis://127.0.0.1:6379/1
+
+# Security Settings
+CSRF_TRUSTED_ORIGINS=http://localhost:3000
+CORS_ALLOWED_ORIGINS=http://localhost:3000
+
+# API Settings
+API_KEY=your-api-key-here
+API_RATE_LIMIT=1000
+
+# Logging Settings
+LOG_LEVEL=INFO
+LOG_FILE=logs/app.log
+'''
+        
+        env_template_path = Path('.env.template')
+        if not env_template_path.exists():
+            with open(env_template_path, 'w') as f:
+                f.write(env_template_content)
+            self.stdout.write(f'  📄 Created {env_template_path}')
+
+    def generate_settings_template(self):
+        """Generate Django settings template"""
+        settings_template_content = '''"""
+Django Settings Template
+Auto-generated Django settings with Django Config Toolkit.
+"""
+
+import os
+from pathlib import Path
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+# Import configuration from Django Config Toolkit
+from django_cfg import ConfigToolkit
+
+# Initialize configuration
+config = ConfigToolkit()
+
+# Export all settings
+globals().update(config.get_django_settings())
+
+# Application definition
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    
+    # Third party apps
+    'rest_framework',
+    'corsheaders',
+    'django_cfg',
+    
+    # Local apps
+    # Add your apps here
+]
+
+MIDDLEWARE = [
+    'corsheaders.middleware.CorsMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'project.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [BASE_DIR / 'templates'],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'project.wsgi.application'
+
+# Static files (CSS, JavaScript, Images)
+STATIC_URL = '/static/'
+STATIC_ROOT = BASE_DIR / 'staticfiles'
+STATICFILES_DIRS = [BASE_DIR / 'static']
+
+# Media files
+MEDIA_URL = '/media/'
+MEDIA_ROOT = BASE_DIR / 'media'
+
+# Default primary key field type
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+# REST Framework settings
+REST_FRAMEWORK = {
+    'DEFAULT_AUTHENTICATION_CLASSES': [
+        'rest_framework.authentication.SessionAuthentication',
+        'rest_framework.authentication.TokenAuthentication',
+    ],
+    'DEFAULT_PERMISSION_CLASSES': [
+        'rest_framework.permissions.IsAuthenticated',
+    ],
+    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
+    'PAGE_SIZE': 20,
+}
+
+# Health check URLs
+HEALTH_CHECK_URLS = [
+    'health/',
+    'health/detailed/',
+    'ready/',
+    'alive/',
+]
+'''
+        
+        settings_template_path = Path('settings_template.py')
+        if not settings_template_path.exists():
+            with open(settings_template_path, 'w') as f:
+                f.write(settings_template_content)
+            self.stdout.write(f'  📄 Created {settings_template_path}')

django_cfg/management/commands/migrator.py

@@ -143,16 +143,13 @@ class Command(BaseCommand):
             # Migrate each app
             for app in apps:
                 try:
-                    # Convert full module path to app_label if needed
-                    app_label = self.get_app_label_from_path(app)
-                    
                     # Skip apps without migrations
-                    if not self.app_has_migrations(app_label):
-                        # self.stdout.write(f"  ⚠️  Skipping {app_label} - no migrations")
+                    if not self.app_has_migrations(app):
+                        # self.stdout.write(f"  ⚠️  Skipping {app} - no migrations")
                         continue
 
-                    self.stdout.write(f"  📦 Migrating {app_label}...")
-                    call_command("migrate", app_label, database=db_name, verbosity=1)
+                    self.stdout.write(f"  📦 Migrating {app}...")
+                    call_command("migrate", app, database=db_name, verbosity=1)
                 except Exception as e:
                     self.stdout.write(self.style.WARNING(f"  ⚠️  Warning migrating {app}: {e}"))
 
@@ -188,11 +185,9 @@ class Command(BaseCommand):
         for db_name in databases:
             apps = self.get_apps_for_database(db_name)
             if app_name in apps:
-                # Convert full module path to app_label if needed
-                app_label = self.get_app_label_from_path(app_name)
-                self.stdout.write(f"  📊 Migrating {app_label} on {db_name}...")
+                self.stdout.write(f"  📊 Migrating {app_name} on {db_name}...")
                 try:
-                    call_command("migrate", app_label, database=db_name, verbosity=1)
+                    call_command("migrate", app_name, database=db_name, verbosity=1)
                 except Exception as e:
                     self.stdout.write(self.style.WARNING(f"  ⚠️  Warning: {e}"))
 
@@ -270,43 +265,19 @@ class Command(BaseCommand):
             self.stdout.write(self.style.ERROR(f"❌ Error getting Django config info: {e}"))
 
     def get_apps_for_database(self, db_name: str):
-        """Get apps for specific database using Django-CFG configuration"""
-        try:
-            # Try to get Django-CFG config
-            from django_cfg.core.config import get_current_config
-            config = get_current_config()
-            
-            if config and hasattr(config, 'databases'):
-                if db_name in config.databases:
-                    db_config = config.databases[db_name]
-                    if hasattr(db_config, 'apps') and db_config.apps:
-                        return db_config.apps
-                        
-                # For default database, get all apps not in other databases
-                if db_name == "default":
-                    all_apps = self.get_all_installed_apps()
-                    apps_in_other_dbs = set()
-                    
-                    # Collect apps from all non-default databases
-                    for other_db_name, other_db_config in config.databases.items():
-                        if other_db_name != "default" and hasattr(other_db_config, 'apps'):
-                            # Convert full paths to app_labels for comparison
-                            for app_path in other_db_config.apps:
-                                app_label = self.get_app_label_from_path(app_path)
-                                apps_in_other_dbs.add(app_label)
-                    
-                    return [app for app in all_apps if app not in apps_in_other_dbs]
-            
-        except Exception as e:
-            self.stdout.write(self.style.WARNING(f"⚠️  Could not get Django-CFG config: {e}"))
-        
-        # Fallback to old routing rules method
-        routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
+        """Get apps for specific database with smart logic for default"""
         if db_name == "default":
+            # For default database, get all apps that are not in other databases
             all_apps = self.get_all_installed_apps()
-            apps_in_other_dbs = set(routing_rules.keys())
+            apps_in_other_dbs = self.get_apps_in_other_databases()
             return [app for app in all_apps if app not in apps_in_other_dbs]
         else:
+            # For other databases, use configured apps from routing rules
+            routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
+
+            # Routing rules are now in Django settings
+            pass
+
             return [app for app, db in routing_rules.items() if db == db_name]
 
     def get_all_installed_apps(self):
@@ -333,26 +304,11 @@ class Command(BaseCommand):
 
     def get_apps_in_other_databases(self) -> set:
         """Get all apps that are configured for non-default databases."""
-        try:
-            # Try to get Django-CFG config
-            from django_cfg.core.config import get_current_config
-            config = get_current_config()
-            
-            if config and hasattr(config, 'databases'):
-                apps_in_other_dbs = set()
-                
-                # Collect apps from all non-default databases
-                for db_name, db_config in config.databases.items():
-                    if db_name != "default" and hasattr(db_config, 'apps'):
-                        apps_in_other_dbs.update(db_config.apps)
-                
-                return apps_in_other_dbs
-                
-        except Exception:
-            pass
-        
-        # Fallback to old routing rules method
         routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
+
+        # Routing rules are now in Django settings
+        pass
+
         return set(routing_rules.keys())
 
     def get_all_database_names(self):
@@ -432,41 +388,3 @@ class Command(BaseCommand):
         except Exception:
             # Silently return False for apps that don't exist or have issues
             return False
-
-    def get_app_label_from_path(self, app_path: str) -> str:
-        """
-        Convert full module path to Django app_label.
-        
-        Args:
-            app_path: Full module path (e.g., 'apps.vehicles_data') or app_label (e.g., 'vehicles_data')
-            
-        Returns:
-            Django app_label that can be used with migrate command
-            
-        Examples:
-            'apps.vehicles_data' -> 'vehicles_data'
-            'vehicles_data' -> 'vehicles_data'
-            'myproject.apps.blog' -> 'blog'
-        """
-        try:
-            # Try to get app config by full path first
-            try:
-                app_config = apps.get_app_config(app_path)
-                return app_config.label
-            except LookupError:
-                pass
-            
-            # Fallback: extract last part of the path as potential app_label
-            potential_label = app_path.split('.')[-1]
-            try:
-                app_config = apps.get_app_config(potential_label)
-                return app_config.label
-            except LookupError:
-                pass
-                
-            # If all fails, return original path
-            return app_path
-            
-        except Exception:
-            # Fallback to original path
-            return app_path

django_cfg/management/commands/test_email.py

@@ -71,7 +71,7 @@ class Command(BaseCommand):
                     'main_text': message,
                     'project_name': 'Django CFG Sample',
                     'site_url': 'http://localhost:8000',
-                    'logo_url': 'https://unrealos.com/favicon.png',
+                    'logo_url': 'https://djangocfg.com/favicon.png',
                     'button_text': 'Visit Website',
                     'button_url': 'http://localhost:8000',
                     'secondary_text': 'This is a test email sent from django-cfg management command.',