Buckets:

download
raw
7.06 kB
"""
URL routing utilities for FastJango.
"""
import re
from typing import Any, Callable, Dict, List, Optional, Tuple, Union
from fastapi import APIRouter, Depends, HTTPException, Request, Response
from fastapi.routing import APIRoute
from fastjango.core.dependencies import get_current_user
from fastjango.http import HttpResponse
class Path:
"""
A path definition for URL routing.
"""
def __init__(self, path: str, view: Callable, name: Optional[str] = None):
"""
Initialize a path.
Args:
path: The URL path
view: The view function or class
name: The name of the path
"""
# Ensure path doesn't start with a slash for consistency
self.path = path[1:] if path.startswith('/') else path
self.view = view
self.name = name
self.methods = ["GET"] # Default to GET method
self.kwargs = {} # Additional kwargs for add_api_route
def path(path: str, view: Callable, name: Optional[str] = None) -> Path:
"""
Define a path for URL routing.
Args:
path: The URL path
view: The view function or class
name: The name of the path
Returns:
A Path object
"""
return Path(path, view, name)
class Include:
"""
A class to store included URL patterns.
"""
def __init__(self, patterns: List[Path], namespace: Optional[str], path: str):
"""
Initialize an include.
Args:
patterns: The URL patterns to include
namespace: The namespace for the included patterns
path: The path prefix for the included patterns
"""
self.patterns = patterns
self.namespace = namespace
self.path = path
def include(module_path: str, namespace: Optional[str] = None) -> Tuple[List[Path], Optional[str], str]:
"""
Include paths from another module.
Args:
module_path: The module path to include
namespace: Optional namespace override
Returns:
A tuple of (paths, namespace, module_path)
"""
# Import the module
import importlib
try:
module = importlib.import_module(module_path)
except ImportError as e:
raise ImportError(f"Could not import '{module_path}'. {e}")
# Get the urlpatterns from the module
urlpatterns = getattr(module, "urlpatterns", [])
# Get the app_name from the module or use the provided namespace
app_name = namespace or getattr(module, "app_name", None)
# Extract the path prefix - use the last component of the module path
# that isn't 'urls' (which is a convention, not part of the URL)
path_parts = module_path.split(".")
path_prefix = ""
for part in reversed(path_parts):
if part != "urls":
path_prefix = part
break
# Ensure path_prefix doesn't start with a slash
if path_prefix.startswith('/'):
path_prefix = path_prefix[1:]
# Return a tuple with the urlpatterns, app_name and path_prefix
return urlpatterns, app_name, path_prefix
class URLResolver:
"""
A URL resolver for FastJango.
"""
def __init__(self, router: APIRouter) -> None:
"""
Initialize the URL resolver.
Args:
router: The FastAPI router to use
"""
self.router = router
def register(self, urlpatterns: List[Path], prefix: str = "") -> None:
"""
Register URL patterns with the FastAPI router.
Args:
urlpatterns: The URL patterns to register
prefix: The URL prefix to use
"""
for path_obj in urlpatterns:
if isinstance(path_obj.view, tuple):
# This is a result of include()
included_patterns, namespace, included_prefix = path_obj.view
# Combine the prefixes properly
combined_prefix = prefix
if path_obj.path:
# Ensure path doesn't start with a slash when adding to prefix
route = path_obj.path
if route.startswith('/'):
route = route[1:]
# Handle case where prefix is empty
if combined_prefix:
combined_prefix = f"{combined_prefix}/{route}"
else:
combined_prefix = route
# Register included patterns with the combined prefix
self.register(included_patterns, prefix=combined_prefix)
else:
# Convert the path to FastAPI format
route_path = self._convert_path(path_obj.path)
# Add prefix if present
if prefix:
# Format prefix properly
clean_prefix = prefix
if clean_prefix.startswith('/'):
clean_prefix = clean_prefix[1:]
if clean_prefix.endswith('/'):
clean_prefix = clean_prefix[:-1]
if route_path == "/":
route_path = f"/{clean_prefix}"
else:
route_path = f"/{clean_prefix}{route_path}"
# Register the route with the FastAPI router
try:
self.router.add_api_route(
route_path,
path_obj.view,
name=path_obj.name,
)
except Exception as e:
from fastjango.core.logging import Logger
logger = Logger("fastjango.urls")
logger.error(f"Failed to register route {route_path}: {e}")
def _convert_path(self, path: str) -> str:
"""
Convert a Django-style path to a FastAPI path.
Args:
path: The Django-style path
Returns:
The FastAPI-style path
"""
# Normalize multiple slashes to single slashes
path = re.sub(r'//+', '/', path)
# Replace Django-style path parameters with FastAPI-style
# e.g., /<int:id>/ becomes /{id}/
path = re.sub(r'<int:(\w+)>', r'{\1}', path)
path = re.sub(r'<str:(\w+)>', r'{\1}', path)
path = re.sub(r'<slug:(\w+)>', r'{\1}', path)
path = re.sub(r'<uuid:(\w+)>', r'{\1}', path)
path = re.sub(r'<path:(\w+)>', r'{\1}', path)
# Remove trailing slash if present
if path.endswith('/') and len(path) > 1:
path = path[:-1]
# Ensure path starts with a slash for FastAPI
if not path.startswith('/'):
path = '/' + path
elif path == "":
path = "/"
return path

Xet Storage Details

Size:
7.06 kB
·
Xet hash:
a2120f5c6200d750a72050c688624ebbf41808913cf458bff2f5b5d62a0fe1df

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.