PyPI - django-cfg - Versions diffs - 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl - Mend

django-cfg 1.4.48py3-none-any.whl → 1.5.7py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of django-cfg might be problematic. Click here for more details.

Files changed (1022) hide show

django_cfg/modules/django_logging/LOGGING_GUIDE.md DELETED Viewed

@@ -1,504 +0,0 @@
-# Django CFG Logging Strategy Guide
-## Overview
-Django CFG uses a sophisticated logging system that automatically adjusts based on the `debug` configuration setting. This guide explains the logging architecture, how to control logging output, and best practices.
-## Core Principles
-### 1. Debug-Aware Logging
-Logging verbosity is controlled by the `config.debug` setting:
-```python
-# config.py
-debug: bool = False  # Production
-debug: bool = True   # Development
-```
-**Log Levels by Mode:**
-| Mode | Level | What You See |
-|------|-------|--------------|
-| `debug=True` | DEBUG | Everything: DEBUG, INFO, WARNING, ERROR, CRITICAL |
-| `debug=False` | WARNING | Only important: WARNING, ERROR, CRITICAL |
-**Why This Matters:**
-- **Production** (`debug=False`): Clean logs, only warnings and errors → easier monitoring
-- **Development** (`debug=True`): Verbose logs → easier debugging
-### 2. Modular File Structure
-Logs are organized by module for easy troubleshooting:
-```
-logs/
-├── django.log                    # All Django logs (root logger)
-└── djangocfg/
-    ├── core.log                  # Core django_cfg functionality
-    ├── apps.log                  # Apps (payments, agents, etc.)
-    ├── models.log                # Data models
-    └── modules.log               # Modules (logging, tasks, etc.)
-```
-**Automatic Module Detection:**
-The logging system automatically routes logs based on the logger name:
-- `django_cfg.core.*` → `core.log`
-- `django_cfg.apps.payments.*` → `apps.log`
-- `django_cfg.modules.*` → `modules.log`
-### 3. Dual Handler System
-Each django-cfg logger has TWO handlers:
-1. **Console Handler** (stdout/stderr)
-   - Uses Rich formatting for pretty output
-   - Respects debug level
-   - Shows in terminal during development
-2. **File Handler** (modular)
-   - Plain text format for parsing
-   - Module-specific files
-   - Persists for analysis
-## Configuration
-### YAML Configuration
-```yaml
-# config.dev.yaml
-debug: true  # Verbose logging
-# config.prod.yaml
-debug: false  # Only warnings/errors
-```
-### Environment Variable Fallback
-If config is not available, uses `DEBUG` environment variable:
-```bash
-DEBUG=true python manage.py runserver  # Verbose
-DEBUG=false python manage.py runserver # Quiet
-```
-## Usage Examples
-### Basic Logging
-```python
-from django_cfg.modules.django_logging import get_logger
-logger = get_logger(__name__)
-# These only show when debug=True:
-logger.debug("Detailed debugging information")
-logger.info("General informational message")
-# These ALWAYS show:
-logger.warning("Something unexpected happened")
-logger.error("An error occurred")
-logger.critical("Critical system failure")
-```
-### Auto-Detected Module Names
-The `get_logger()` function automatically detects the module:
-```python
-# In: /django_cfg/apps/payments/services/provider.py
-logger = get_logger()  # Auto-detects as 'django_cfg.apps.payments'
-# Manual override:
-logger = get_logger('django_cfg.custom_module')
-```
-### Rich Console Output
-When `debug=True`, you get beautifully formatted console output:
-```
-[10/02/25 17:52:00] INFO     🚀 Generated DRF settings
-                    INFO     ✅ Dramatiq enabled with 7 queues
-```
-When `debug=False`, console is silent except for warnings/errors.
-## Logger Types
-### 1. Django Logger (`django_logger.py`)
-**NEW Simple Auto-Configuring Logger**
-```python
-from django_cfg.modules.django_logging.django_logger import get_logger
-logger = get_logger(__name__)
-logger.info("This message respects debug mode")
-```
-**Features:**
-- Automatically respects `config.debug`
-- Modular file output
-- Single source of truth for all django-cfg logging
-**When to Use:** For all new django-cfg code (PREFERRED)
-### 2. Legacy Rich Logger (`logger.py`)
-**OLD Rich-Formatted Logger**
-```python
-from django_cfg.modules.django_logging.logger import DjangoCfgLogger
-logger = DjangoCfgLogger()
-logger.info("Rich formatted message")
-```
-**Features:**
-- Fancy Rich console formatting
-- NOW respects `config.debug` (recently fixed)
-- Used in older code
-**When to Use:** Existing code that hasn't been migrated yet
-## How Debug Control Works
-### Architecture Flow
-```
-┌─────────────────────────────────────────────────────┐
-│ 1. config.debug = False                            │
-│    (Set in config.dev.yaml / config.prod.yaml)     │
-└────────────────────┬────────────────────────────────┘
-                     │
-                     ▼
-┌─────────────────────────────────────────────────────┐
-│ 2. Logger Setup Detects Debug Mode                 │
-│    - Checks config.debug first                     │
-│    - Falls back to DEBUG env var                   │
-└────────────────────┬────────────────────────────────┘
-                     │
-                     ▼
-┌─────────────────────────────────────────────────────┐
-│ 3. Sets Log Level Based on Debug                   │
-│    - debug=True  → logging.DEBUG (all messages)    │
-│    - debug=False → logging.WARNING (warn+ only)    │
-└────────────────────┬────────────────────────────────┘
-                     │
-                     ▼
-┌─────────────────────────────────────────────────────┐
-│ 4. Configures Handlers                             │
-│    - Console Handler: level = log_level            │
-│    - File Handler: level = log_level               │
-│    - Both respect the same level                   │
-└────────────────────┬────────────────────────────────┘
-                     │
-                     ▼
-┌─────────────────────────────────────────────────────┐
-│ 5. Runtime Filtering                               │
-│    - logger.info() → Filtered out if debug=False   │
-│    - logger.warning() → Always passes through       │
-└─────────────────────────────────────────────────────┘
-```
-## Code Examples
-### Example 1: Simple Usage
-```python
-from django_cfg.modules.django_logging import get_logger
-logger = get_logger(__name__)
-def process_payment(amount: float):
-    logger.debug(f"Processing payment: ${amount}")  # Only in debug
-    try:
-        result = payment_gateway.charge(amount)
-        logger.info(f"Payment processed: {result.id}")  # Only in debug
-        return result
-    except PaymentError as e:
-        logger.error(f"Payment failed: {e}")  # Always shown
-        raise
-```
-### Example 2: Module-Specific Logging
-```python
-# File: django_cfg/apps/payments/services/nowpayments.py
-from django_cfg.modules.django_logging import get_logger
-# Auto-detects as 'django_cfg.apps.payments'
-logger = get_logger()
-class NowPaymentsProvider:
-    def __init__(self, api_key: str):
-        logger.debug(f"Initializing NowPayments: {api_key[:10]}...")
-        # Logs to: logs/djangocfg/apps.log
-```
-### Example 3: Conditional Debug Code
-```python
-from django_cfg.core.state import get_current_config
-config = get_current_config()
-if config and config.debug:
-    # Expensive operation only in debug mode
-    from django_cfg.modules.django_dashboard.debug import save_section_render
-    save_section_render('overview', html_content)
-else:
-    # Skip debug rendering in production
-    pass
-```
-## Troubleshooting
-### Issue: Still Seeing INFO Logs When debug=False
-**Possible Causes:**
-1. **Server not restarted** after changing config
-   ```bash
-   # Solution: Restart server
-   python manage.py runserver
-   ```
-2. **Wrong config file loaded**
-   ```bash
-   # Check which config is loaded
-   Loading config file: config.dev.ignore.yaml
-   [django-cfg] Modular logging configured successfully! Debug: False
-   ```
-3. **Using wrong logger**
-   ```python
-   # ❌ BAD: Standard logging (doesn't respect config)
-   import logging
-   logger = logging.getLogger(__name__)
-   # ✅ GOOD: Django CFG logger (respects config)
-   from django_cfg.modules.django_logging import get_logger
-   logger = get_logger(__name__)
-   ```
-### Issue: Logs Not Going to Files
-**Check:**
-1. **Directory permissions**
-   ```bash
-   ls -la logs/
-   # Should be writable
-   ```
-2. **Logger name prefix**
-   ```python
-   # Only 'django_cfg.*' loggers get modular files
-   logger = get_logger('django_cfg.my_module')  # ✅ Gets file
-   logger = get_logger('my_module')             # ❌ Console only
-   ```
-### Issue: No Console Output at All
-**Check debug status:**
-```python
-from django_cfg.core.state import get_current_config
-config = get_current_config()
-print(f"Debug: {config.debug}")
-# Expected output:
-# debug=True  → You'll see INFO, DEBUG, WARNING, ERROR
-# debug=False → You'll ONLY see WARNING, ERROR, CRITICAL
-```
-## Best Practices
-### 1. Use Appropriate Log Levels
-```python
-# DEBUG: Detailed diagnostic info
-logger.debug(f"SQL query: {query}")
-logger.debug(f"Function called with args: {args}")
-# INFO: Confirmation of expected behavior
-logger.info(f"User {user.id} logged in successfully")
-logger.info(f"Payment processor initialized")
-# WARNING: Something unexpected but handled
-logger.warning(f"API rate limit approaching: {count}/1000")
-logger.warning(f"Deprecated function called: {func.__name__}")
-# ERROR: Actual errors that need attention
-logger.error(f"Payment failed: {error}")
-logger.error(f"Database connection lost")
-# CRITICAL: System-level failures
-logger.critical(f"Redis connection failed - cache disabled")
-logger.critical(f"Unable to load configuration")
-```
-### 2. Structured Logging for Production
-```python
-# Include context for easier troubleshooting
-logger.error(
-    f"Payment processing failed",
-    extra={
-        'user_id': user.id,
-        'amount': amount,
-        'provider': 'nowpayments',
-        'error_code': error.code
-    }
-)
-```
-### 3. Performance Considerations
-```python
-# ❌ BAD: Expensive operation always runs
-debug_data = expensive_debug_operation()
-logger.debug(f"Debug data: {debug_data}")
-# ✅ GOOD: Only run when needed
-if logger.isEnabledFor(logging.DEBUG):
-    debug_data = expensive_debug_operation()
-    logger.debug(f"Debug data: {debug_data}")
-# ✅ BETTER: Check config directly
-config = get_current_config()
-if config and config.debug:
-    debug_data = expensive_debug_operation()
-    logger.debug(f"Debug data: {debug_data}")
-```
-### 4. Migration from Old Logging
-**Before (using standard logging):**
-```python
-import logging
-logger = logging.getLogger(__name__)
-logger.info("This always shows")  # Problem!
-```
-**After (using django-cfg logging):**
-```python
-from django_cfg.modules.django_logging import get_logger
-logger = get_logger(__name__)
-logger.info("This respects debug mode")  # Better!
-```
-## Quick Reference
-### Log Levels Cheat Sheet
-| Level | Numeric | When to Use | Shows in Production? |
-|-------|---------|-------------|---------------------|
-| DEBUG | 10 | Diagnostic details | ❌ No |
-| INFO | 20 | Confirmation messages | ❌ No |
-| WARNING | 30 | Unexpected but handled | ✅ Yes |
-| ERROR | 40 | Errors requiring attention | ✅ Yes |
-| CRITICAL | 50 | System-level failures | ✅ Yes |
-### Configuration Quick Check
-```python
-# In Python shell
-from django_cfg.core.state import get_current_config
-config = get_current_config()
-print(f"Debug mode: {config.debug}")
-print(f"Environment: {config.env_mode}")
-# Expected for production:
-# Debug mode: False
-# Environment: production
-```
-### File Location Quick Reference
-```bash
-# View recent logs
-tail -f logs/django.log                    # All logs
-tail -f logs/djangocfg/apps.log           # App-specific
-tail -f logs/djangocfg/core.log           # Core functionality
-# Search for errors
-grep ERROR logs/django.log
-grep CRITICAL logs/djangocfg/*.log
-```
-## Advanced Topics
-### Custom Log Formatting
-```python
-from django_cfg.modules.django_logging import get_logger
-import logging
-logger = get_logger(__name__)
-# Add custom formatter
-handler = logging.FileHandler('custom.log')
-formatter = logging.Formatter(
-    '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
-)
-handler.setFormatter(formatter)
-logger.addHandler(handler)
-```
-### Logging in Async Code
-```python
-import asyncio
-from django_cfg.modules.django_logging import get_logger
-logger = get_logger(__name__)
-async def async_task():
-    logger.debug("Starting async task")
-    await asyncio.sleep(1)
-    logger.info("Async task completed")
-```
-### Integration with External Services
-```python
-from django_cfg.modules.django_logging import get_logger
-import sentry_sdk
-logger = get_logger(__name__)
-def process_with_sentry():
-    try:
-        result = risky_operation()
-        logger.info(f"Operation succeeded: {result}")
-    except Exception as e:
-        logger.error(f"Operation failed: {e}")
-        sentry_sdk.capture_exception(e)
-        raise
-```
-## Summary
-The Django CFG logging system provides:
-✅ **Automatic debug-aware logging** - Respects `config.debug`
-✅ **Modular file organization** - Easy to find relevant logs
-✅ **Rich console formatting** - Beautiful development experience
-✅ **Production-ready** - Clean, parseable logs in production
-✅ **Easy migration** - Simple `get_logger()` function
-**Remember:** When `debug=False`, only WARNING, ERROR, and CRITICAL messages appear. This keeps production logs clean and focused on what matters.
----
-**Last Updated:** 2025-10-03
-**Django CFG Version:** 1.3.13
-**Python Version:** 3.10+

