django-cfg 1.2.29__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/core/integration/url_integration.py

@@ -0,0 +1,123 @@
+"""
+Django CFG URL integration utilities.
+
+Provides automatic URL registration for django_cfg endpoints and integrations.
+"""
+
+from typing import List
+from django.urls import path, include, URLPattern
+from django_cfg.core.environment import EnvironmentDetector
+from django.conf import settings
+
+
+def add_django_cfg_urls(urlpatterns: List[URLPattern], cfg_prefix: str = "cfg/") -> List[URLPattern]:
+    """
+    Automatically add django_cfg URLs and all integrations to the main URL configuration.
+    
+    This function adds:
+    - Django CFG management URLs (cfg/)
+    - Django Revolution URLs (if available)
+    - Startup information display (based on config)
+    
+    Args:
+        urlpatterns: Existing URL patterns list
+        cfg_prefix: URL prefix for django_cfg endpoints (default: "cfg/")
+        
+    Returns:
+        Updated URL patterns list with all URLs added
+        
+    Example:
+        # In your main urls.py
+        from django_cfg import add_django_cfg_urls
+        
+        urlpatterns = [
+            path("", home_view, name="home"),
+            path("admin/", admin.site.urls),
+        ]
+        
+        # Automatically adds:
+        # - path("cfg/", include("django_cfg.apps.urls"))
+        # - Django Revolution URLs (if available)
+        # - Startup info display (based on config.startup_info_mode)
+        urlpatterns = add_django_cfg_urls(urlpatterns)
+    """
+    # Add django_cfg API URLs
+    new_patterns = urlpatterns + [
+        path(cfg_prefix, include("django_cfg.apps.urls")),
+    ]
+    
+    # Try to add Django Revolution URLs if available
+    try:
+        from django_revolution import add_revolution_urls
+        new_patterns = add_revolution_urls(new_patterns)
+    except ImportError:
+        # Django Revolution not available - skip
+        pass
+    
+    # Show startup info based on config
+    try:
+        from . import print_startup_info
+        print_startup_info()
+    except ImportError:
+        pass
+    
+    return new_patterns
+
+
+def get_django_cfg_urls_info() -> dict:
+    """
+    Get information about django_cfg URL integration and all integrations.
+    
+    Returns:
+        Dictionary with complete URL integration info
+    """
+    from django_cfg.config import (
+        LIB_NAME,
+        LIB_SITE_URL,
+        LIB_DOCS_URL,
+        LIB_GITHUB_URL,
+        LIB_SUPPORT_URL,
+        LIB_HEALTH_URL,
+    )
+    
+    try:
+        from django_cfg import __version__
+        version = __version__
+    except ImportError:
+        version = "unknown"
+    
+    # Get current config directly from Pydantic
+    config = None
+    try:
+        from django_cfg.core.config import get_current_config
+        config = get_current_config()
+    except Exception:
+        pass
+    
+    
+    info = {
+        "django_cfg": {
+            "version": version,
+            "prefix": "cfg/",
+            "description": LIB_NAME,
+            "site_url": LIB_SITE_URL,
+            "docs_url": LIB_DOCS_URL,
+            "github_url": LIB_GITHUB_URL,
+            "support_url": LIB_SUPPORT_URL,
+            "health_url": LIB_HEALTH_URL,
+            "env_mode": config.env_mode if config else "unknown",
+            "debug": config.debug if config else False,
+            "startup_info_mode": config.startup_info_mode if config else "full",
+        }
+    }
+    
+    # Add Django Revolution info if available
+    try:
+        from django_revolution import get_revolution_urls_info
+        revolution_info = get_revolution_urls_info()
+        if revolution_info:
+            info["django_revolution"] = revolution_info
+    except ImportError:
+        pass
+    
+    return info

django_cfg/core/integration/version_checker.py

