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

django_cfg/apps/payments/middleware/usage_tracking.py

@@ -6,14 +6,16 @@ Lightweight middleware for tracking API usage and analytics.
 
 import time
 from typing import Optional
+
+from django.core.cache import cache
 from django.http import HttpRequest, HttpResponse
-from django.utils.deprecation import MiddlewareMixin
 from django.utils import timezone
-from django.core.cache import cache
+from django.utils.deprecation import MiddlewareMixin
 
-from ..config.helpers import MiddlewareConfigHelper
 from django_cfg.modules.django_logging import get_logger
 
+from ..config.helpers import MiddlewareConfigHelper
+
 logger = get_logger("usage_tracking_middleware")
 
 
@@ -28,20 +30,20 @@ class UsageTrackingMiddleware(MiddlewareMixin):
     - Performance metrics
     - Error rate tracking
     """
-    
+
     def __init__(self, get_response=None):
         super().__init__(get_response)
-        
+
         # Load configuration from django-cfg
         try:
             middleware_config = MiddlewareConfigHelper.get_middleware_config()
-            
+
             # Configuration from django-cfg
             self.enabled = middleware_config['usage_tracking_enabled']
             self.track_anonymous = middleware_config['track_anonymous_usage']
             self.api_prefixes = middleware_config['api_prefixes']
             self.cache_timeout = middleware_config['cache_timeouts']['default']
-            
+
             # Static exempt paths
             self.exempt_paths = [
                 '/api/health/',
@@ -49,7 +51,7 @@ class UsageTrackingMiddleware(MiddlewareMixin):
                 '/static/',
                 '/media/',
             ]
-            
+
         except Exception as e:
             logger.warning(f"Failed to load usage tracking config, using defaults: {e}")
             # Fallback defaults
@@ -58,12 +60,12 @@ class UsageTrackingMiddleware(MiddlewareMixin):
             self.api_prefixes = ['/api/']
             self.exempt_paths = ['/api/health/', '/admin/']
             self.cache_timeout = 3600
-        
-        logger.info(f"Usage Tracking Middleware initialized", extra={
+
+        logger.info("Usage Tracking Middleware initialized", extra={
             'enabled': self.enabled,
             'track_anonymous': self.track_anonymous
         })
-    
+
     def process_request(self, request: HttpRequest) -> Optional[HttpResponse]:
         """
         Process incoming request - start timing and prepare tracking.
@@ -78,10 +80,10 @@ class UsageTrackingMiddleware(MiddlewareMixin):
         # Check if we should track this request
         if not self._should_track_request(request):
             return None
-        
+
         # Start timing
         request._usage_start_time = time.time()
-        
+
         # Store request info for tracking
         request._usage_info = {
             'method': request.method,
@@ -90,59 +92,59 @@ class UsageTrackingMiddleware(MiddlewareMixin):
             'ip_address': self._get_client_ip(request),
             'authenticated': hasattr(request, 'api_key') or (hasattr(request, 'user') and request.user.is_authenticated)
         }
-        
+
         return None
-    
+
     def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
         """
         Process response - track usage and performance metrics.
         """
         if not self.enabled or not hasattr(request, '_usage_start_time'):
             return response
-        
+
         try:
             # Calculate response time
             response_time = (time.time() - request._usage_start_time) * 1000  # ms
-            
+
             # Get usage info
             usage_info = getattr(request, '_usage_info', {})
-            
+
             # Track the request
             self._track_request(request, response, response_time, usage_info)
-            
+
             # Add performance headers
             response['X-Response-Time'] = f"{response_time:.2f}ms"
-            
+
         except Exception as e:
             logger.warning(f"Usage tracking failed: {e}")
-        
+
         return response
-    
+
     def _should_track_request(self, request: HttpRequest) -> bool:
         """
         Determine if we should track this request.
         """
         # Check if path is in API prefixes
         is_api_request = any(request.path.startswith(prefix) for prefix in self.api_prefixes)
-        
+
         if not is_api_request:
             return False
-        
+
         # Check exempt paths
         if request.path in self.exempt_paths:
             return False
-        
+
         # Check if we should track anonymous requests
         if not self.track_anonymous:
             is_authenticated = (
-                hasattr(request, 'api_key') or 
+                hasattr(request, 'api_key') or
                 (hasattr(request, 'user') and request.user.is_authenticated)
             )
             if not is_authenticated:
                 return False
-        
+
         return True
