django-bolt 0.1.0__cp310-abi3-win_amd64.whl

django_bolt/admin/routes.py

@@ -0,0 +1,91 @@
+"""
+Django admin route registration for BoltAPI.
+
+This module handles the registration of Django admin routes via ASGI bridge,
+keeping the BoltAPI class lean and focused.
+"""
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from django_bolt.api import BoltAPI
+
+
+class AdminRouteRegistrar:
+    """Handles registration of Django admin routes via ASGI bridge."""
+
+    def __init__(self, api: 'BoltAPI'):
+        """Initialize the registrar with a BoltAPI instance.
+
+        Args:
+            api: The BoltAPI instance to register routes on
+        """
+        self.api = api
+
+    def register_routes(self, host: str = "localhost", port: int = 8000) -> None:
+        """Register Django admin routes via ASGI bridge.
+
+        This method auto-registers routes for Django admin if it's installed
+        and enabled. The routes use an ASGI bridge to handle Django's middleware
+        stack (sessions, CSRF, auth, etc.).
+
+        Args:
+            host: Server hostname for ASGI scope
+            port: Server port for ASGI scope
+        """
+        if self.api._admin_routes_registered:
+            return
+
+        # Check if admin should be enabled
+        from django_bolt.admin.admin_detection import should_enable_admin, get_admin_route_patterns
+
+        if not should_enable_admin():
+            return
+
+        # Get admin route patterns
+        route_patterns = get_admin_route_patterns()
+        if not route_patterns:
+            return
+
+        # Lazy-load ASGI handler
+        if self.api._asgi_handler is None:
+            from django_bolt.admin.asgi_bridge import ASGIFallbackHandler
+            self.api._asgi_handler = ASGIFallbackHandler(host, port)
+
+        # Register admin routes for each method
+        for path_pattern, methods in route_patterns:
+            for method in methods:
+                self._register_admin_route(method, path_pattern)
+
+        self.api._admin_routes_registered = True
+
+    def _register_admin_route(self, method: str, path_pattern: str) -> None:
+        """Register a single admin route.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path_pattern: URL path pattern
+        """
+        # Create handler that delegates to ASGI bridge
+        # NOTE: We need to create a new function for each route to avoid closure issues
+        def make_admin_handler(asgi_handler):
+            async def admin_handler(request):
+                return await asgi_handler.handle_request(request)
+            return admin_handler
+
+        admin_handler = make_admin_handler(self.api._asgi_handler)
+
+        # Register the route using internal route registration
+        # This bypasses the decorator to avoid async enforcement issues
+        handler_id = self.api._next_handler_id
+        self.api._next_handler_id += 1
+
+        self.api._routes.append((method, path_pattern, handler_id, admin_handler))
+        self.api._handlers[handler_id] = admin_handler
+
+        # Create minimal metadata for admin handlers
+        meta = {
+            "mode": "request_only",
+            "sig": None,
+            "fields": [],
+        }
+        self.api._handler_meta[admin_handler] = meta

django_bolt/admin/static.py