django_cfg/modules/django_tasks/__init__.py DELETED Viewed

@@ -1,29 +0,0 @@
-"""
-Django-CFG Task Service Module.
-Simplified task service for Dramatiq integration with essential functionality.
-"""
-from .factory import (
-    get_task_health,
-    get_task_service,
-    initialize_task_system,
-    is_task_system_available,
-    reset_task_service,
-)
-from .service import DjangoTasks
-from .settings import (
-    extend_constance_config_with_tasks,
-    generate_dramatiq_settings_from_config,
-)
-__all__ = [
-    "DjangoTasks",
-    "get_task_service",
-    "reset_task_service",
-    "is_task_system_available",
-    "get_task_health",
-    "generate_dramatiq_settings_from_config",
-    "extend_constance_config_with_tasks",
-    "initialize_task_system",
-]

django_cfg/modules/django_tasks/dramatiq_setup.py DELETED Viewed

@@ -1,20 +0,0 @@
-"""
-Dramatiq broker module for django-cfg CLI integration.
-This module provides the broker instance required by Dramatiq CLI.
-It's a thin wrapper around django_dramatiq.setup with broker export.
-Usage:
-    dramatiq django_cfg.modules.dramatiq_setup [task_modules...]
-"""
-# CRITICAL: Initialize Django BEFORE any model imports in worker processes
-import django
-# Initialize Django app registry (DJANGO_SETTINGS_MODULE must be set by caller)
-django.setup()
-# Re-export the broker for Dramatiq CLI
-import dramatiq
-broker = dramatiq.get_broker()

