django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/middleware/pagination.py

@@ -4,11 +4,11 @@ Django CFG Default Pagination Classes
 Provides enhanced pagination classes with better response format and schema support.
 """
 
-from rest_framework.pagination import PageNumberPagination
-from rest_framework.response import Response
-from typing import Dict, Any, Optional
+
 from django.core.paginator import InvalidPage
 from rest_framework.exceptions import NotFound
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.response import Response
 
 
 class DefaultPagination(PageNumberPagination):
@@ -21,15 +21,15 @@ class DefaultPagination(PageNumberPagination):
     - Better OpenAPI schema support
     - Consistent error handling
     """
-    
+
     # Page size configuration
     page_size = 100
     page_size_query_param = 'page_size'
     max_page_size = 1000
-    
+
     # Page number configuration
     page_query_param = 'page'
-    
+
     # Template for invalid page messages
     invalid_page_message = 'Invalid page "{page_number}": {message}.'
 
@@ -97,7 +97,7 @@ class DefaultPagination(PageNumberPagination):
                     'example': 2
                 },
                 'pages': {
-                    'type': 'integer', 
+                    'type': 'integer',
                     'description': 'Total number of pages',
                     'example': 15
                 },
@@ -251,7 +251,7 @@ class CursorPaginationEnhanced(PageNumberPagination):
 # Export all pagination classes
 __all__ = [
     'DefaultPagination',
-    'LargePagination', 
+    'LargePagination',
     'SmallPagination',
     'NoPagination',
     'CursorPaginationEnhanced',

django_cfg/middleware/public_endpoints.py

@@ -7,7 +7,8 @@ authentication errors on endpoints with AllowAny permissions.
 
 import logging
 import re
-from typing import List, Optional, Set
+from typing import List, Optional
+
 from django.http import HttpRequest, HttpResponse
 from django.utils.deprecation import MiddlewareMixin
 
@@ -28,7 +29,7 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
     - ✅ Detailed logging for debugging
     - ✅ Performance optimized with compiled regex patterns
     """
-    
+
     # Default public endpoint patterns
     DEFAULT_PUBLIC_PATTERNS = [
         r'^/api/accounts/otp/',           # OTP endpoints (request, verify)
@@ -41,7 +42,7 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
         r'^/api/schema/',                 # API schema endpoints
         r'^/api/docs/',                   # API documentation
     ]
-    
+
     def __init__(self, get_response=None):
         super().__init__(get_response)
         self.public_patterns: List[re.Pattern] = []
@@ -51,71 +52,71 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
             'public_endpoints_hit': 0,
         }
         self._compile_patterns()
-    
+
     def _compile_patterns(self):
         """Compile regex patterns for better performance."""
         patterns = self._get_public_patterns()
         self.public_patterns = [re.compile(pattern) for pattern in patterns]
         logger.debug(f"Compiled {len(self.public_patterns)} public endpoint patterns")
-    
+
     def _get_public_patterns(self) -> List[str]:
         """Get public endpoint patterns from Django settings or use defaults."""
         from django.conf import settings
-        
+
         # Try to get patterns from settings
         custom_patterns = getattr(settings, 'PUBLIC_ENDPOINT_PATTERNS', None)
         if custom_patterns:
             logger.debug(f"Using custom public patterns: {len(custom_patterns)} patterns")
             return custom_patterns
-        
+
         # Use defaults
         logger.debug(f"Using default public patterns: {len(self.DEFAULT_PUBLIC_PATTERNS)} patterns")
         return self.DEFAULT_PUBLIC_PATTERNS
-    
+
     def _is_public_endpoint(self, path: str) -> bool:
         """Check if the request path matches any public endpoint pattern."""
         for pattern in self.public_patterns:
             if pattern.match(path):
                 return True
         return False
-    
+
     def _has_jwt_token(self, request: HttpRequest) -> bool:
         """Check if request has a JWT Authorization header."""
         auth_header = request.META.get('HTTP_AUTHORIZATION', '')
         return auth_header.startswith('Bearer ')
-    
+
     def _extract_auth_header(self, request: HttpRequest) -> Optional[str]:
         """Extract and remove Authorization header from request."""
         return request.META.pop('HTTP_AUTHORIZATION', None)
-    
+
     def _restore_auth_header(self, request: HttpRequest, auth_header: str):
         """Restore Authorization header to request."""
         if auth_header:
             request.META['HTTP_AUTHORIZATION'] = auth_header
-    
+
     def process_request(self, request: HttpRequest) -> Optional[HttpResponse]:
         """
         Process incoming request and temporarily remove auth header for public endpoints.
         """
         self.stats['requests_processed'] += 1
-        
+
         # Check if this is a public endpoint
         if not self._is_public_endpoint(request.path):
             return None
-        
+
         self.stats['public_endpoints_hit'] += 1
-        
+
         # Check if request has JWT token
         if not self._has_jwt_token(request):
             return None
-        
+
         # Store the auth header and remove it temporarily
         auth_header = self._extract_auth_header(request)
         if auth_header:
             self.stats['tokens_ignored'] += 1
             # Store in request for restoration later
             request._original_auth_header = auth_header
-            
+
             logger.debug(
                 f"Temporarily removed auth header for public endpoint: {request.path}",
                 extra={
@@ -124,9 +125,9 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
                     'has_token': bool(auth_header),
                 }
             )
-        
+
         return None
-    
+
     def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
         """
         Restore Authorization header after request processing.
@@ -135,7 +136,7 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
         if hasattr(request, '_original_auth_header'):
             self._restore_auth_header(request, request._original_auth_header)
             delattr(request, '_original_auth_header')
-            
+
             logger.debug(
                 f"Restored auth header for public endpoint: {request.path}",
                 extra={
@@ -143,9 +144,9 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
                     'status_code': response.status_code,
                 }
             )
-        
+
         return response
-    
+
     def get_stats(self) -> dict:
         """Get middleware statistics."""
         return {
@@ -153,7 +154,7 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
             'public_patterns_count': len(self.public_patterns),
             'middleware_active': True,
         }
-    
+
     def reset_stats(self):
         """Reset middleware statistics."""
         self.stats = {

django_cfg/middleware/user_activity.py

@@ -6,9 +6,11 @@ making API requests. Only works when accounts app is enabled.
 """
 
 import logging
-from django.utils import timezone
+
 from django.contrib.auth import get_user_model
+from django.utils import timezone
 from django.utils.deprecation import MiddlewareMixin
+
 from django_cfg.modules.base import BaseCfgModule
 
 logger = logging.getLogger(__name__)
@@ -27,20 +29,20 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
     - Only works when accounts app is enabled
     - KISS principle - no configuration needed
     """
-    
+
     def __init__(self, get_response=None):
         """Initialize the middleware."""
         super().__init__(get_response)
         BaseCfgModule.__init__(self)
         self.get_response = get_response
-        
+
         # Cache for tracking last update times (in memory)
         self._last_updates = {}
-        
+
         # Fixed configuration - KISS principle
         self.update_interval = 300  # 5 minutes
         self.api_only = True  # Only track API requests
-    
+
     def process_request(self, request):
         """
         Process incoming request to track user activity.
@@ -51,23 +53,23 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
         # Only process if accounts app is enabled
         if not self.is_accounts_enabled():
             return None
-        
+
         # Only track authenticated users
         if not hasattr(request, 'user') or not request.user.is_authenticated:
             return None
-        
+
         # Only track API requests if api_only is enabled
         if self.api_only and not self._is_api_request(request):
             return None
-        
+
         try:
             self._update_user_activity(request.user, request)
         except Exception as e:
             # Log error but don't break the request
             logger.warning(f"Failed to update user activity: {e}")
-        
+
         return None
-    
+
     def _is_api_request(self, request):
         """
         Check if this is an API request using intelligent detection.
@@ -81,23 +83,23 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
         # Primary detection: Check for JSON-related indicators
         content_type = request.content_type or ''
         accept_header = request.META.get('HTTP_ACCEPT', '')
-        
+
         # 1. JSON Content-Type or Accept header
-        if ('application/json' in content_type or 
+        if ('application/json' in content_type or
             'application/json' in accept_header):
             return True
-        
+
         # 2. DRF format parameter
         if request.GET.get('format') in ['json', 'api']:
             return True
-        
+
         # 3. Common REST API HTTP methods with specific paths
         if request.method in ['POST', 'PUT', 'PATCH', 'DELETE']:
             path = request.path_info
             # Only track REST operations, not form submissions
             if not path.endswith('/') or 'admin' not in path:
                 return True
-        
+
         # 4. Check if path matches configured API prefixes
         path = request.path_info
         try:
@@ -108,7 +110,7 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
                     api_prefix = f"/{getattr(config.openapi_client, 'api_prefix', 'api')}/"
                     if path.startswith(api_prefix):
                         return True
-                
+
                 # Check Django CFG prefix (always /cfg/ by default)
                 if path.startswith('/cfg/'):
                     return True
@@ -116,9 +118,9 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
             # Fallback to basic path detection
             if path.startswith(('/api/', '/cfg/')):
                 return True
-        
+
         return False
-    
+
     def _update_user_activity(self, user, request):
         """
         Update user's last_login field if enough time has passed.
@@ -129,33 +131,33 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
         """
         now = timezone.now()
         user_id = user.pk
-        
+
         # Check if we should update (avoid database spam)
         last_update = self._last_updates.get(user_id)
         if last_update and (now - last_update).total_seconds() < self.update_interval:
             return
-        
+
         # Update user's last_login
         User = get_user_model()
         try:
             # Use update() to avoid triggering signals and save() overhead
             User.objects.filter(pk=user_id).update(last_login=now)
-            
+
             # Cache the update time
             self._last_updates[user_id] = now
-            
+
             # Log the activity (optional, for debugging)
             logger.debug(f"Updated last_login for user {user.email} from {request.path}")
-            
+
             # Clean up old cache entries (keep only last 1000 users)
             if len(self._last_updates) > 1000:
                 # Remove oldest entries
                 sorted_items = sorted(self._last_updates.items(), key=lambda x: x[1])
                 self._last_updates = dict(sorted_items[-500:])
-                
+
         except Exception as e:
             logger.error(f"Failed to update last_login for user {user_id}: {e}")
-    
+
     def get_activity_stats(self):
         """
         Get middleware activity statistics.

django_cfg/models/__init__.py

@@ -15,46 +15,45 @@ Organized by category:
 """
 
 # Base classes
-from .base.config import BaseConfig, BaseSettings
-from .base.module import BaseCfgAutoModule
-
-# Infrastructure
-from .infrastructure.database import DatabaseConfig
-from .infrastructure.cache import CacheConfig
-from .infrastructure.logging import LoggingConfig
-from .infrastructure.security import SecurityConfig
+# External modules (imported from other locations)
+from ..modules.django_unfold.models.config import UnfoldConfig
 
 # API & Authentication
 from .api.config import APIConfig
-from .api.keys import ApiKeys
-from .api.jwt import JWTConfig
 from .api.cors import CORSConfig
-from .api.limits import LimitsConfig
 from .api.drf.config import DRFConfig
+from .api.drf.redoc import RedocUISettings
 from .api.drf.spectacular import SpectacularConfig
 from .api.drf.swagger import SwaggerUISettings
-from .api.drf.redoc import RedocUISettings
+from .api.jwt import JWTConfig
+from .api.keys import ApiKeys
+from .api.limits import LimitsConfig
+from .base.config import BaseConfig, BaseSettings
+from .base.module import BaseCfgAutoModule
+from .django.constance import ConstanceConfig, ConstanceField
 
 # Django-specific
 from .django.environment import EnvironmentConfig
-from .django.constance import ConstanceConfig, ConstanceField
 from .django.openapi import OpenAPIClientConfig
+from .infrastructure.cache import CacheConfig
 
-# Services
-from .services.email import EmailConfig
-from .services.telegram import TelegramConfig
-from .services.base import ServiceConfig
-from .ngrok.config import NgrokConfig
+# Infrastructure
+from .infrastructure.database import DatabaseConfig
+from .infrastructure.logging import LoggingConfig
+from .infrastructure.security import SecurityConfig
 from .ngrok.auth import NgrokAuthConfig
+from .ngrok.config import NgrokConfig
 from .ngrok.tunnel import NgrokTunnelConfig
 
 # Payments
 from .payments.config import PaymentsConfig
 from .payments.providers.base import BaseProviderConfig
 from .payments.providers.nowpayments import NowPaymentsProviderConfig
+from .services.base import ServiceConfig
 
-# External modules (imported from other locations)
-from ..modules.django_unfold.models.config import UnfoldConfig
+# Services
+from .services.email import EmailConfig
+from .services.telegram import TelegramConfig
 
 __all__ = [
     # Base

django_cfg/models/api/__init__.py

@@ -5,14 +5,14 @@ API, authentication, and documentation configuration.
 """
 
 from .config import APIConfig
-from .keys import ApiKeys
-from .jwt import JWTConfig
 from .cors import CORSConfig
-from .limits import LimitsConfig
 from .drf.config import DRFConfig
+from .drf.redoc import RedocUISettings
 from .drf.spectacular import SpectacularConfig
 from .drf.swagger import SwaggerUISettings
-from .drf.redoc import RedocUISettings
+from .jwt import JWTConfig
+from .keys import ApiKeys
+from .limits import LimitsConfig
 
 __all__ = [
     "APIConfig",

django_cfg/models/api/config.py

@@ -4,8 +4,10 @@ API Configuration Model
 Django REST Framework and API settings with Pydantic 2.
 """
 
-from typing import Dict, Any, List
+from typing import Any, Dict, List
+
 from pydantic import Field, field_validator
+
 from ..base import BaseConfig
 
 
@@ -16,7 +18,7 @@ class APIConfig(BaseConfig):
     Configures Django REST Framework, pagination, throttling,
     and API documentation settings.
     """
-    
+
     # Pagination settings
     page_size: int = Field(
         default=20,
@@ -24,52 +26,52 @@ class APIConfig(BaseConfig):
         le=100,
         description="Default API pagination page size"
     )
-    
+
     max_page_size: int = Field(
         default=100,
         ge=1,
         le=1000,
         description="Maximum API pagination page size"
     )
-    
+
     # Throttling settings
     rate_limit_enabled: bool = Field(
         default=True,
         description="Enable API rate limiting"
     )
-    
+
     rate_limit_anon: str = Field(
         default="100/hour",
         description="Rate limit for anonymous users"
     )
-    
+
     rate_limit_user: str = Field(
-        default="1000/hour", 
+        default="1000/hour",
         description="Rate limit for authenticated users"
     )
-    
+
     # Documentation settings
     docs_enabled: bool = Field(
         default=True,
         description="Enable API documentation"
     )
-    
+
     docs_title: str = Field(
         default="API Documentation",
         description="API documentation title"
     )
-    
+
     docs_version: str = Field(
         default="v1",
         description="API version"
     )
-    
+
     # CORS settings for API
     api_cors_origins: List[str] = Field(
         default_factory=list,
         description="CORS origins specifically for API endpoints"
     )
-    
+
     @field_validator('page_size', 'max_page_size')
     @classmethod
     def validate_page_sizes(cls, v: int) -> int:
@@ -77,7 +79,7 @@ class APIConfig(BaseConfig):
         if v <= 0:
             raise ValueError("Page size must be positive")
         return v
-    
+
     @field_validator('rate_limit_anon', 'rate_limit_user')
     @classmethod
     def validate_rate_limits(cls, v: str) -> str:
@@ -87,7 +89,7 @@ class APIConfig(BaseConfig):
         if not re.match(pattern, v):
             raise ValueError("Rate limit must be in format: number/(second|minute|hour|day)")
         return v
-    
+
     def to_django_settings(self) -> Dict[str, Any]:
         """Convert to Django REST Framework settings."""
         settings = {
@@ -95,22 +97,22 @@ class APIConfig(BaseConfig):
                 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
                 'PAGE_SIZE': self.page_size,
                 'MAX_PAGE_SIZE': self.max_page_size,
-                
+
                 'DEFAULT_AUTHENTICATION_CLASSES': [
                     'rest_framework.authentication.SessionAuthentication',
                     'rest_framework.authentication.TokenAuthentication',
                     'rest_framework_simplejwt.authentication.JWTAuthentication',
                 ],
-                
+
                 'DEFAULT_PERMISSION_CLASSES': [
                     'rest_framework.permissions.IsAuthenticated',
                 ],
-                
+
                 'DEFAULT_RENDERER_CLASSES': [
                     'rest_framework.renderers.JSONRenderer',
                     'rest_framework.renderers.BrowsableAPIRenderer',
                 ],
-                
+
                 'DEFAULT_FILTER_BACKENDS': [
                     'django_filters.rest_framework.DjangoFilterBackend',
                     'rest_framework.filters.OrderingFilter',
@@ -118,7 +120,7 @@ class APIConfig(BaseConfig):
                 ],
             }
         }
-        
+
         # Add throttling if enabled
         if self.rate_limit_enabled:
             settings['REST_FRAMEWORK']['DEFAULT_THROTTLE_CLASSES'] = [
@@ -129,7 +131,7 @@ class APIConfig(BaseConfig):
                 'anon': self.rate_limit_anon,
                 'user': self.rate_limit_user,
             }
-        
+
         # API documentation settings
         if self.docs_enabled:
             settings.update({
@@ -141,5 +143,5 @@ class APIConfig(BaseConfig):
                     'SCHEMA_PATH_PREFIX': '/api/',
                 }
             })
-        
+
         return settings