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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.4.4
+Version: 1.4.5
 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.4 → django_cfg-1.4.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.4"
+version = "1.4.5"
 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",]
@@ -85,6 +85,11 @@ ignore = [ "E501", "B008", "S101", "S311",]
 exclude_dirs = [ "tests", "migrations",]
 skips = [ "B101", "B601",]
 
+[tool.poetry]
+[[tool.poetry.source]]
+name = "pypi"
+priority = "primary"
+
 [tool.ruff.per-file-ignores]
 "tests/*" = [ "S101", "S106",]
 "*/migrations/*" = [ "N806",]
@@ -132,6 +137,12 @@ pytest = "^8.4.2"
 pytest-django = "^4.11.1"
 fakeredis = "^2.31.3"
 
+[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 = "../django_ipc"
+path = "/Users/markinmatrix/djangoipc"
 develop = true

{django_cfg-1.4.4 → django_cfg-1.4.5}/requirements-dev.txt

@@ -1,4 +1,4 @@
-# Development dependencies for django_cfg (includes main deps)
+# Development dependencies for django-cfg-dev (includes main deps)
 # Generated automatically from pyproject.toml
 # Do not edit manually!
 

{django_cfg-1.4.4 → django_cfg-1.4.5}/requirements-test.txt

@@ -1,4 +1,4 @@
-# Test dependencies for django_cfg (includes main deps)
+# Test dependencies for django-cfg-dev (includes main deps)
 # Generated automatically from pyproject.toml
 # Do not edit manually!
 

{django_cfg-1.4.4 → django_cfg-1.4.5}/requirements.txt

@@ -1,4 +1,4 @@
-# Main dependencies for django_cfg
+# Main dependencies for django-cfg-dev
 # Generated automatically from pyproject.toml
 # Do not edit manually!
 

django_cfg-1.4.5/src/django_cfg/apps/api/endpoints/__init__.py

@@ -0,0 +1,5 @@
+"""
+Django CFG Endpoints Status Check
+
+Provides endpoints monitoring and status checking functionality.
+"""

django_cfg-1.4.5/src/django_cfg/apps/api/endpoints/checker.py

@@ -0,0 +1,406 @@
+"""
+Endpoints Status Checker
+
+Utility for checking all registered Django URL endpoints.
+"""
+
+import time
+import re
+from typing import List, Dict, Any, Optional
+from django.urls import get_resolver, URLPattern, URLResolver
+from django.test import Client
+from django.utils import timezone
+from django.contrib.auth import get_user_model
+
+
+def get_url_group(url_pattern: str, depth: int = 3) -> str:
+    """
+    Extract group from URL pattern up to specified depth.
+
+    Examples:
+        /api/accounts/profile/ → api/accounts
+        /api/payments/webhook/status/ → api/payments/webhook
+        /cfg/health/drf/ → cfg/health/drf
+        /admin/auth/user/ → admin/auth/user
+
+    Args:
+        url_pattern: URL pattern string
+        depth: Maximum depth for grouping (default: 3)
+
+    Returns:
+        Group name as string
+    """
+    # Remove leading/trailing slashes and split
+    parts = [p for p in url_pattern.strip('/').split('/') if p and '<' not in p]
+
+    # Take up to depth parts
+    group_parts = parts[:depth]
+
+    return '/'.join(group_parts) if group_parts else 'root'
+
+
+def should_check_endpoint(url_pattern: str, url_name: Optional[str] = None) -> bool:
+    """
+    Determine if endpoint should be checked.
+
+    Excludes:
+        - Health check endpoints (to avoid recursion)
+        - Admin endpoints
+        - Static/media files
+        - Django internal endpoints
+        - Schema/Swagger/Redoc documentation endpoints
+
+    Args:
+        url_pattern: URL pattern string
+        url_name: Optional URL name
+
+    Returns:
+        True if endpoint should be checked
+    """
+    # Exclude patterns
+    exclude_patterns = [
+        r'^/?static/',
+        r'^/?media/',
+        r'^/?admin/',
+        r'^/?cfg/health/',  # Exclude health endpoints (recursion prevention)
+        r'^/?cfg/api/endpoints/',  # Exclude ourselves
+        r'^/__debug__/',
+        r'^/__reload__/',
+        r'^/?schema/',  # Exclude schema/swagger/redoc documentation endpoints
+    ]
+
+    for pattern in exclude_patterns:
+        if re.match(pattern, url_pattern):
+            return False
+
+    # Exclude URL names
+    exclude_names = [
+        'django_cfg_health',
+        'django_cfg_quick_health',
+        'django_cfg_drf_health',
+        'django_cfg_drf_quick_health',
+        'endpoints_status',
+        'endpoints_status_drf',
+    ]
+
+    if url_name in exclude_names:
+        return False
+
+    return True
+
+
+def collect_endpoints(
+    urlpatterns=None,
+    prefix: str = '',
+    namespace: str = '',
+    include_unnamed: bool = True
+) -> List[Dict[str, Any]]:
+    """
+    Recursively collect all URL endpoints.
+
+    Args:
+        urlpatterns: URL patterns to process (default: root resolver)
+        prefix: Current URL prefix
+        namespace: Current URL namespace
+        include_unnamed: Include endpoints without names
+
+    Returns:
+        List of endpoint dictionaries
+    """
+    if urlpatterns is None:
+        resolver = get_resolver()
+        urlpatterns = resolver.url_patterns
+
+    endpoints = []
+
+    for pattern in urlpatterns:
+        if isinstance(pattern, URLResolver):
+            # This is an include() - recurse
+            new_prefix = prefix + str(pattern.pattern)
+            new_namespace = namespace
+
+            if hasattr(pattern, 'namespace') and pattern.namespace:
+                new_namespace = (
+                    f"{namespace}:{pattern.namespace}"
+                    if namespace
+                    else pattern.namespace
+                )
+
+            # Recursively collect nested patterns
+            endpoints.extend(
+                collect_endpoints(
+                    pattern.url_patterns,
+                    new_prefix,
+                    new_namespace,
+                    include_unnamed
+                )
+            )
+
+        elif isinstance(pattern, URLPattern):
+            # Regular URL pattern
+            full_pattern = prefix + str(pattern.pattern)
+
+            # Clean up the pattern
+            clean_pattern = re.sub(r'\^|\$', '', full_pattern)
+            clean_pattern = re.sub(r'\\/', '/', clean_pattern)
+
+            # Ensure leading slash
+            if not clean_pattern.startswith('/'):
+                clean_pattern = '/' + clean_pattern
+
+            url_name = getattr(pattern, 'name', None)
+
+            # Skip unnamed if requested
+            if not include_unnamed and not url_name:
+                continue
+
+            # Check if should include this endpoint
+            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'):
+                callback = pattern.callback
+                if hasattr(callback, 'view_class'):
+                    view_name = callback.view_class.__name__
+                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',
+            })
+
+    return endpoints
+
+
+def create_test_user_and_get_token() -> Optional[str]:
+    """
+    Create test user and generate JWT token.
+
+    Returns:
+        JWT access token or None if JWT not available
+    """
+    try:
+        from rest_framework_simplejwt.tokens import RefreshToken
+
+        User = get_user_model()
+
+        # Create or get test user
+        username = 'endpoint_test_user'
+        email = 'endpoint_test@test.com'
+
+        user, created = User.objects.get_or_create(
+            username=username,
+            defaults={'email': email, 'is_active': True}
+        )
+
+        if created:
+            user.set_password('testpass123')
+            user.save()
+
+        # Generate JWT token
+        refresh = RefreshToken.for_user(user)
+        access_token = str(refresh.access_token)
+
+        return access_token
+
+    except ImportError:
+        # JWT not installed
+        return None
+    except Exception:
+        # Any other error
+        return None
+
+
+def check_endpoint(
+    endpoint: Dict[str, Any],
+    client: Optional[Client] = None,
+    timeout: int = 5,
+    auth_token: Optional[str] = None,
+    auto_auth: bool = True
+) -> tuple[Dict[str, Any], Optional[str]]:
+    """
+    Check a single endpoint health.
+
+    Automatically creates test user and retries with JWT if endpoint returns 401/403.
+
+    Args:
+        endpoint: Endpoint dictionary from collect_endpoints()
+        client: Django test client (creates new if None)
+        timeout: Request timeout in seconds
+        auth_token: JWT token (created automatically on first 401/403)
+        auto_auth: Auto-retry with JWT on 401/403 (default: True)
+
+    Returns:
+        Tuple of (updated endpoint dictionary, auth_token if created)
+    """
+    if client is None:
+        client = Client()
+
+    # Skip if already marked as skipped
+    if endpoint.get('status') == 'skipped':
+        return endpoint, auth_token
+
+    url = endpoint['url']
+    token_created = False
+
+    try:
+        start_time = time.time()
+
+        # First attempt - without auth
+        extra_headers = {'SERVER_NAME': 'localhost'}
+        response = client.get(url, timeout=timeout, **extra_headers)
+        response_time = (time.time() - start_time) * 1000  # Convert to ms
+        status_code = response.status_code
+
+        # If unauthorized and auto_auth enabled, retry with token
+        requires_auth = False
+        if status_code in [401, 403] and auto_auth:
+            requires_auth = True
+
+            # Create token if not provided (only once!)
+            if auth_token is None:
+                auth_token = create_test_user_and_get_token()
+                token_created = True
+
+            if auth_token:
+                start_time = time.time()
+                extra_headers['HTTP_AUTHORIZATION'] = f'Bearer {auth_token}'
+                response = client.get(url, timeout=timeout, **extra_headers)
+                response_time = (time.time() - start_time) * 1000  # Convert to ms
+                status_code = response.status_code
+
+        # Determine if healthy
+        # 200-299: Success
+        # 300-399: Redirects (OK)
+        # 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)
+        # 500+: Server errors (unhealthy)
+
+        is_healthy = status_code in [
+            200, 201, 204,  # Success
+            301, 302, 303, 307, 308,  # Redirects
+            401, 403,  # Auth required (expected)
+            405,  # Method not allowed (endpoint exists)
+        ]
+
+        # Special handling for 404
+        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'
+
+        endpoint.update({
+            'status_code': status_code,
+            'response_time_ms': round(response_time, 2),
+            'is_healthy': is_healthy,
+            'status': 'healthy' if is_healthy else ('warning' if is_healthy is None else 'unhealthy'),
+            'last_checked': timezone.now().isoformat(),
+        })
+
+        if requires_auth:
+            endpoint['required_auth'] = True
+
+    except Exception as e:
+        endpoint.update({
+            'status_code': None,
+            'response_time_ms': None,
+            'is_healthy': False,
+            'status': 'error',
+            'error': str(e)[:200],  # Truncate long errors
+            'last_checked': timezone.now().isoformat(),
+        })
+
+    # Return endpoint and token (if it was created)
+    return endpoint, (auth_token if token_created else None)
+
+
+def check_all_endpoints(
+    include_unnamed: bool = False,
+    timeout: int = 5,
+    auto_auth: bool = True
+) -> Dict[str, Any]:
+    """
+    Check all registered endpoints.
+
+    Args:
+        include_unnamed: Include endpoints without names
+        timeout: Request timeout in seconds
+        auto_auth: Automatically retry with JWT auth on 401/403 (default: True)
+
+    Returns:
+        Dictionary with overall status and all endpoints
+    """
+    # Collect endpoints
+    endpoints = collect_endpoints(include_unnamed=include_unnamed)
+
+    # Create client once
+    client = Client()
+
+    # Token will be created lazily on first 401/403
+    auth_token = None
+
+    # Check each endpoint
+    checked_endpoints = []
+    for endpoint in endpoints:
+        # Check endpoint (will auto-retry with JWT if needed)
+        checked, new_token = check_endpoint(
+            endpoint,
+            client=client,
+            timeout=timeout,
+            auth_token=auth_token,
+            auto_auth=auto_auth
+        )
+
+        # If token was created on first 401/403, save it for ALL subsequent endpoints
+        if new_token and auth_token is None:
+            auth_token = new_token
+
+        checked_endpoints.append(checked)
+
+    # Calculate statistics
+    total = len(checked_endpoints)
+    healthy = sum(1 for e in checked_endpoints if e.get('status') == 'healthy')
+    unhealthy = sum(1 for e in checked_endpoints if e.get('status') == 'unhealthy')
+    warnings = sum(1 for e in checked_endpoints if e.get('status') == 'warning')
+    errors = sum(1 for e in checked_endpoints if e.get('status') == 'error')
+    skipped = sum(1 for e in checked_endpoints if e.get('status') == 'skipped')
+
+    # Determine overall status
+    if errors > 0 or unhealthy > 0:
+        overall_status = 'unhealthy'
+    elif warnings > 0:
+        overall_status = 'degraded'
+    else:
+        overall_status = 'healthy'
+
+    return {
+        'status': overall_status,
+        'timestamp': timezone.now().isoformat(),
+        'total_endpoints': total,
+        'healthy': healthy,
+        'unhealthy': unhealthy,
+        'warnings': warnings,
+        'errors': errors,
+        'skipped': skipped,
+        'endpoints': checked_endpoints,
+    }