@@ -0,0 +1,160 @@
+"""
+Version checker for django-cfg library.
+
+Checks PyPI for the latest version and caches results for 24 hours using cachetools.
+"""
+
+import importlib.metadata
+import requests
+from typing import Optional, Dict, Any
+from cachetools import TTLCache
+
+
+class VersionChecker:
+    """
+    Checks for library updates on PyPI with 24-hour caching using cachetools.
+    """
+    
+    # Cache for 24 hours (86400 seconds)
+    CACHE_TTL = 86400
+    
+    def __init__(self):
+        """Initialize version checker with TTL cache."""
+        self._cache = TTLCache(maxsize=10, ttl=self.CACHE_TTL)
+    
+    def get_package_name(self) -> str:
+        """
+        Get package name automatically using importlib.metadata.
+        
+        Returns:
+            Package name for PyPI
+        """
+        try:
+            # Get package metadata
+            metadata = importlib.metadata.metadata('django-cfg')
+            return metadata['Name']
+        except importlib.metadata.PackageNotFoundError:
+            # Fallback to hardcoded name
+            return 'django-cfg'
+    
+    def get_latest_version(self) -> Optional[str]:
+        """
+        Get latest version from PyPI with caching.
+        
+        Returns:
+            Latest version string or None if unavailable
+        """
+        # Check cache first
+        cached_version = self._cache.get('latest_version')
+        if cached_version:
+            return cached_version
+        
+        try:
+            package_name = self.get_package_name()
+            url = f"https://pypi.org/pypi/{package_name}/json"
+            
+            response = requests.get(url, timeout=5)
+            response.raise_for_status()
+            
+            data = response.json()
+            version = data["info"]["version"]
+            
+            # Cache the result
+            self._cache['latest_version'] = version
+            
+            return version
+            
+        except Exception:
+            # Silently fail - version checking is not critical
+            return None
+    
+    def get_current_version(self) -> Optional[str]:
+        """
+        Get current installed version using importlib.metadata.
+        
+        Returns:
+            Current version string or None if unavailable
+        """
+        try:
+            # First try to get from __version__
+            from django_cfg import __version__
+            return __version__
+        except ImportError:
+            try:
+                # Fallback to importlib.metadata
+                return importlib.metadata.version('django-cfg')
+            except importlib.metadata.PackageNotFoundError:
+                return None
+    
+    def check_for_updates(self) -> Dict[str, Any]:
+        """
+        Check if an update is available.
+        
+        Returns:
+            Dictionary with update information
+        """
+        current = self.get_current_version()
+        latest = self.get_latest_version()
+        
+        result = {
+            'current_version': current,
+            'latest_version': latest,
+            'update_available': False,
+            'update_url': None,
+        }
+        
+        if current and latest and current != latest:
+            # Simple version comparison (assumes semantic versioning)
+            try:
+                current_parts = [int(x) for x in current.split('.')]
+                latest_parts = [int(x) for x in latest.split('.')]
+                
+                # Pad shorter version with zeros
+                max_len = max(len(current_parts), len(latest_parts))
+                current_parts.extend([0] * (max_len - len(current_parts)))
+                latest_parts.extend([0] * (max_len - len(latest_parts)))
+                
+                if latest_parts > current_parts:
+                    result['update_available'] = True
+                    package_name = self.get_package_name()
+                    result['update_url'] = f"https://pypi.org/project/{package_name}/"
+                    
+            except (ValueError, AttributeError):
+                # Version comparison failed - skip update check
+                pass
+        
+        return result
+
+
+# Global instance
+_version_checker = VersionChecker()
+
+
+def get_version_info() -> Dict[str, Any]:
+    """
+    Get version information and update status.
+    
+    Returns:
+        Dictionary with version and update information
+    """
+    return _version_checker.check_for_updates()
+
+
+def get_latest_version() -> Optional[str]:
+    """
+    Get latest version from PyPI.
+    
+    Returns:
+        Latest version string or None if unavailable
+    """
+    return _version_checker.get_latest_version()
+
+
+def get_current_version() -> Optional[str]:
+    """
+    Get current installed version.
+    
+    Returns:
+        Current version string or None if unavailable
+    """
+    return _version_checker.get_current_version()

django_cfg/management/commands/auto_generate.py

@@ -11,9 +11,12 @@ from django.core.management import call_command
 from django.conf import settings
 import questionary
 from datetime import datetime
