django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/apps/tasks/admin.py

@@ -1,320 +0,0 @@
-"""
-Admin interface for Dramatiq task management.
-
-Provides web interface for starting workers, checking queue status,
-and clearing queues with AJAX endpoints and interactive buttons.
-"""
-
-import logging
-import subprocess
-import sys
-from typing import Dict, Any
-
-from django.db.models import Count            
-from django.contrib import admin
-from django.contrib.admin.views.main import ChangeList
-from django.http import JsonResponse
-from django.urls import path
-from django.views.decorators.csrf import csrf_exempt
-from unfold.admin import ModelAdmin
-
-try:
-    from django_dramatiq.models import Task
-    from django_dramatiq.admin import TaskAdmin as BaseDramatiqTaskAdmin
-except ImportError:
-    Task = None
-    BaseDramatiqTaskAdmin = None
-
-from ...modules.django_tasks import DjangoTasks
-
-
-class TaskQueueChangeList(ChangeList):
-    """Custom changelist for task queue management."""
-    
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.tasks_service = DjangoTasks()
-
-
-class TaskQueueAdmin(ModelAdmin):
-    """
-    Enhanced admin for Dramatiq task management.
-    
-    Provides buttons for:
-    - Starting/stopping workers
-    - Checking queue status
-    - Clearing queues
-    - Viewing task statistics
-    """
-    
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.logger = logging.getLogger(__name__)
-        self.tasks_service = DjangoTasks()
-    
-    def get_urls(self):
-        """Add custom URLs for task management."""
-        urls = super().get_urls()
-        custom_urls = [
-            path('queue-status/', csrf_exempt(self.queue_status_view), name='dramatiq_queue_status'),
-            path('start-workers/', csrf_exempt(self.start_workers_view), name='dramatiq_start_workers'),
-            path('clear-queues/', csrf_exempt(self.clear_queues_view), name='dramatiq_clear_queues'),
-            path('task-stats/', csrf_exempt(self.task_stats_view), name='dramatiq_task_stats'),
-        ]
-        return custom_urls + urls
-    
-    def queue_status_view(self, request):
-        """Get queue status and statistics."""
-        if request.method != 'GET':
-            return JsonResponse({'success': False, 'error': 'Method not allowed'}, status=405)
-        
-        try:
-            # Get queue status using tasks service
-            status_data = self._get_queue_status()
-            
-            return JsonResponse({
-                'success': True,
-                'data': status_data
-            })
-            
-        except Exception as e:
-            self.logger.error(f"Queue status check failed: {e}")
-            return JsonResponse({
-                'success': False,
-                'error': str(e)
-            }, status=500)
-    
-    def start_workers_view(self, request):
-        """Start Dramatiq workers."""
-        if request.method != 'POST':
-            return JsonResponse({'success': False, 'error': 'Method not allowed'}, status=405)
-        
-        try:
-            # Get parameters from request
-            processes = int(request.POST.get('processes', 2))
-            threads = int(request.POST.get('threads', 8))
-            queues = request.POST.get('queues', '')
-            
-            # Validate parameters
-            if processes < 1 or processes > 16:
-                return JsonResponse({
-                    'success': False,
-                    'error': 'Processes must be between 1 and 16'
-                }, status=400)
-            
-            if threads < 1 or threads > 32:
-                return JsonResponse({
-                    'success': False,
-                    'error': 'Threads must be between 1 and 32'
-                }, status=400)
-            
-            # Build command
-            cmd = [sys.executable, 'manage.py', 'rundramatiq']
-            cmd.extend(['--processes', str(processes)])
-            cmd.extend(['--threads', str(threads)])
-            
-            if queues:
-                cmd.extend(['--queues', queues])
-            
-            # Start workers in background
-            process = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                cwd=None  # Use current working directory
-            )
-            
-            return JsonResponse({
-                'success': True,
-                'message': f'Started {processes} worker processes with {threads} threads each',
-                'pid': process.pid,
-                'command': ' '.join(cmd)
-            })
-            
-        except Exception as e:
-            self.logger.error(f"Start workers failed: {e}")
-            return JsonResponse({
-                'success': False,
-                'error': str(e)
-            }, status=500)
-    
-    def clear_queues_view(self, request):
-        """Clear Dramatiq queues."""
-        if request.method != 'POST':
-            return JsonResponse({'success': False, 'error': 'Method not allowed'}, status=405)
-        
-        try:
-            # Get parameters
-            queue_name = request.POST.get('queue', '')
-            failed_only = request.POST.get('failed_only', 'false').lower() == 'true'
-            
-            # Build command
-            cmd = [sys.executable, 'manage.py', 'task_clear', '--confirm']
-            
-            if queue_name:
-                cmd.extend(['--queue', queue_name])
-            
-            if failed_only:
-                cmd.append('--failed-only')
-            
-            # Execute command
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=30
-            )
-            
-            if result.returncode == 0:
-                return JsonResponse({
-                    'success': True,
-                    'message': 'Queues cleared successfully',
-                    'output': result.stdout
-                })
-            else:
-                return JsonResponse({
-                    'success': False,
-                    'error': result.stderr or 'Clear command failed'
-                }, status=500)
-                
-        except subprocess.TimeoutExpired:
-            return JsonResponse({
-                'success': False,
-                'error': 'Clear operation timed out'
-            }, status=500)
-        except Exception as e:
-            self.logger.error(f"Clear queues failed: {e}")
-            return JsonResponse({
-                'success': False,
-                'error': str(e)
-            }, status=500)
-    
-    def task_stats_view(self, request):
-        """Get task statistics."""
-        if request.method != 'GET':
-            return JsonResponse({'success': False, 'error': 'Method not allowed'}, status=405)
-        
-        try:
-            # Get task statistics using tasks service
-            stats_data = self._get_task_statistics()
-            
-            return JsonResponse({
-                'success': True,
-                'data': stats_data
-            })
-            
-        except Exception as e:
-            self.logger.error(f"Task stats failed: {e}")
-            return JsonResponse({
-                'success': False,
-                'error': str(e)
-            }, status=500)
-    
-    def _get_queue_status(self) -> Dict[str, Any]:
-        """Get current queue status."""
-        try:
-            # Use tasks service to get Redis connection
-            redis_client = self.tasks_service.get_redis_client()
-            
-            if not redis_client:
-                return {
-                    'error': 'Redis connection not available',
-                    'queues': {},
-                    'workers': 0
-                }
-            
-            # Get queue information
-            queues_info = {}
-            config = self.tasks_service.config
-            
-            if config and config.dramatiq and config.dramatiq.queues:
-                for queue_name in config.dramatiq.queues:
-                    queue_key = f"dramatiq:default.DQ.{queue_name}"
-                    queue_length = redis_client.llen(queue_key)
-                    
-                    # Get failed queue length
-                    failed_key = f"dramatiq:default.DQ.{queue_name}.failed"
-                    failed_length = redis_client.llen(failed_key)
-                    
-                    queues_info[queue_name] = {
-                        'pending': queue_length,
-                        'failed': failed_length,
-                        'total': queue_length + failed_length
-                    }
-            
-            # Get worker information (simplified)
-            worker_keys = redis_client.keys("dramatiq:worker:*")
-            active_workers = len(worker_keys) if worker_keys else 0
-            
-            return {
-                'queues': queues_info,
-                'workers': active_workers,
-                'redis_connected': True,
-                'timestamp': self.tasks_service._get_current_timestamp()
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Queue status error: {e}")
-            return {
-                'error': str(e),
-                'queues': {},
-                'workers': 0,
-                'redis_connected': False
-            }
-    
-    def _get_task_statistics(self) -> Dict[str, Any]:
-        """Get task execution statistics."""
-        try:
-            if not Task:
-                return {'error': 'django_dramatiq not available'}
-            
-            
-            stats = Task.tasks.aggregate(
-                total=Count('id'),
-                # Add more aggregations as needed
-            )
-            
-            # Get recent tasks
-            recent_tasks = list(
-                Task.tasks.order_by('-created_at')[:10]
-                .values('actor_name', 'status', 'created_at', 'updated_at')
-            )
-            
-            return {
-                'statistics': stats,
-                'recent_tasks': recent_tasks,
-                'timestamp': self.tasks_service._get_current_timestamp()
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Task statistics error: {e}")
-            return {'error': str(e)}
-
-
-# Register the enhanced admin if django_dramatiq is available
-if Task and BaseDramatiqTaskAdmin:
-    # Unregister the default admin
-    admin.site.unregister(Task)
-    
-    # Register our enhanced admin
-    @admin.register(Task)
-    class EnhancedTaskAdmin(TaskQueueAdmin, BaseDramatiqTaskAdmin):
-        """Enhanced Task admin with queue management buttons."""
-        
-        def get_changelist(self, request, **kwargs):
-            """Use custom changelist."""
-            return TaskQueueChangeList
-        
-        def changelist_view(self, request, extra_context=None):
-            """Add extra context for queue management."""
-            extra_context = extra_context or {}
-            
-            # Add queue status to context
-            try:
-                queue_status = self._get_queue_status()
-                extra_context['queue_status'] = queue_status
-            except Exception as e:
-                self.logger.error(f"Failed to get queue status: {e}")
-                extra_context['queue_status'] = {'error': str(e)}
-            
-            return super().changelist_view(request, extra_context)

django_cfg/middleware/static_nocache.py

@@ -1,55 +0,0 @@
-"""
-Static files no-cache middleware for django-cfg.
-
-Automatically disables caching for static files in development environments
-to prevent browser caching issues during development.
-"""
-
-from django.conf import settings
-from django_cfg.core.config import EnvironmentMode
-
-
-class StaticNoCacheMiddleware:
-    """
-    Middleware to disable caching for static files in development.
-    
-    This ensures that JavaScript and CSS files are always fresh during development,
-    preventing browser caching issues when files are updated.
-    
-    Automatically detects development mode based on:
-    - DEBUG setting
-    - ENV_MODE environment variable
-    """
-    
-    def __init__(self, get_response):
-        self.get_response = get_response
-        
-        # Determine if we should disable caching
-        self.should_disable_cache = self._should_disable_cache()
-
-    def _should_disable_cache(self):
-        """Determine if caching should be disabled based on environment."""
-        # Always disable in DEBUG mode
-        if settings.DEBUG:
-            return True
-            
-        # Check ENV_MODE if available
-        env_mode = getattr(settings, 'ENV_MODE', None)
-        if env_mode == EnvironmentMode.DEVELOPMENT or env_mode == EnvironmentMode.TEST:
-            return True
-            
-        return False
-
-    def __call__(self, request):
-        response = self.get_response(request)
-        
-        # Apply no-cache headers for static files in development
-        if self.should_disable_cache and request.path.startswith('/static/'):
-            response['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
-            response['Pragma'] = 'no-cache'
-            response['Expires'] = '0'
-            # Add ETag removal to prevent conditional requests
-            if 'ETag' in response:
-                del response['ETag']
-        
-        return response

django_cfg/modules/django_currency/clients/yahoo_client.py

@@ -1,157 +0,0 @@
-import logging
-import requests
-import time
-from datetime import datetime
-from typing import Dict, Set, Optional
-from cachetools import TTLCache
-
-from ..core.models import Rate, YahooFinanceResponse
-from ..core.exceptions import RateFetchError
-
-logger = logging.getLogger(__name__)
-
-
-class YahooFinanceClient:
-    """Simple Yahoo Finance client without yfinance dependency."""
-
-    BASE_URL = "https://query1.finance.yahoo.com/v8/finance/chart"
-    
-    def __init__(self, cache_ttl: int = 3600):
-        """Initialize Yahoo Finance client with TTL cache."""
-        self._rate_cache = TTLCache(maxsize=500, ttl=cache_ttl)
-        self._session = requests.Session()
-        self._session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-        })
-        self._last_request_time = 0
-        self._rate_limit_delay = 1.0  # 1 second between requests
-
-    def _get_yahoo_symbol(self, base: str, quote: str) -> str:
-        """Convert currency pair to Yahoo Finance symbol format."""
-        # Yahoo uses format like EURUSD=X for forex pairs
-        return f"{base}{quote}=X"
-
-    def fetch_rate(self, base: str, quote: str) -> Rate:
-        """
-        Fetch forex rate from Yahoo Finance with caching.
-        
-        Args:
-            base: Base currency code (e.g., EUR)
-            quote: Quote currency code (e.g., USD)
-            
-        Returns:
-            Rate object with exchange rate data
-            
-        Raises:
-            RateFetchError: If rate fetch fails
-        """
-        base = base.upper()
-        quote = quote.upper()
-        cache_key = f"{base}_{quote}"
-
-        # Try cache first
-        if cache_key in self._rate_cache:
-            logger.debug(f"Retrieved rate {base}/{quote} from Yahoo cache")
-            return self._rate_cache[cache_key]
-
-        symbol = self._get_yahoo_symbol(base, quote)
-        
-        # Rate limiting
-        current_time = time.time()
-        time_since_last_request = current_time - self._last_request_time
-        if time_since_last_request < self._rate_limit_delay:
-            sleep_time = self._rate_limit_delay - time_since_last_request
-            logger.debug(f"Rate limiting: sleeping for {sleep_time:.2f}s")
-            time.sleep(sleep_time)
-        
-        try:
-            response = self._session.get(f"{self.BASE_URL}/{symbol}")
-            self._last_request_time = time.time()
-            response.raise_for_status()
-            
-            raw_data = response.json()
-            
-            # Validate response using Pydantic model
-            try:
-                yahoo_response = YahooFinanceResponse(**raw_data)
-            except Exception as e:
-                raise RateFetchError(f"Invalid Yahoo Finance response format: {e}")
-
-            if not yahoo_response.chart.result:
-                raise RateFetchError(f"No data returned for {symbol}")
-
-            meta = yahoo_response.chart.result[0].meta
-            rate_value = meta.regularMarketPrice
-            timestamp = datetime.fromtimestamp(meta.regularMarketTime)
-            
-            rate = Rate(
-                source="yahoo",
-                base_currency=base,
-                quote_currency=quote,
-                rate=float(rate_value),
-                timestamp=timestamp
-            )
-            
-            self._rate_cache[cache_key] = rate
-            logger.info(f"Fetched rate {base}/{quote} = {rate_value} from Yahoo Finance")
-            return rate
-            
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Failed to fetch rate from Yahoo Finance: {e}")
-            raise RateFetchError(f"Yahoo Finance API error: {e}")
-        except (KeyError, TypeError, ValueError) as e:
-            logger.error(f"Failed to parse Yahoo Finance response: {e}")
-            raise RateFetchError(f"Invalid response format: {e}")
-        except Exception as e:
-            logger.error(f"Unexpected error fetching from Yahoo Finance: {e}")
-            raise RateFetchError(f"Yahoo Finance fetch failed: {e}")
-
-    def supports_pair(self, base: str, quote: str) -> bool:
-        """
-        Check if Yahoo Finance supports the given currency pair.
-        
-        Yahoo Finance primarily supports major forex pairs.
-        """
-        base = base.upper()
-        quote = quote.upper()
-        
-        # Major currencies supported by Yahoo Finance
-        major_currencies = {
-            'USD', 'EUR', 'GBP', 'JPY', 'CHF', 'CAD', 'AUD', 'NZD',
-            'SEK', 'NOK', 'DKK', 'PLN', 'CZK', 'HUF', 'RUB', 'CNY',
-            'INR', 'KRW', 'SGD', 'HKD', 'THB', 'MXN', 'BRL', 'ZAR',
-            'TRY', 'ILS'
-        }
-        
-        return base in major_currencies and quote in major_currencies
-
-    def get_all_supported_currencies(self) -> Dict[str, str]:
-        """Get all major currencies supported by Yahoo Finance."""
-        return {
-            'USD': 'US Dollar',
-            'EUR': 'Euro',
-            'GBP': 'British Pound',
-            'JPY': 'Japanese Yen',
-            'CHF': 'Swiss Franc',
-            'CAD': 'Canadian Dollar',
-            'AUD': 'Australian Dollar',
-            'NZD': 'New Zealand Dollar',
-            'SEK': 'Swedish Krona',
-            'NOK': 'Norwegian Krone',
-            'DKK': 'Danish Krone',
-            'PLN': 'Polish Zloty',
-            'CZK': 'Czech Koruna',
-            'HUF': 'Hungarian Forint',
-            'RUB': 'Russian Ruble',
-            'CNY': 'Chinese Yuan',
-            'INR': 'Indian Rupee',
-            'KRW': 'South Korean Won',
-            'SGD': 'Singapore Dollar',
-            'HKD': 'Hong Kong Dollar',
-            'THB': 'Thai Baht',
-            'MXN': 'Mexican Peso',
-            'BRL': 'Brazilian Real',
-            'ZAR': 'South African Rand',
-            'TRY': 'Turkish Lira',
-            'ILS': 'Israeli Shekel'
-        }