django-cfg 1.4.5__tar.gz → 1.4.6__tar.gz

{django_cfg-1.4.5 → django_cfg-1.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.4.5
+Version: 1.4.6
 Summary: Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django.
 Project-URL: Homepage, https://djangocfg.com
 Project-URL: Documentation, https://djangocfg.com

{django_cfg-1.4.5 → django_cfg-1.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.5"
+version = "1.4.6"
 description = "Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "ai-agents", "enterprise-django", "django-settings", "type-safe-config",]
@@ -116,14 +116,6 @@ directory = "htmlcov"
 [tool.poetry.group.local]
 optional = true
 
-[tool.hatch.build.targets.wheel]
-packages = [ "src/django_cfg",]
-exclude = [ "scripts/",]
-
-[tool.hatch.build.targets.sdist]
-include = [ "src/django_cfg", "README.md", "LICENSE", "CHANGELOG.md", "CONTRIBUTING.md", "requirements*.txt", "MANIFEST.in",]
-exclude = [ "@*", "tests", "scripts", "*.log", ".env*",]
-
 [tool.poetry.group.dev.dependencies]
 tomlkit = "^0.13.3"
 build = "^1.3.0"
@@ -137,12 +129,20 @@ pytest = "^8.4.2"
 pytest-django = "^4.11.1"
 fakeredis = "^2.31.3"
 
+[tool.hatch.build.targets.wheel]
+packages = [ "src/django_cfg",]
+exclude = [ "scripts/",]
+
+[tool.hatch.build.targets.sdist]
+include = [ "src/django_cfg", "README.md", "LICENSE", "CHANGELOG.md", "CONTRIBUTING.md", "requirements*.txt", "MANIFEST.in",]
+exclude = [ "@*", "tests", "scripts", "*.log", ".env*",]
+
+[tool.poetry.group.local.dependencies.django-ipc]
+path = "/Users/markinmatrix/djangoipc"
+develop = true
+
 [tool.hatch.build.targets.wheel.force-include]
 LICENSE = "django_cfg/LICENSE"
 "CONTRIBUTING.md" = "django_cfg/CONTRIBUTING.md"
 "CHANGELOG.md" = "django_cfg/CHANGELOG.md"
 "pyproject.toml" = "django_cfg/pyproject.toml"
-
-[tool.poetry.group.local.dependencies.django-ipc]
-path = "/Users/markinmatrix/djangoipc"
-develop = true

{django_cfg-1.4.5 → django_cfg-1.4.6}/src/django_cfg/apps/api/endpoints/checker.py

@@ -6,7 +6,8 @@ Utility for checking all registered Django URL endpoints.
 
 import time
 import re
-from typing import List, Dict, Any, Optional
+import uuid
+from typing import List, Dict, Any, Optional, Tuple
 from django.urls import get_resolver, URLPattern, URLResolver
 from django.test import Client
 from django.utils import timezone
@@ -49,6 +50,7 @@ def should_check_endpoint(url_pattern: str, url_name: Optional[str] = None) -> b
         - Static/media files
         - Django internal endpoints
         - Schema/Swagger/Redoc documentation endpoints
+        - DRF format suffix patterns (causes kwarg errors)
 
     Args:
         url_pattern: URL pattern string
@@ -73,6 +75,11 @@ def should_check_endpoint(url_pattern: str, url_name: Optional[str] = None) -> b
         if re.match(pattern, url_pattern):
             return False
 
+    # Exclude DRF format suffix patterns (e.g., \.(?P<format>[a-z0-9]+))
+    # These cause "got an unexpected keyword argument 'format'" errors in action methods
+    if r'\.(?P<format>' in url_pattern or '<drf_format_suffix:' in url_pattern:
+        return False
+
     # Exclude URL names
     exclude_names = [
         'django_cfg_health',
@@ -89,6 +96,147 @@ def should_check_endpoint(url_pattern: str, url_name: Optional[str] = None) -> b
     return True
 
 
+def get_test_value_for_parameter(param_name: str, param_pattern: str) -> str:
+    """
+    Generate appropriate test value for URL parameter based on name and pattern.
+
+    Args:
+        param_name: Parameter name (e.g., 'slug', 'pk', 'id', 'uuid')
+        param_pattern: Regex pattern for the parameter
+
+    Returns:
+        Test value string
+
+    Examples:
+        slug -> 'test-slug'
+        pk -> '1'
+        id -> '1'
+        uuid -> generated UUID
+        format -> 'json'
+    """
+    param_lower = param_name.lower()
+
+    # UUID parameters
+    if 'uuid' in param_lower:
+        return str(uuid.uuid4())
+
+    # Primary key / ID parameters
+    if param_lower in ['pk', 'id']:
+        return '1'
+
+    # Slug parameters
+    if 'slug' in param_lower:
+        return 'test-slug'
+
+    # Format parameters (for DRF format suffixes)
+    if 'format' in param_lower:
+        return 'json'
+
+    # Username parameters
+    if 'username' in param_lower:
+        return 'testuser'
+
+    # Year/Month/Day parameters
+    if param_lower == 'year':
+        return '2024'
+    if param_lower == 'month':
+        return '01'
+    if param_lower == 'day':
+        return '01'
+
+    # Generic string parameter - check pattern
+    if '[a-z0-9]' in param_pattern or '[\\w]' in param_pattern:
+        return 'test'
+
+    # Numeric parameter
+    if '[0-9]' in param_pattern or '\\d' in param_pattern:
+        return '1'
+
+    # Default
+    return 'test'
+
+
+def resolve_parametrized_url(url_pattern: str) -> Optional[str]:
+    """
+    Resolve URL pattern with parameters to concrete URL with test values.
+
+    Supports both regex patterns and Django typed path converters.
+
+    Args:
+        url_pattern: URL pattern with Django parameters
+
+    Returns:
+        Resolved URL with test values, or None if cannot resolve
+
+    Examples:
+        Regex patterns:
+        '/api/products/(?P<slug>[^/]+)/' -> '/api/products/test-slug/'
+        '/api/users/(?P<pk>[0-9]+)/' -> '/api/users/1/'
+
+        Typed converters:
+        '/api/products/<int:pk>/' -> '/api/products/1/'
+        '/api/posts/<slug:slug>/' -> '/api/posts/test-slug/'
+        '/api/items/<uuid:item_id>/' -> '/api/items/<uuid>/'
+    """
+    resolved_url = url_pattern
+
+    # First, handle Django typed path converters: <converter:name>
+    # Pattern: <type:name>
+    typed_converter_regex = r'<([^:>]+):([^>]+)>'
+
+    typed_matches = list(re.finditer(typed_converter_regex, url_pattern))
+
+    for match in typed_matches:
+        converter_type = match.group(1)
+        param_name = match.group(2)
+        full_match = match.group(0)
+
+        # Get test value based on converter type
+        if converter_type == 'int':
+            test_value = '1'
+        elif converter_type == 'slug':
+            test_value = 'test-slug'
+        elif converter_type == 'uuid':
+            test_value = str(uuid.uuid4())
+        elif converter_type == 'str':
+            test_value = get_test_value_for_parameter(param_name, '')
+        elif converter_type == 'path':
+            test_value = 'test/path'
+        elif converter_type == 'drf_format_suffix':
+            test_value = 'json'
+        else:
+            # Unknown converter - use parameter name to guess
+            test_value = get_test_value_for_parameter(param_name, '')
+
+        # Replace typed converter with test value
+        resolved_url = resolved_url.replace(full_match, test_value, 1)
+
+    # Then handle regex patterns: (?P<name>pattern)
+    param_regex = r'\(\?P<([^>]+)>([^)]+)\)'
+
+    regex_matches = re.finditer(param_regex, resolved_url)
+
+    for match in regex_matches:
+        param_name = match.group(1)
+        param_pattern = match.group(2)
+        full_match = match.group(0)
+
+        # Get test value for this parameter
+        test_value = get_test_value_for_parameter(param_name, param_pattern)
+
+        # Replace parameter with test value
+        resolved_url = resolved_url.replace(full_match, test_value, 1)
+
+    # Clean up any remaining regex syntax
+    resolved_url = re.sub(r'[\^$\\]', '', resolved_url)
+
+    # Check if resolution was successful (no parameter patterns left)
+    if '(?P<' in resolved_url or '<' in resolved_url:
+        return None
+
+    return resolved_url
+
+
 def collect_endpoints(
     urlpatterns=None,
     prefix: str = '',
@@ -158,18 +306,6 @@ def collect_endpoints(
             if not should_check_endpoint(clean_pattern, url_name):
                 continue
 
-            # Skip patterns with required parameters (for now)
-            if '<' in clean_pattern:
-                endpoints.append({
-                    'url': clean_pattern,
-                    'url_name': url_name,
-                    'namespace': namespace,
-                    'group': get_url_group(clean_pattern),
-                    'status': 'skipped',
-                    'reason': 'requires_parameters',
-                })
-                continue
-
             # Get view info
             view_name = 'unknown'
             if hasattr(pattern, 'callback'):
@@ -179,14 +315,44 @@ def collect_endpoints(
                 elif hasattr(callback, '__name__'):
                     view_name = callback.__name__
 
-            endpoints.append({
-                'url': clean_pattern,
-                'url_name': url_name,
-                'namespace': namespace,
-                'group': get_url_group(clean_pattern),
-                'view': view_name,
-                'status': 'pending',
-            })
+            # Handle patterns with parameters
+            if '<' in clean_pattern or '(?P<' in clean_pattern:
+                # Try to resolve with test values
+                resolved_url = resolve_parametrized_url(clean_pattern)
+
+                if resolved_url:
+                    # Successfully resolved - can test it
+                    endpoints.append({
+                        'url': resolved_url,
+                        'url_pattern': clean_pattern,  # Keep original pattern for reference
+                        'url_name': url_name,
+                        'namespace': namespace,
+                        'group': get_url_group(clean_pattern),
+                        'view': view_name,
+                        'status': 'pending',
+                        'has_parameters': True,
+                    })
+                else:
+                    # Cannot resolve - skip
+                    endpoints.append({
+                        'url': clean_pattern,
+                        'url_name': url_name,
+                        'namespace': namespace,
+                        'group': get_url_group(clean_pattern),
+                        'view': view_name,
+                        'status': 'skipped',
+                        'reason': 'cannot_resolve_parameters',
+                    })
+            else:
+                # No parameters - can test directly
+                endpoints.append({
+                    'url': clean_pattern,
+                    'url_name': url_name,
+                    'namespace': namespace,
+                    'group': get_url_group(clean_pattern),
+                    'view': view_name,
+                    'status': 'pending',
+                })
 
     return endpoints
 
@@ -266,7 +432,11 @@ def check_endpoint(
         start_time = time.time()
 
         # First attempt - without auth
-        extra_headers = {'SERVER_NAME': 'localhost'}
+        # Add special header to bypass rate limiting for internal checks
+        extra_headers = {
+            'SERVER_NAME': 'localhost',
+            'HTTP_X_DJANGO_CFG_INTERNAL_CHECK': 'true'
+        }
         response = client.get(url, timeout=timeout, **extra_headers)
         response_time = (time.time() - start_time) * 1000  # Convert to ms
         status_code = response.status_code
@@ -294,6 +464,7 @@ def check_endpoint(
         # 401, 403: Auth required (expected, still healthy)
         # 404: Not found (might be OK if endpoint exists but has no data)
         # 405: Method not allowed (endpoint exists, just wrong method)
+        # 429: Rate limited (expected for rate-limited APIs, still healthy)
         # 500+: Server errors (unhealthy)
 
         is_healthy = status_code in [
@@ -301,13 +472,16 @@ def check_endpoint(
             301, 302, 303, 307, 308,  # Redirects
             401, 403,  # Auth required (expected)
             405,  # Method not allowed (endpoint exists)
+            429,  # Rate limited (expected for rate-limited APIs)
         ]
 
         # Special handling for 404
+        reason = None
         if status_code == 404:
             # 404 might be OK for some endpoints (e.g., detail views with no data)
             # Mark as warning rather than unhealthy
             is_healthy = None  # Will be marked as 'warning'
+            reason = 'Not Found - endpoint works but no data exists (empty list or test object not found)'
 
         endpoint.update({
             'status_code': status_code,
@@ -317,16 +491,39 @@ def check_endpoint(
             'last_checked': timezone.now().isoformat(),
         })
 
+        if reason:
+            endpoint['reason'] = reason
+
         if requires_auth:
             endpoint['required_auth'] = True
 
+        if status_code == 429:
+            endpoint['rate_limited'] = True
+
     except Exception as e:
+        from django.db import DatabaseError, OperationalError
+
+        # Multi-database compatibility: treat DB errors as warnings, not errors
+        # Common in multi-database setups with db_constraint=False ForeignKeys
+        is_db_error = isinstance(e, (DatabaseError, OperationalError))
+        error_message = str(e)[:200]
+
+        # Check for cross-database JOIN errors (common with SQLite multi-db)
+        is_cross_db_error = any(keyword in str(e).lower() for keyword in [
+            'no such table',
+            'no such column',
+            'cannot join',
+            'cross-database',
+            'multi-database'
+        ])
+
         endpoint.update({
             'status_code': None,
             'response_time_ms': None,
-            'is_healthy': False,
-            'status': 'error',
-            'error': str(e)[:200],  # Truncate long errors
+            'is_healthy': False if not (is_db_error or is_cross_db_error) else None,
+            'status': 'warning' if (is_db_error or is_cross_db_error) else 'error',
+            'error': error_message,
+            'error_type': 'database' if (is_db_error or is_cross_db_error) else 'general',
             'last_checked': timezone.now().isoformat(),
         })
 

{django_cfg-1.4.5 → django_cfg-1.4.6}/src/django_cfg/apps/api/endpoints/drf_views.py

@@ -23,6 +23,7 @@ class DRFEndpointsStatusView(APIView):
     Query Parameters:
         - include_unnamed: Include endpoints without names (default: false)
         - timeout: Request timeout in seconds (default: 5)
+        - auto_auth: Auto-retry with JWT on 401/403 (default: true)
 
     This endpoint uses DRF Browsable API with Tailwind CSS theme! 🎨
     """
@@ -35,11 +36,13 @@ class DRFEndpointsStatusView(APIView):
         # Get query parameters
         include_unnamed = request.query_params.get('include_unnamed', 'false').lower() == 'true'
         timeout = int(request.query_params.get('timeout', 5))
+        auto_auth = request.query_params.get('auto_auth', 'true').lower() == 'true'
 
         # Check all endpoints
         status_data = check_all_endpoints(
             include_unnamed=include_unnamed,
-            timeout=timeout
+            timeout=timeout,
+            auto_auth=auto_auth
         )
 
         # Return appropriate HTTP status

{django_cfg-1.4.5 → django_cfg-1.4.6}/src/django_cfg/apps/api/endpoints/serializers.py

@@ -11,7 +11,12 @@ class EndpointSerializer(serializers.Serializer):
     """Serializer for single endpoint status."""
 
     url = serializers.CharField(
-        help_text="URL pattern of the endpoint"
+        help_text="Resolved URL (for parametrized URLs) or URL pattern"
+    )
+    url_pattern = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Original URL pattern (for parametrized URLs)"
     )
     url_name = serializers.CharField(
         required=False,
@@ -53,21 +58,36 @@ class EndpointSerializer(serializers.Serializer):
         allow_blank=True,
         help_text="Error message if check failed"
     )
+    error_type = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="Error type: database, general, etc."
+    )
     reason = serializers.CharField(
         required=False,
         allow_blank=True,
-        help_text="Reason for skip (if skipped)"
+        help_text="Reason for warning/skip"
     )
     last_checked = serializers.DateTimeField(
         required=False,
         allow_null=True,
         help_text="Timestamp of last check"
     )
+    has_parameters = serializers.BooleanField(
+        required=False,
+        default=False,
+        help_text="Whether URL has parameters that were resolved with test values"
+    )
     required_auth = serializers.BooleanField(
         required=False,
         default=False,
         help_text="Whether endpoint required JWT authentication"
     )
+    rate_limited = serializers.BooleanField(
+        required=False,
+        default=False,
+        help_text="Whether endpoint returned 429 (rate limited)"
+    )
 
 
 class EndpointsStatusSerializer(serializers.Serializer):

{django_cfg-1.4.5 → django_cfg-1.4.6}/src/django_cfg/apps/payments/middleware/rate_limiting.py

@@ -52,6 +52,7 @@ class RateLimitingMiddleware(MiddlewareMixin):
             self.window_precision = 10  # sub-windows
             self.exempt_paths = [
                 '/api/health/',
+                '/cfg/',  # Exempt all django-cfg internal endpoints
                 '/admin/',
                 '/static/',
                 '/media/',
@@ -73,7 +74,7 @@ class RateLimitingMiddleware(MiddlewareMixin):
             self.burst_allowance = 0.5
             self.window_size = 60
             self.window_precision = 10
-            self.exempt_paths = ['/api/health/', '/admin/']
+            self.exempt_paths = ['/api/health/', '/cfg/', '/admin/']
             self.cache_timeout = 300
         
         logger.info(f"Rate Limiting Middleware initialized", extra={
@@ -92,9 +93,14 @@ class RateLimitingMiddleware(MiddlewareMixin):
         if not self.enabled:
             return None
         
-        # Check if path is exempt
-        if request.path in self.exempt_paths:
+        # Check if this is a django-cfg internal endpoint check (bypass rate limiting)
+        if request.META.get('HTTP_X_DJANGO_CFG_INTERNAL_CHECK') == 'true':
             return None
+
+        # Check if path is exempt (supports prefix matching)
+        for exempt_path in self.exempt_paths:
+            if request.path.startswith(exempt_path):
+                return None
         
         start_time = time.time()
         

{django_cfg-1.4.5 → django_cfg-1.4.6}/src/django_cfg/management/commands/check_endpoints.py

@@ -113,7 +113,7 @@ class Command(BaseCommand):
         self.stdout.write(self.style.HTTP_INFO('🔗 Endpoints:'))
 
         for endpoint in data['endpoints']:
-            name = endpoint.get('name', 'unnamed')
+            name = endpoint.get('url_name') or 'unnamed'
             url = endpoint['url']
             status = endpoint['status']
 
@@ -128,18 +128,41 @@ class Command(BaseCommand):
                 style = self.style.ERROR
 
             self.stdout.write(f'  {icon} {name}')
-            self.stdout.write(f'     URL: {url}')
-            self.stdout.write(style(f'     Status: {status}'))
 
-            if endpoint.get('response_time'):
-                self.stdout.write(f'     Response time: {endpoint["response_time"]:.3f}s')
+            # Show both pattern and resolved URL for parametrized endpoints
+            if endpoint.get('has_parameters') and endpoint.get('url_pattern'):
+                self.stdout.write(f'     Pattern: {endpoint["url_pattern"]}')
+                self.stdout.write(f'     Resolved: {url}')
+            else:
+                self.stdout.write(f'     URL: {url}')
+
+            # Show status with status code
+            status_code = endpoint.get('status_code')
+            if status_code:
+                self.stdout.write(style(f'     Status: {status} ({status_code})'))
+            else:
+                self.stdout.write(style(f'     Status: {status}'))
+
+            if endpoint.get('response_time_ms'):
+                self.stdout.write(f'     Response time: {endpoint["response_time_ms"]:.2f}ms')
 
             if endpoint.get('error'):
-                self.stdout.write(self.style.ERROR(f'     Error: {endpoint["error"]}'))
+                error_type = endpoint.get('error_type', 'general')
+                if error_type == 'database':
+                    self.stdout.write(self.style.WARNING(f'     ⚠️  DB Error (multi-db): {endpoint["error"]}'))
+                else:
+                    self.stdout.write(self.style.ERROR(f'     Error: {endpoint["error"]}'))
+
+            # Show reason for warnings (e.g., 404 explanations)
+            if endpoint.get('reason') and status == 'warning':
+                self.stdout.write(self.style.WARNING(f'     ⚠️  {endpoint["reason"]}'))
 
             if endpoint.get('required_auth'):
                 self.stdout.write(f'     🔐 Required JWT authentication')
 
+            if endpoint.get('rate_limited'):
+                self.stdout.write(f'     ⏱️  Rate limited (429)')
+
             self.stdout.write('')
 
         # Timestamp

{django_cfg-1.4.5 → django_cfg-1.4.6}/src/django_cfg/management/commands/rundramatiq.py

@@ -117,7 +117,7 @@ class Command(BaseCommand):
             
             process_args = [
                 executable_name,
-                "django_cfg.modules.dramatiq_setup",  # Broker module
+                "django_cfg.modules.django_tasks.dramatiq_setup",  # Broker module
                 "--processes", str(processes),
                 "--threads", str(threads),
                 "--worker-shutdown-timeout", str(worker_shutdown_timeout),
@@ -155,7 +155,7 @@ class Command(BaseCommand):
         # Build process arguments exactly like django_dramatiq
         process_args = [
             executable_name,
-            "django_cfg.modules.dramatiq_setup",  # Broker module
+            "django_cfg.modules.django_tasks.dramatiq_setup",  # Broker module
             "--processes", str(processes),
             "--threads", str(threads),
             "--worker-shutdown-timeout", str(worker_shutdown_timeout),
@@ -213,7 +213,7 @@ class Command(BaseCommand):
     def _discover_tasks_modules(self):
         """Discover task modules like django_dramatiq does."""
         # Always include our broker setup module first
-        tasks_modules = ["django_cfg.modules.dramatiq_setup"]
+        tasks_modules = ["django_cfg.modules.django_tasks.dramatiq_setup"]
         
         # Get task service for configuration
         task_service = get_task_service()

{django_cfg-1.4.5 → django_cfg-1.4.6}/src/django_cfg/modules/django_unfold/dashboard.py

@@ -61,6 +61,7 @@ class DashboardManager(BaseCfgModule):
                     NavigationItem(title="Overview", icon=Icons.DASHBOARD, link="/admin/"),
                     NavigationItem(title="Settings", icon=Icons.SETTINGS, link="/admin/constance/config/"),
                     NavigationItem(title="Health Check", icon=Icons.HEALTH_AND_SAFETY, link="/cfg/health/"),
+                    NavigationItem(title="Endpoints Status", icon=Icons.API, link="/cfg/endpoints/drf/"),
                 ]
             ),
         ]