+from django_cfg.modules.django_logger import get_logger
 
 from django_cfg import ConfigToolkit
 
+logger = get_logger('auto_generate')
+
 
 class Command(BaseCommand):
     help = 'Auto-generate configuration files and Django components'
@@ -36,6 +39,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
+        logger.info("Starting auto_generate command")
         if options['all']:
             self.generate_all()
         elif options['config']:

django_cfg/management/commands/check_settings.py

@@ -13,11 +13,16 @@ from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.core.mail import get_connection
 from datetime import datetime
+from django_cfg.modules.django_logger import get_logger
 
 
+
+logger = get_logger('check_settings')
+
 class Command(BaseCommand):
     """Command to check and debug django-cfg settings."""
 
+
     help = "Check and debug django-cfg configuration settings"
 
     def add_arguments(self, parser):
@@ -34,6 +39,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Main command handler."""
+        logger.info("Starting check_settings command")
         self.stdout.write(self.style.SUCCESS("\n🔍 Django CFG Settings Checker\n"))
         
         # Show basic info

django_cfg/management/commands/clear_constance.py

@@ -6,12 +6,14 @@ Clear Constance configuration cache and database records.
 from django.core.management.base import BaseCommand
 from django.core.cache import cache
 from django.conf import settings
-import logging
+from django_cfg.modules.django_logger import get_logger
+
 
-logger = logging.getLogger(__name__)
 
 
 class Command(BaseCommand):
+    logger = get_logger('clear_constance')
+
     help = 'Clear Constance configuration cache and database records'
 
     def add_arguments(self, parser):
@@ -38,6 +40,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Handle the command execution."""
+        self.logger.info("Starting clear_constance command")
         self.stdout.write(self.style.SUCCESS('🧹 Constance Clear Tool - Django Config Toolkit\n'))
         
         # Check if constance is installed

django_cfg/management/commands/create_token.py

@@ -12,13 +12,18 @@ from django.contrib.auth import get_user_model
 from django.conf import settings
 import questionary
 from datetime import datetime, timedelta
+from django_cfg.modules.django_logger import get_logger
+
 
 from django_cfg import ConfigToolkit
 
 User = get_user_model()
 
 
+logger = get_logger('create_token')
+
 class Command(BaseCommand):
+
     help = 'Create API tokens and authentication tokens'
 
     def add_arguments(self, parser):
