django-cfg 1.4.3__py3-none-any.whl → 1.4.5__py3-none-any.whl

django_cfg/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.2.25] - 2025-09-24
+
+### Added
+- **Payment System Enhancements**: Unified payment provider configurations
+  - New `PaymentsConfig` model with provider-specific settings
+  - Enhanced validation utilities for API keys and subscription access
+  - Improved webhook handling and reliability
+  - Support for multiple payment providers (NowPayments, Cryptomus, etc.)
+- **Template System**: Enhanced project template management
+  - Improved template extraction and project name replacement
+  - Better integration with CLI `create-project` command
+  - More reliable template archiving system
+
+### Changed
+- **Project Structure**: Reorganized template location
+  - Moved Django sample project to `examples/django_sample`
+  - Improved template packaging for better distribution
+- **Dependencies**: Updated dependency management
+  - Better version constraint handling
+  - Improved package compatibility
+
+### Fixed
+- **Payment Validation**: Enhanced security for payment processing
+  - Improved API key validation
+  - Better webhook verification
+  - Fixed subscription access control issues
+- **CLI Tools**: Improved reliability of project creation
+  - Fixed template extraction issues
+  - Better error handling for project setup
+  - Improved project name replacement logic
+
+### Security
+- **Payment Processing**: Enhanced security measures
+  - Stronger API key validation
+  - Improved webhook verification
+  - Better access control for subscription features
+
+## [Previous Versions]
+
+### [1.2.24] and earlier
+- Core Django-CFG functionality
+- Basic payment provider support
+- Configuration management system
+- CLI tools for project creation
+- Health monitoring modules
+- Database and Redis integration
+
+---
+
+**Note**: This changelog focuses on user-facing features and API changes in the Django-CFG package.

django_cfg/CONTRIBUTING.md

@@ -0,0 +1,145 @@
+# 🤝 Contributing to Django-CFG
+
+Thank you for your interest in contributing to Django-CFG! This project aims to make Django configuration simple, type-safe, and developer-friendly.
+
+## 🚀 Quick Start
+
+### Development Setup
+
+1. **Clone the repository**
+   ```bash
+   git clone https://github.com/markolofsen/django-cfg.git
+   cd django-cfg
+   ```
+
+2. **Install dependencies**
+   ```bash
+   poetry install --extras dev
+   ```
+
+3. **Run tests**
+   ```bash
+   poetry run pytest
+   ```
+
+## 📋 Development Workflow
+
+### Making Changes
+
+1. **Create a feature branch**
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+
+2. **Make your changes**
+   - Follow the existing code style
+   - Add tests for new features
+   - Update documentation if needed
+
+3. **Test your changes**
+   ```bash
+   # Run all tests
+   poetry run pytest
+   
+   # Run with coverage
+   poetry run pytest --cov=django_cfg
+   
+   # Run linting
+   poetry run black src/ tests/
+   poetry run isort src/ tests/
+   poetry run flake8 src/ tests/
+   ```
+
+4. **Update version and generate requirements**
+   ```bash
+   # Use our development CLI
+   poetry run python scripts/dev_cli.py
+   
+   # Or manually bump version
+   poetry run python scripts/version_manager.py bump --bump-type patch
+   ```
+
+### Code Style
+
+- **Python**: Follow PEP 8, use Black for formatting
+- **Type Hints**: Required for all public APIs
+- **Documentation**: Add docstrings for public methods
+- **Tests**: Write tests for new features and bug fixes
+
+## 🧪 Testing
+
+### Running Tests
+
+```bash
+# All tests
+poetry run pytest
+
+# Specific test file
+poetry run pytest tests/test_basic_config.py
+
+# With coverage report
+poetry run pytest --cov=django_cfg --cov-report=html
+```
+
+### Writing Tests
+
+- Place tests in the `tests/` directory
+- Use descriptive test names
+- Test both success and error cases
+- Mock external dependencies
+
+## 📝 Pull Request Process
+
+1. **Ensure tests pass**
+   ```bash
+   poetry run pytest
+   ```
+
+2. **Update documentation** if your change affects the public API
+
+3. **Create a pull request** with:
+   - Clear description of changes
+   - Link to any related issues
+   - Screenshots for UI changes
+
+4. **Code review** - address any feedback from maintainers
+
+## 🐛 Bug Reports
+
+When reporting bugs, please include:
+
+- Django-CFG version
+- Django version
+- Python version
+- Minimal code example
+- Full error traceback
+
+## 💡 Feature Requests
+
+For new features:
+
+- Check existing issues first
+- Describe the use case clearly
+- Provide code examples if possible
+- Consider backward compatibility
+
+## 📚 Documentation
+
+Documentation improvements are always welcome:
+
+- Fix typos and grammar
+- Add examples and use cases
+- Improve API documentation
+- Update README with new features
+
+## ⚖️ License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.
+
+## 🙏 Recognition
+
+All contributors will be recognized in our README and release notes.
+
+---
+
+**Questions?** Open an issue or start a discussion. We're here to help! 🚀

django_cfg/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ReformsAI Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.3"
+__version__ = "1.4.4"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

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/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/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)