@@ -0,0 +1,155 @@
+"""
+Static file serving utilities for Django-Bolt.
+
+Provides static file serving for Django admin and other static assets.
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, Tuple, List, Dict, Any
+
+
+def find_static_file(path: str) -> Optional[str]:
+    """
+    Find a static file using Django's static file finders.
+
+    Args:
+        path: Relative path to static file (e.g., 'admin/css/base.css')
+
+    Returns:
+        Absolute path to file if found, None otherwise
+    """
+    try:
+        from django.conf import settings
+
+        # First try STATIC_ROOT (collected static files in production)
+        if hasattr(settings, 'STATIC_ROOT') and settings.STATIC_ROOT:
+            static_root = Path(settings.STATIC_ROOT)
+            file_path = static_root / path
+            if file_path.exists() and file_path.is_file():
+                return str(file_path)
+
+        # Try using Django's static file finders (development mode)
+        try:
+            from django.contrib.staticfiles.finders import find
+            found_path = find(path)
+            if found_path:
+                return found_path
+        except ImportError:
+            # staticfiles not installed
+            pass
+
+        # Fallback: check STATICFILES_DIRS
+        if hasattr(settings, 'STATICFILES_DIRS'):
+            for static_dir in settings.STATICFILES_DIRS:
+                if isinstance(static_dir, tuple):
+                    static_dir = static_dir[1]  # (prefix, path) tuple
+                file_path = Path(static_dir) / path
+                if file_path.exists() and file_path.is_file():
+                    return str(file_path)
+
+    except Exception as e:
+        import sys
+        print(f"[django-bolt] Warning: Error finding static file {path}: {e}", file=sys.stderr)
+
+    return None
+
+
+def guess_content_type(file_path: str) -> str:
+    """
+    Guess content type from file extension.
+
+    Args:
+        file_path: Path to file
+
+    Returns:
+        MIME type string
+    """
+    import mimetypes
+
+    content_type, _ = mimetypes.guess_type(file_path)
+    if content_type:
+        return content_type
+
+    # Fallback for common static file types
+    ext = os.path.splitext(file_path)[1].lower()
+    type_map = {
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.eot': 'application/vnd.ms-fontobject',
+    }
+
+    return type_map.get(ext, 'application/octet-stream')
+
+
+async def serve_static_file(path: str) -> Tuple[int, List[Tuple[str, str]], bytes]:
+    """
+    Serve a static file using Django's static file system.
+
+    Args:
+        path: Relative path to static file
+
+    Returns:
+        Response tuple: (status_code, headers, body)
+    """
+    from ..exceptions import HTTPException
+
+    # Security: prevent directory traversal
+    if '..' in path or path.startswith('/'):
+        raise HTTPException(400, "Invalid static file path")
+
+    # Find the static file
+    file_path = find_static_file(path)
+
+    if not file_path:
+        raise HTTPException(404, f"Static file not found: {path}")
+
+    # Return FileResponse (Rust will handle streaming)
+    from ..responses import FileResponse
+    content_type = guess_content_type(file_path)
+
+    # Use FileResponse which returns the special file response format
+    return FileResponse(
+        file_path,
+        headers={"content-type": content_type}
+    )
+
+
+def register_static_routes(api, static_url: Optional[str] = None):
+    """
+    Register static file serving routes on a BoltAPI instance.
+
+    Args:
+        api: BoltAPI instance
+        static_url: Static URL prefix (default: from settings.STATIC_URL)
+    """
+    from django.conf import settings
+
+    if static_url is None:
+        if not hasattr(settings, 'STATIC_URL') or not settings.STATIC_URL:
+            # Static files not configured
+            return
+        static_url = settings.STATIC_URL.strip('/')
+
+    if not static_url:
+        static_url = 'static'
+
+    # Register catch-all route for static files
+    route_pattern = f'/{static_url}/{{path:path}}'
+
+    @api.get(route_pattern)
+    async def serve_static(path: str):
+        """Serve static files for Django admin and other apps."""
+        return await serve_static_file(path)
+
+    return serve_static

django_bolt/admin/static_routes.py

@@ -0,0 +1,111 @@
+"""
+Static file route registration for Django admin.
+
+This module handles the registration of static file serving routes
+needed by Django admin and other Django apps.
+"""
+import inspect
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from django_bolt.api import BoltAPI
+
+
+class StaticRouteRegistrar:
+    """Handles registration of static file serving routes."""
+
+    def __init__(self, api: 'BoltAPI'):
+        """Initialize the registrar with a BoltAPI instance.
+
+        Args:
+            api: The BoltAPI instance to register routes on
+        """
+        self.api = api
+
+    def register_routes(self) -> None:
+        """Register static file serving routes for Django admin.
+
+        This enables serving of CSS, JS, and other static assets needed
+        by Django admin and other Django apps.
+        """
+        if self.api._static_routes_registered:
+            return
+
+        # Only register static routes if admin routes were registered
+        # (admin needs static files for CSS/JS)
+        if not self.api._admin_routes_registered:
+            return
+
+        try:
+            from django.conf import settings
+
+            # Check if static files are configured
+            if not hasattr(settings, 'STATIC_URL') or not settings.STATIC_URL:
+                return
+
+            static_url = settings.STATIC_URL.strip('/')
+            if not static_url:
+                static_url = 'static'
+
+            # Register catch-all route for static files
+            route_pattern = f'/{static_url}/{{path:path}}'
+
+            # Import here to avoid circular dependency
+            from django_bolt.admin.static import serve_static_file
+
+            # Create static file handler
+            async def static_handler(path: str):
+                """Serve static files for Django admin and other apps."""
+                return await serve_static_file(path)
+
+            # Register the route
+            self._register_static_route(route_pattern, static_handler)
+
+            self.api._static_routes_registered = True
+
+        except Exception as e:
+            import sys
+            print(f"[django-bolt] Warning: Failed to register static routes: {e}", file=sys.stderr)
+
+    def _register_static_route(self, route_pattern: str, handler) -> None:
+        """Register a static file serving route.
+
+        Args:
+            route_pattern: URL path pattern (e.g., /static/{path:path})
+            handler: Async handler function for serving static files
+        """
+        handler_id = self.api._next_handler_id
+        self.api._next_handler_id += 1
+
+        self.api._routes.append(("GET", route_pattern, handler_id, handler))
+        self.api._handlers[handler_id] = handler
+
+        # Create metadata for static handler
+        # Extract path parameter metadata
+        sig = inspect.signature(handler)
+        meta = {
+            "mode": "mixed",
+            "sig": sig,
+            "fields": [{
+                "name": "path",
+                "annotation": str,
+                "default": inspect.Parameter.empty,
+                "kind": inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                "source": "path",
+                "alias": None,
+                "embed": False,
+                "dependency": None,
+            }],
+            "path_params": {"path"},
+            "params": [{
+                "name": "path",
+                "annotation": str,
+                "default": inspect.Parameter.empty,
+                "kind": inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                "source": "path",
+                "alias": None,
+                "embed": False,
+                "dependency": None,
+            }],
+        }
+        self.api._handler_meta[handler] = meta