@@ -46,6 +51,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
+        logger.info("Starting create_token command")
         if options['user'] and options['type']:
             self.create_token_for_user(
                 username=options['user'],

django_cfg/management/commands/list_urls.py

@@ -9,6 +9,8 @@ import re
 from django.core.management.base import BaseCommand
 from django.urls import get_resolver
 from django.conf import settings
+from django_cfg.modules.django_logger import get_logger
+
 
 # Rich imports for beautiful output
 from rich.console import Console
@@ -20,8 +22,11 @@ from rich.align import Align
 from django_cfg.core.config import get_current_config
 
 
+logger = get_logger('list_urls')
+
 class Command(BaseCommand):
     """Command to display all available URLs in the project."""
+
     help = "Display all available URLs with Rich formatting"
     
     def __init__(self, *args, **kwargs):
@@ -53,6 +58,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
+        logger.info("Starting list_urls command")
         filter_str = options["filter"]
         webhook_only = options["webhook"]
         api_only = options["api"]

django_cfg/management/commands/migrate_all.py

@@ -6,11 +6,16 @@ Migrate all databases based on django-cfg configuration.
 from django.core.management.base import BaseCommand
 from django.core.management import call_command
 from django.apps import apps
+from django_cfg.modules.django_logger import get_logger
+
 
 from django_cfg.core.config import get_current_config
 
 
+logger = get_logger('migrate_all')
+
 class Command(BaseCommand):
+
     help = "Migrate all databases based on django-cfg configuration"
 
     def add_arguments(self, parser):
@@ -27,6 +32,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Run migrations for all configured databases."""
+        logger.info("Starting migrate_all command")
         dry_run = options.get("dry_run", False)
         skip_makemigrations = options.get("skip_makemigrations", False)
         

django_cfg/management/commands/migrator.py

@@ -14,6 +14,9 @@ from django.conf import settings
 import questionary
 from datetime import datetime
 from django_cfg.core.config import DEFAULT_APPS
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger('migrator')
 
 
 class Command(BaseCommand):

django_cfg/management/commands/rundramatiq.py

@@ -15,6 +15,8 @@ from django.apps import apps
 from django.conf import settings
 from django.core.management.base import BaseCommand
 from django.utils.module_loading import module_has_submodule
+from django_cfg.modules.django_logger import get_logger
+
 
 from django_cfg.modules.django_tasks import get_task_service
 
@@ -24,6 +26,9 @@ NPROCS = multiprocessing.cpu_count()
 NTHREADS = 8
 
 
+logger = get_logger('rundramatiq')
+
+
 class Command(BaseCommand):
     help = "Run Dramatiq workers with Django-CFG configuration."
 
@@ -77,6 +82,7 @@ class Command(BaseCommand):
 
     def handle(self, watch_dir, processes, threads, verbosity, queues, 
                pid_file, log_file, worker_shutdown_timeout, dry_run, **options):
+        logger.info("Starting rundramatiq command")
         
         # Get task service and validate
         task_service = get_task_service()

django_cfg/management/commands/runserver_ngrok.py

@@ -5,11 +5,12 @@ Simple implementation following KISS principle.
 """
 
 import os
+import time
 from django.core.management.commands.runserver import Command as RunServerCommand
 from django_cfg.modules.django_ngrok import get_ngrok_service
-import logging
+from django_cfg.modules.django_logger import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger('runserver_ngrok')
 
 
 class Command(RunServerCommand):
@@ -66,36 +67,61 @@ class Command(RunServerCommand):
         
         # Start ngrok tunnel
         ngrok_service = get_ngrok_service()
+        
+        self.stdout.write("🚇 Starting ngrok tunnel...")
+        logger.info(f"Starting ngrok tunnel for port {server_port}")
+        
         tunnel_url = ngrok_service.start_tunnel(server_port)
         
         if tunnel_url:
-            self.stdout.write(
-                self.style.SUCCESS(
-                    f"ngrok forwarding to http://127.0.0.1:{server_port} "
-                    f"from ingress url: {tunnel_url}"
-                )
-            )
+            # Wait for tunnel to be fully established
+            self.stdout.write("⏳ Waiting for tunnel to be established...")
+            logger.info("Waiting for ngrok tunnel to be fully established")
             
-            # Set environment variables for ngrok URL
-            self._set_ngrok_env_vars(tunnel_url)
+            max_retries = 10
+            retry_count = 0
+            tunnel_ready = False
             
-            # Update ALLOWED_HOSTS if needed
-            self._update_allowed_hosts(tunnel_url)
+            while retry_count < max_retries and not tunnel_ready:
+                time.sleep(1)
+                retry_count += 1
+                
+                # Check if tunnel is actually accessible
+                try:
+                    current_url = ngrok_service.get_tunnel_url()
+                    if current_url and current_url == tunnel_url:
+                        tunnel_ready = True
+                        logger.info(f"Ngrok tunnel established successfully: {tunnel_url}")
+                        break
+                except Exception as e:
+                    logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
+                
+                self.stdout.write(f"⏳ Tunnel check {retry_count}/{max_retries}...")
             
-            # Update config URLs if enabled
-            ngrok_service.update_config_urls()
-            
-            # Show webhook URL example
-            webhook_url = ngrok_service.get_webhook_url("/api/webhooks/")
-            self.stdout.write(
-                self.style.HTTP_INFO(
-                    f"Webhook URL example: {webhook_url}"
+            if tunnel_ready:
+                # Set environment variables for ngrok URL
+                self._set_ngrok_env_vars(tunnel_url)
+                
+                # Update ALLOWED_HOSTS if needed
+                self._update_allowed_hosts(tunnel_url)
+                
+                # Update config URLs if enabled
+                ngrok_service.update_config_urls()
+                
+                # Brief success message - detailed info will be shown by startup_display
+                self.stdout.write(
+                    self.style.SUCCESS(f"✅ Ngrok tunnel ready: {tunnel_url}")
+                )
+                logger.info(f"Ngrok tunnel fully ready: {tunnel_url}")
+            else:
+                self.stdout.write(
+                    self.style.WARNING("⚠️ Ngrok tunnel started but may not be fully ready")
                 )
-            )
+                logger.warning("Ngrok tunnel started but readiness check failed")
         else:
-            self.stdout.write(
-                self.style.WARNING("Failed to start ngrok tunnel")
-            )
+            error_msg = "Failed to start ngrok tunnel"
+            self.stdout.write(self.style.ERROR(f"❌ {error_msg}"))
+            logger.error(error_msg)
     
     def _set_ngrok_env_vars(self, tunnel_url: str):
         """Set environment variables with ngrok URL for easy access."""
@@ -114,11 +140,7 @@ class Command(RunServerCommand):
             # Set API URL (same as tunnel URL for most cases)
             os.environ['NGROK_API_URL'] = tunnel_url
             
-            self.stdout.write(
-                self.style.HTTP_INFO(
-                    f"Environment variables set: NGROK_URL={tunnel_url}"
-                )
-            )
+            # Environment variables set - no need for verbose output
             logger.info(f"Set ngrok environment variables: {tunnel_url}")
             
         except Exception as e:

django_cfg/management/commands/script.py

@@ -13,11 +13,16 @@ from django.core.management import call_command
 from django.conf import settings
 import questionary
 from datetime import datetime
+from django_cfg.modules.django_logger import get_logger
+
 
 from django_cfg import ConfigToolkit
 
 
+logger = get_logger('script')
+
 class Command(BaseCommand):
+
     help = 'Run custom scripts and manage Django applications'
 
     def add_arguments(self, parser):
@@ -48,6 +53,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
+        logger.info("Starting script command")
         if options['list']:
             self.list_scripts()
         elif options['create']:

django_cfg/management/commands/show_config.py

@@ -10,6 +10,9 @@ import json
 import os
 from django.core.management.base import BaseCommand
 from django.conf import settings
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger('show_config')
 
 
 class Command(BaseCommand):
@@ -30,18 +33,25 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Show configuration in requested format."""
+        logger.info("Starting show_config command")
         try:
             # Get the config instance from Django settings
             config = self._get_config_instance()
+            logger.info("Successfully retrieved configuration instance")
             
             if options['format'] == 'json':
+                logger.info("Displaying configuration in JSON format")
                 self._show_json_format(config, options['include_secrets'])
             else:
+                logger.info("Displaying configuration in table format")
                 self._show_table_format(config, options['include_secrets'])
                 
+            logger.info("show_config command completed successfully")
         except Exception as e:
+            error_msg = f'Failed to show configuration: {e}'
+            logger.error(error_msg, exc_info=True)
             self.stdout.write(
-                self.style.ERROR(f'❌ Failed to show configuration: {e}')
+                self.style.ERROR(f'❌ {error_msg}')
             )
 
     def _get_config_instance(self):
@@ -92,7 +102,7 @@ class Command(BaseCommand):
         env_data = [
             ('Environment', getattr(config, '_environment', 'auto-detected')),
             ('Debug Mode', config.debug),
-            ('Allowed Hosts', ', '.join(config.allowed_hosts)),
+            ('Security Domains', ', '.join(config.security_domains) if config.security_domains else 'None'),
         ]
         
         if include_secrets:

django_cfg/management/commands/show_urls.py

@@ -8,6 +8,9 @@ from django.core.management.base import BaseCommand, CommandParser
 from django.urls import get_resolver
 from django.conf import settings
 from django.utils.termcolors import make_style
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger('show_urls')
 
 
 class Command(BaseCommand):
@@ -78,6 +81,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options) -> None:
         """Main command handler."""
+        logger.info("Starting show_urls command")
         self.options = options
         
         # Disable colors if requested