django_cfg-1.4.5/src/django_cfg/apps/api/endpoints/drf_views.py

@@ -0,0 +1,52 @@
+"""
+Django CFG Endpoints Status DRF Views
+
+DRF browsable API views with Tailwind theme support.
+"""
+
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.permissions import AllowAny
+
+from .checker import check_all_endpoints
+from .serializers import EndpointsStatusSerializer
+
+
+class DRFEndpointsStatusView(APIView):
+    """
+    Django CFG endpoints status check with DRF Browsable API.
+
+    Checks all registered URL endpoints and returns their health status.
+    Excludes health check endpoints and admin to avoid recursion.
+
+    Query Parameters:
+        - include_unnamed: Include endpoints without names (default: false)
+        - timeout: Request timeout in seconds (default: 5)
+
+    This endpoint uses DRF Browsable API with Tailwind CSS theme! 🎨
+    """
+
+    permission_classes = [AllowAny]  # Public endpoint
+    serializer_class = EndpointsStatusSerializer  # For schema generation
+
+    def get(self, request):
+        """Return endpoints status data."""
+        # Get query parameters
+        include_unnamed = request.query_params.get('include_unnamed', 'false').lower() == 'true'
+        timeout = int(request.query_params.get('timeout', 5))
+
+        # Check all endpoints
+        status_data = check_all_endpoints(
+            include_unnamed=include_unnamed,
+            timeout=timeout
+        )
+
+        # Return appropriate HTTP status
+        http_status = status.HTTP_200_OK
+        if status_data["status"] == "unhealthy":
+            http_status = status.HTTP_503_SERVICE_UNAVAILABLE
+        elif status_data["status"] == "degraded":
+            http_status = status.HTTP_200_OK  # Still operational
+
+        return Response(status_data, status=http_status)