-    
+
     def _track_request(self, request: HttpRequest, response: HttpResponse, response_time: float, usage_info: dict):
         """
         Track request usage and performance metrics.
@@ -154,23 +156,23 @@ class UsageTrackingMiddleware(MiddlewareMixin):
                 user_id = request.api_key.user.id
             elif hasattr(request, 'user') and request.user.is_authenticated:
                 user_id = request.user.id
-            
+
             # Track endpoint usage
             self._track_endpoint_usage(usage_info['path'], usage_info['method'], response.status_code)
-            
+
             # Track user activity
             if user_id:
                 self._track_user_activity(user_id, usage_info['path'], response_time)
-            
+
             # Track performance metrics
             self._track_performance_metrics(usage_info['path'], response_time, response.status_code)
-            
+
             # Track errors
             if response.status_code >= 400:
                 self._track_error(usage_info, response.status_code)
-            
+
             # Log request
-            logger.debug(f"Request tracked", extra={
+            logger.debug("Request tracked", extra={
                 'path': usage_info['path'],
                 'method': usage_info['method'],
                 'status_code': response.status_code,
@@ -178,10 +180,10 @@ class UsageTrackingMiddleware(MiddlewareMixin):
                 'user_id': user_id,
                 'authenticated': usage_info['authenticated']
             })
-            
+
         except Exception as e:
             logger.warning(f"Failed to track request: {e}")
-    
+
     def _track_endpoint_usage(self, path: str, method: str, status_code: int):
         """
         Track endpoint usage statistics.
@@ -189,59 +191,59 @@ class UsageTrackingMiddleware(MiddlewareMixin):
         try:
             today = timezone.now().date().isoformat()
             hour = timezone.now().hour
-            
+
             # Daily endpoint usage
             daily_key = f"endpoint_usage:{path}:{method}:{today}"
             cache.set(daily_key, cache.get(daily_key, 0) + 1, timeout=86400 * 2)
-            
+
             # Hourly endpoint usage
             hourly_key = f"endpoint_usage_hourly:{path}:{method}:{today}:{hour}"
             cache.set(hourly_key, cache.get(hourly_key, 0) + 1, timeout=86400)
-            
+
             # Status code tracking
             status_key = f"endpoint_status:{path}:{method}:{status_code}:{today}"
             cache.set(status_key, cache.get(status_key, 0) + 1, timeout=86400 * 2)
-            
+
         except Exception as e:
             logger.warning(f"Failed to track endpoint usage: {e}")
-    
+
     def _track_user_activity(self, user_id: int, path: str, response_time: float):
         """
         Track user activity and performance.
         """
         try:
             today = timezone.now().date().isoformat()
-            
+
             # Update last activity
             cache.set(f"user_last_activity:{user_id}", timezone.now().isoformat(), timeout=86400 * 30)
-            
+
             # Daily user requests
             daily_requests_key = f"user_requests:{user_id}:{today}"
             cache.set(daily_requests_key, cache.get(daily_requests_key, 0) + 1, timeout=86400 * 2)
-            
+
             # User endpoint usage
             user_endpoint_key = f"user_endpoint:{user_id}:{path}:{today}"
             cache.set(user_endpoint_key, cache.get(user_endpoint_key, 0) + 1, timeout=86400 * 2)
-            
+
             # User performance tracking
             perf_key = f"user_performance:{user_id}:{today}"
             perf_data = cache.get(perf_key, {'total_time': 0.0, 'request_count': 0})
             perf_data['total_time'] += response_time
             perf_data['request_count'] += 1
             perf_data['avg_response_time'] = perf_data['total_time'] / perf_data['request_count']
-            
+
             cache.set(perf_key, perf_data, timeout=86400 * 2)
-            
+
         except Exception as e:
             logger.warning(f"Failed to track user activity: {e}")
-    
+
     def _track_performance_metrics(self, path: str, response_time: float, status_code: int):
         """
         Track performance metrics for monitoring.
         """
         try:
             today = timezone.now().date().isoformat()
-            
+
             # Global performance metrics
             global_perf_key = f"global_performance:{today}"
             global_perf = cache.get(global_perf_key, {
@@ -250,53 +252,53 @@ class UsageTrackingMiddleware(MiddlewareMixin):
                 'slow_requests': 0,  # > 1000ms
                 'fast_requests': 0,  # < 100ms
             })
-            
+
             global_perf['total_requests'] += 1
             global_perf['total_time'] += response_time
-            
+
             if response_time > 1000:
                 global_perf['slow_requests'] += 1
             elif response_time < 100:
                 global_perf['fast_requests'] += 1