django_cfg/modules/django_tasks/factory.py DELETED Viewed

@@ -1,127 +0,0 @@
-"""
-Task service factory and utilities.
-Provides singleton instance and utility functions.
-"""
-import logging
-from typing import Any, Dict
-logger = logging.getLogger(__name__)
-# Lazy import to avoid circular dependency
-_task_service_instance = None
-def get_task_service():
-    """Get the global task service instance."""
-    global _task_service_instance
-    if _task_service_instance is None:
-        from .service import DjangoTasks
-        _task_service_instance = DjangoTasks()
-    return _task_service_instance
-def reset_task_service():
-    """Reset the global task service instance (useful for testing)."""
-    global _task_service_instance
-    _task_service_instance = None
-def is_task_system_available() -> bool:
-    """Check if task system is available and properly configured."""
-    try:
-        service = get_task_service()
-        return service.is_enabled()
-    except Exception:
-        return False
-def get_task_health() -> Dict[str, Any]:
-    """Get task system health status."""
-    try:
-        service = get_task_service()
-        return service.get_health_status()
-    except Exception as e:
-        return {
-            "enabled": False,
-            "error": str(e),
-            "redis_connection": False,
-            "configuration_valid": False,
-        }
-def initialize_task_system():
-    """
-    Initialize the task system during Django app startup.
-    This function is called from Django AppConfig.ready() method.
-    """
-    try:
-        service = get_task_service()
-        # Force config reload to ensure we have fresh config
-        service._config = None
-        config = service.config
-        if config and config.enabled:
-            logger.info("🔧 Initializing Django-CFG task system...")
-            # Set up Dramatiq broker from Django settings
-            try:
-                import dramatiq
-                from django.conf import settings
-                # Django-dramatiq automatically configures the broker from DRAMATIQ_BROKER setting
-                if hasattr(settings, 'DRAMATIQ_BROKER'):
-                    # Configure broker with middleware
-                    broker_config = settings.DRAMATIQ_BROKER
-                    middleware_list = getattr(settings, 'DRAMATIQ_MIDDLEWARE', [])
-                    # Import and instantiate middleware
-                    middleware_instances = []
-                    for middleware_path in middleware_list:
-                        try:
-                            module_path, class_name = middleware_path.rsplit('.', 1)
-                            module = __import__(module_path, fromlist=[class_name])
-                            middleware_class = getattr(module, class_name)
-                            middleware_instances.append(middleware_class())
-                        except Exception as e:
-                            logger.warning(f"Failed to load middleware {middleware_path}: {e}")
-                    # Create broker with middleware
-                    broker_class_path = broker_config['BROKER']
-                    module_path, class_name = broker_class_path.rsplit('.', 1)
-                    module = __import__(module_path, fromlist=[class_name])
-                    broker_class = getattr(module, class_name)
-                    broker_options = broker_config.get('OPTIONS', {})
-                    broker = broker_class(middleware=middleware_instances, **broker_options)
-                    # Set as default broker
-                    dramatiq.set_broker(broker)
-                    logger.debug(f"✅ Dramatiq broker configured with {len(middleware_instances)} middleware")
-                else:
-                    logger.warning("DRAMATIQ_BROKER not found in Django settings")
-            except Exception as e:
-                logger.warning(f"Failed to configure Dramatiq: {e}")
-            logger.info("✅ Task system initialized successfully")
-            logger.info("💡 To start workers, run: python manage.py rundramatiq")
-        else:
-            logger.debug(f"Task system not enabled (config: {config}), skipping initialization")
-    except Exception as e:
-        logger.error(f"Failed to initialize task system: {e}")
-__all__ = [
-    "get_task_service",
-    "reset_task_service",
-    "is_task_system_available",
-    "get_task_health",
-    "initialize_task_system",
-]

django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

Potentially problematic release.

django-cfg 1.4.48py3-none-any.whl → 1.5.7py3-none-any.whl