django_cfg-1.4.5/src/django_cfg/apps/api/endpoints/serializers.py

@@ -0,0 +1,103 @@
+"""
+Django CFG Endpoints Status Serializers
+
+DRF serializers for endpoints status check API.
+"""
+
+from rest_framework import serializers
+
+
+class EndpointSerializer(serializers.Serializer):
+    """Serializer for single endpoint status."""
+
+    url = serializers.CharField(
+        help_text="URL pattern of the endpoint"
+    )
+    url_name = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Django URL name (if available)"
+    )
+    namespace = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="URL namespace"
+    )
+    group = serializers.CharField(
+        help_text="URL group (up to 3 depth)"
+    )
+    view = serializers.CharField(
+        required=False,
+        help_text="View function/class name"
+    )
+    status = serializers.CharField(
+        help_text="Status: healthy, unhealthy, warning, error, skipped, pending"
+    )
+    status_code = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        help_text="HTTP status code"
+    )
+    response_time_ms = serializers.FloatField(
+        required=False,
+        allow_null=True,
+        help_text="Response time in milliseconds"
+    )
+    is_healthy = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Whether endpoint is healthy"
+    )
+    error = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="Error message if check failed"
+    )
+    reason = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="Reason for skip (if skipped)"
+    )
+    last_checked = serializers.DateTimeField(
+        required=False,
+        allow_null=True,
+        help_text="Timestamp of last check"
+    )
+    required_auth = serializers.BooleanField(
+        required=False,
+        default=False,
+        help_text="Whether endpoint required JWT authentication"
+    )
+
+
+class EndpointsStatusSerializer(serializers.Serializer):
+    """Serializer for overall endpoints status response."""
+
+    status = serializers.CharField(
+        help_text="Overall status: healthy, degraded, or unhealthy"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Timestamp of the check"
+    )
+    total_endpoints = serializers.IntegerField(
+        help_text="Total number of endpoints checked"
+    )
+    healthy = serializers.IntegerField(
+        help_text="Number of healthy endpoints"
+    )
+    unhealthy = serializers.IntegerField(
+        help_text="Number of unhealthy endpoints"
+    )
+    warnings = serializers.IntegerField(
+        help_text="Number of endpoints with warnings"
+    )
+    errors = serializers.IntegerField(
+        help_text="Number of endpoints with errors"
+    )
+    skipped = serializers.IntegerField(
+        help_text="Number of skipped endpoints"
+    )
+    endpoints = EndpointSerializer(
+        many=True,
+        help_text="List of all endpoints with their status"
+    )