-            
+
             global_perf['avg_response_time'] = global_perf['total_time'] / global_perf['total_requests']
-            
+
             cache.set(global_perf_key, global_perf, timeout=86400 * 2)
-            
+
             # Update system average response time for adaptive rate limiting
             cache.set('system_avg_response_time', global_perf['avg_response_time'], timeout=300)
-            
+
         except Exception as e:
             logger.warning(f"Failed to track performance metrics: {e}")
-    
+
     def _track_error(self, usage_info: dict, status_code: int):
         """
         Track error occurrences for monitoring.
         """
         try:
             today = timezone.now().date().isoformat()
-            
+
             # Global error tracking
             error_key = f"errors:{status_code}:{today}"
             cache.set(error_key, cache.get(error_key, 0) + 1, timeout=86400 * 7)
-            
+
             # Endpoint-specific error tracking
             endpoint_error_key = f"endpoint_errors:{usage_info['path']}:{status_code}:{today}"
             cache.set(endpoint_error_key, cache.get(endpoint_error_key, 0) + 1, timeout=86400 * 7)
-            
+
             # Log significant errors
             if status_code >= 500:
-                logger.error(f"Server error tracked", extra={
+                logger.error("Server error tracked", extra={
                     'status_code': status_code,
                     'path': usage_info['path'],
                     'method': usage_info['method'],
                     'ip_address': usage_info['ip_address'],
                     'user_agent': usage_info['user_agent']
                 })
-            
+
         except Exception as e:
             logger.warning(f"Failed to track error: {e}")
-    
+
     def _get_client_ip(self, request: HttpRequest) -> str:
         """
         Get client IP address from request.
@@ -304,9 +306,9 @@ class UsageTrackingMiddleware(MiddlewareMixin):
         x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
         if x_forwarded_for:
             return x_forwarded_for.split(',')[0].strip()
-        
+
         x_real_ip = request.META.get('HTTP_X_REAL_IP')
         if x_real_ip:
             return x_real_ip
-        
+
         return request.META.get('REMOTE_ADDR', 'unknown')

django_cfg/apps/payments/migrations/0001_initial.py

@@ -1,9 +1,10 @@
 # Generated by Django 5.2.6 on 2025-09-29 06:18
 
+import uuid
+
 import django.core.validators
 import django.db.models.deletion
 import django.utils.timezone
-import uuid
 from django.conf import settings
 from django.db import migrations, models
 

django_cfg/apps/payments/models/__init__.py

@@ -6,26 +6,25 @@ All models follow the data typing requirements: Django ORM for database layer.
 """
 
 # Base models
+# API Keys
+from .api_keys import APIKey
+
+# Balance models
+from .balance import Transaction, UserBalance
 from .base import UUIDTimestampedModel
 
 # Currency models
 from .currencies import Currency, Network, ProviderCurrency
 
-# Payment models  
+# Payment models
 from .payments import UniversalPayment
 
-# Balance models
-from .balance import UserBalance, Transaction
-
 # Subscription models
-from .subscriptions import Subscription, EndpointGroup
+from .subscriptions import EndpointGroup, Subscription
 
 # Tariff models
 from .tariffs import Tariff, TariffEndpointGroup
 
-# API Keys
-from .api_keys import APIKey
-
 # Export TextChoices for external use
 PaymentStatus = UniversalPayment.PaymentStatus
 PaymentProvider = UniversalPayment.PaymentProvider
@@ -37,22 +36,22 @@ SubscriptionTier = Subscription.SubscriptionTier
 __all__ = [
     # Base
     'UUIDTimestampedModel',
-    
+
     # Currencies
     'Currency',
     'Network',
     'ProviderCurrency',
-    
+
     # Core Models
     'UniversalPayment',
     'UserBalance',
-    'Transaction', 
+    'Transaction',
     'Subscription',
     'EndpointGroup',
     'Tariff',
     'TariffEndpointGroup',
     'APIKey',
-    
+
     # TextChoices
     'PaymentStatus',
     'PaymentProvider',

django_cfg/apps/payments/models/api_keys.py

@@ -5,11 +5,13 @@ Handles API key management and access control.
 """
 
 import secrets
-from django.db import models
+
 from django.contrib.auth import get_user_model
-from django.core.validators import MinLengthValidator
 from django.core.exceptions import ValidationError
+from django.core.validators import MinLengthValidator
+from django.db import models
 from django.utils import timezone
+
 from .base import UUIDTimestampedModel
 
 User = get_user_model()
@@ -21,61 +23,61 @@ class APIKey(UUIDTimestampedModel):
     
     Provides secure API access with usage tracking and rate limiting.
     """
-    
+
     user = models.ForeignKey(
         User,
         on_delete=models.CASCADE,
         related_name='api_keys',
         help_text="User who owns this API key"
     )
-    
+
     name = models.CharField(
         max_length=100,
         help_text="Human-readable name for this API key"
     )
-    
+
     key = models.CharField(
         max_length=64,
         unique=True,
         validators=[MinLengthValidator(32)],
         help_text="The actual API key (auto-generated)"
     )
-    
+
     # Access control
     is_active = models.BooleanField(
         default=True,
         help_text="Whether this API key is active"
     )
-    
+
     # Usage tracking
     total_requests = models.PositiveIntegerField(
         default=0,
         help_text="Total number of requests made with this key"
     )
-    
+
     last_used_at = models.DateTimeField(
         null=True,
         blank=True,
         help_text="When this API key was last used"
     )
-    
+
     # Expiration
     expires_at = models.DateTimeField(
         null=True,
         blank=True,
         help_text="When this API key expires (null = never expires)"
     )
-    
+
     # IP restrictions
     allowed_ips = models.TextField(
         blank=True,
         help_text="Comma-separated list of allowed IP addresses (empty = any IP)"
     )
-    
+
     # Manager
     from .managers.api_key_managers import APIKeyManager
     objects = APIKeyManager()
-    
+
     class Meta:
         db_table = 'payments_api_keys'
         verbose_name = 'API Key'
@@ -86,45 +88,45 @@ class APIKey(UUIDTimestampedModel):
             models.Index(fields=['user', 'is_active']),
             models.Index(fields=['expires_at']),
         ]
-    
+
     def __str__(self):
         return f"{self.user.username} - {self.name}"
-    
+
     def save(self, *args, **kwargs):
         """Override save to generate API key."""
         if not self.key:
             self.key = self.generate_api_key()
         super().save(*args, **kwargs)
-    
+
     def clean(self):
         """Validate API key data."""
         if self.expires_at and self.expires_at <= timezone.now():
             raise ValidationError("Expiration time must be in the future")
-    
+
     @staticmethod
     def generate_api_key() -> str:
         """Generate a secure API key."""
         return secrets.token_urlsafe(32)
-    
+
     @property
     def is_expired(self) -> bool:
         """Check if API key is expired."""
         if not self.expires_at:
             return False
         return timezone.now() > self.expires_at
-    
+
     @property
     def is_valid(self) -> bool:
         """Check if API key is valid (active and not expired)."""
         return self.is_active and not self.is_expired
-    
+
     @property
     def masked_key(self) -> str:
         """Get masked version of API key for display."""
         if len(self.key) < 8:
             return self.key
         return f"{self.key[:4]}...{self.key[-4:]}"
-    
+
     @property
     def days_until_expiry(self) -> int:
         """Get days until expiration."""
@@ -134,7 +136,7 @@ class APIKey(UUIDTimestampedModel):
             return 0
         delta = self.expires_at - timezone.now()
         return max(0, delta.days)
-    
+
     def is_ip_allowed(self, ip_address: str) -> bool:
         """
         Check if IP address is allowed to use this API key.
@@ -147,27 +149,27 @@ class APIKey(UUIDTimestampedModel):
         """
         if not self.allowed_ips.strip():
             return True  # No restrictions
-        
+
         allowed_list = [ip.strip() for ip in self.allowed_ips.split(',') if ip.strip()]
         return ip_address in allowed_list
-    
+
     def increment_usage(self, ip_address: str = None):
         """Increment usage counter (delegates to manager)."""
         return self.__class__.objects.increment_api_key_usage(self, ip_address)
-    
+
     def deactivate(self, reason: str = None):
         """Deactivate this API key (delegates to manager)."""
         return self.__class__.objects.deactivate_api_key(self, reason)
-    
+
     def extend_expiry(self, days: int):
         """Extend API key expiration (delegates to manager)."""
         return self.__class__.objects.extend_api_key_expiry(self, days)
-    
+
     @classmethod
     def create_for_user(cls, user, name="Default API Key", expires_in_days=None):
         """Create new API key for user (delegates to manager)."""
         return cls.objects.create_api_key_for_user(user, name, expires_in_days)
-    
+
     @classmethod
     def get_valid_key(cls, key_value: str):
         """Get valid API key by key value (delegates to manager)."""