tessl/pypi-fastapi-slim

FastAPI framework, high performance, easy to learn, fast to code, ready for production - slim version without standard dependencies

—

Pending

Overview

Eval results

Files

API Routing

Name: tessl/pypi-fastapi-slim
Author: tessl

The APIRouter class enables modular organization of API endpoints into logical groups with shared configuration like prefixes, tags, dependencies, and responses. Routers can be nested hierarchically and included in the main FastAPI application or other routers.

Capabilities

APIRouter Class

Router class for grouping related endpoints with shared configuration and hierarchical organization.

class APIRouter:
    def __init__(
        self,
        *,
        prefix: str = "",
        tags: Optional[List[Union[str, Enum]]] = None,
        dependencies: Optional[Sequence[Depends]] = None,
        default_response_class: Type[Response] = Default(JSONResponse),
        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
        callbacks: Optional[List[BaseRoute]] = None,
        routes: Optional[List[BaseRoute]] = None,
        redirect_slashes: bool = True,
        default: Optional[ASGIApp] = None,
        dependency_overrides_provider: Optional[Any] = None,
        route_class: Type[APIRoute] = APIRoute,
        on_startup: Optional[Sequence[Callable]] = None,
        on_shutdown: Optional[Sequence[Callable]] = None,
        lifespan: Optional[Callable] = None,
        deprecated: Optional[bool] = None,
        include_in_schema: bool = True,
        generate_unique_id_function: Callable[[APIRoute], str] = Default(generate_unique_id)
    ):
        """
        Create an APIRouter instance.

        Parameters:
        - prefix: URL prefix for all routes in this router
        - tags: List of tags applied to all routes in this router
        - dependencies: List of dependencies applied to all routes in this router
        - default_response_class: Default response class for all routes
        - responses: Default additional responses for all routes
        - callbacks: List of callback routes
        - routes: List of route instances to include
        - redirect_slashes: Automatically redirect URLs with trailing slashes
        - default: Default ASGI app to call for unmatched routes
        - dependency_overrides_provider: Provider for dependency overrides
        - route_class: Class to use for API routes
        - on_startup: Functions to run on router startup (deprecated)
        - on_shutdown: Functions to run on router shutdown (deprecated)
        - lifespan: Async context manager for router lifespan events
        - deprecated: Mark all routes in this router as deprecated
        - include_in_schema: Include all routes in OpenAPI schema
        - generate_unique_id_function: Function to generate unique operation IDs
        """

HTTP Method Decorators

Decorators for defining HTTP endpoints within the router with the same functionality as FastAPI application decorators.

def get(
    self,
    path: str,
    *,
    response_model: Any = Default(None),
    status_code: Optional[int] = None,
    tags: Optional[List[Union[str, Enum]]] = None,
    dependencies: Optional[Sequence[Depends]] = None,
    summary: Optional[str] = None,
    description: Optional[str] = None,
    response_description: str = "Successful Response",
    responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
    deprecated: Optional[bool] = None,
    operation_id: Optional[str] = None,
    response_model_include: Optional[IncEx] = None,
    response_model_exclude: Optional[IncEx] = None,
    response_model_by_alias: bool = True,
    response_model_exclude_unset: bool = False,
    response_model_exclude_defaults: bool = False,
    response_model_exclude_none: bool = False,
    include_in_schema: bool = True,
    response_class: Type[Response] = Default(JSONResponse),
    name: Optional[str] = None,
    callbacks: Optional[List[BaseRoute]] = None,
    openapi_extra: Optional[Dict[str, Any]] = None,
    generate_unique_id_function: Callable[[APIRoute], str] = Default(generate_unique_id)
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """Create a GET endpoint decorator within this router."""

def post(self, path: str, **kwargs) -> Callable:
    """Create a POST endpoint decorator within this router."""

def put(self, path: str, **kwargs) -> Callable:
    """Create a PUT endpoint decorator within this router."""

def delete(self, path: str, **kwargs) -> Callable:
    """Create a DELETE endpoint decorator within this router."""

def patch(self, path: str, **kwargs) -> Callable:
    """Create a PATCH endpoint decorator within this router."""

def options(self, path: str, **kwargs) -> Callable:
    """Create an OPTIONS endpoint decorator within this router."""

def head(self, path: str, **kwargs) -> Callable:
    """Create a HEAD endpoint decorator within this router."""

def trace(self, path: str, **kwargs) -> Callable:
    """Create a TRACE endpoint decorator within this router."""

WebSocket Support

Decorator for defining WebSocket endpoints within the router.

def websocket(
    self,
    path: str,
    *,
    name: Optional[str] = None,
    dependencies: Optional[Sequence[Depends]] = None,
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Create a WebSocket endpoint decorator within this router.

    Parameters:
    - path: URL path for the WebSocket endpoint
    - name: Name for the endpoint (for URL reversing)
    - dependencies: List of dependencies for this endpoint
    """

Router Inclusion

Method for including other routers within this router, enabling hierarchical router organization.

def include_router(
    self,
    router: "APIRouter",
    *,
    prefix: str = "",
    tags: Optional[List[Union[str, Enum]]] = None,
    dependencies: Optional[Sequence[Depends]] = None,
    responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
    deprecated: Optional[bool] = None,
    include_in_schema: bool = True,
    default_response_class: Type[Response] = Default(JSONResponse),
    callbacks: Optional[List[BaseRoute]] = None
) -> None:
    """
    Include another APIRouter within this router.

    Parameters:
    - router: APIRouter instance to include
    - prefix: Additional URL prefix for the included router
    - tags: Additional tags for all routes in the included router
    - dependencies: Additional dependencies for all routes in the included router
    - responses: Additional responses for all routes in the included router
    - deprecated: Mark all routes in the included router as deprecated
    - include_in_schema: Include included router routes in OpenAPI schema
    - default_response_class: Default response class for included router routes
    - callbacks: Additional callbacks for all routes in the included router
    """

Programmatic Route Management

Methods for adding routes programmatically instead of using decorators.

def add_api_route(
    self,
    path: str,
    endpoint: Callable,
    *,
    methods: Optional[Union[Set[str], List[str]]] = None,
    name: Optional[str] = None,
    dependencies: Optional[Sequence[Depends]] = None,
    **kwargs: Any
) -> None:
    """
    Add an API route programmatically to this router.

    Parameters:
    - path: URL path for the route
    - endpoint: Function to handle the route
    - methods: HTTP methods for the route (defaults to ["GET"])
    - name: Name for the route
    - dependencies: Dependencies for the route
    """

def add_websocket_route(
    self,
    path: str,
    endpoint: Callable,
    name: Optional[str] = None
) -> None:
    """
    Add a WebSocket route programmatically to this router.

    Parameters:
    - path: URL path for the WebSocket route
    - endpoint: Function to handle the WebSocket connection
    - name: Name for the route
    """

Generic Route Decorator

Generic decorator for creating routes with custom HTTP methods.

def route(
    self,
    path: str,
    methods: Optional[List[str]] = None,
    name: Optional[str] = None,
    include_in_schema: bool = True
) -> Callable:
    """
    Create a generic route decorator for custom HTTP methods.

    Parameters:
    - path: URL path for the route
    - methods: List of HTTP methods to handle
    - name: Name for the route
    - include_in_schema: Include route in OpenAPI schema
    """

Sub-Application Mounting

Method for mounting WSGI or ASGI applications within the router.

def mount(
    self,
    path: str,
    app: ASGIApp,
    name: Optional[str] = None
) -> None:
    """
    Mount a sub-application at the given path within this router.

    Parameters:
    - path: Path to mount the application at
    - app: WSGI or ASGI application to mount
    - name: Name for the mounted application
    """

Route Classes

APIRoute

Class representing individual API routes with their configuration and metadata.

class APIRoute:
    def __init__(
        self,
        path: str,
        endpoint: Callable,
        *,
        response_model: Any = Default(None),
        status_code: Optional[int] = None,
        tags: Optional[List[Union[str, Enum]]] = None,
        dependencies: Optional[Sequence[Depends]] = None,
        summary: Optional[str] = None,
        description: Optional[str] = None,
        response_description: str = "Successful Response",
        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
        deprecated: Optional[bool] = None,
        methods: Optional[Union[Set[str], List[str]]] = None,
        operation_id: Optional[str] = None,
        response_model_include: Optional[IncEx] = None,
        response_model_exclude: Optional[IncEx] = None,
        response_model_by_alias: bool = True,
        response_model_exclude_unset: bool = False,
        response_model_exclude_defaults: bool = False,
        response_model_exclude_none: bool = False,
        include_in_schema: bool = True,
        response_class: Type[Response] = Default(JSONResponse),
        name: Optional[str] = None,
        callbacks: Optional[List[BaseRoute]] = None,
        openapi_extra: Optional[Dict[str, Any]] = None,
        generate_unique_id_function: Callable[["APIRoute"], str] = Default(generate_unique_id)
    ):
        """
        Individual API route configuration.

        Properties:
        - path: URL path pattern
        - endpoint: Handler function
        - methods: HTTP methods handled by this route
        - response_model: Pydantic model for response serialization
        - status_code: Default HTTP status code
        - tags: OpenAPI tags
        - dependencies: Route-specific dependencies
        - name: Route name for URL reversing
        """

APIWebSocketRoute

Class representing WebSocket routes.

class APIWebSocketRoute:
    def __init__(
        self,
        path: str,
        endpoint: Callable,
        *,
        name: Optional[str] = None,
        dependencies: Optional[Sequence[Depends]] = None
    ):
        """
        WebSocket route configuration.

        Properties:
        - path: URL path pattern
        - endpoint: WebSocket handler function
        - name: Route name for URL reversing
        - dependencies: Route-specific dependencies
        """

Usage Examples

Basic Router Setup

from fastapi import APIRouter, Depends
from pydantic import BaseModel

# Create router with shared configuration
router = APIRouter(
    prefix="/items",
    tags=["items"],
    dependencies=[Depends(verify_auth)],
    responses={404: {"description": "Not found"}}
)

class Item(BaseModel):
    name: str
    price: float

@router.get("/")
async def get_items():
    return [{"name": "Item 1", "price": 10.5}]

@router.post("/", response_model=Item)
async def create_item(item: Item):
    return item

@router.get("/{item_id}")
async def get_item(item_id: int):
    return {"name": f"Item {item_id}", "price": 10.5}

Hierarchical Router Organization

from fastapi import FastAPI, APIRouter

# Main application
app = FastAPI()

# API v1 router
api_v1 = APIRouter(prefix="/api/v1")

# Feature-specific routers
users_router = APIRouter(prefix="/users", tags=["users"])
items_router = APIRouter(prefix="/items", tags=["items"])

@users_router.get("/")
async def get_users():
    return [{"id": 1, "name": "John"}]

@users_router.get("/{user_id}")
async def get_user(user_id: int):
    return {"id": user_id, "name": "John"}

@items_router.get("/")
async def get_items():
    return [{"id": 1, "name": "Item 1"}]

# Include feature routers in API v1
api_v1.include_router(users_router)
api_v1.include_router(items_router)

# Include API v1 in main app
app.include_router(api_v1)

# Final URLs:
# GET /api/v1/users/
# GET /api/v1/users/{user_id}
# GET /api/v1/items/

Router with Shared Dependencies

from fastapi import APIRouter, Depends, HTTPException

def get_current_user(token: str = Depends(get_token)):
    if not token:
        raise HTTPException(status_code=401, detail="Not authenticated")
    return {"user_id": 1, "username": "john"}

def verify_admin(user: dict = Depends(get_current_user)):
    if not user.get("is_admin"):
        raise HTTPException(status_code=403, detail="Not enough permissions")
    return user

# Admin router with shared admin dependency
admin_router = APIRouter(
    prefix="/admin",
    tags=["admin"],
    dependencies=[Depends(verify_admin)]
)

@admin_router.get("/users")
async def get_all_users():
    # Only accessible by admin users
    return [{"id": 1, "name": "John"}, {"id": 2, "name": "Jane"}]

@admin_router.delete("/users/{user_id}")
async def delete_user(user_id: int):
    # Only accessible by admin users
    return {"message": f"User {user_id} deleted"}

Router with Custom Response Classes

from fastapi import APIRouter
from fastapi.responses import PlainTextResponse, HTMLResponse

router = APIRouter(prefix="/content")

@router.get("/text", response_class=PlainTextResponse)
async def get_text():
    return "This is plain text"

@router.get("/html", response_class=HTMLResponse)
async def get_html():
    return "<html><body><h1>Hello HTML</h1></body></html>"

@router.get("/json")  # Uses default JSONResponse
async def get_json():
    return {"message": "This is JSON"}

WebSocket Router

from fastapi import APIRouter, WebSocket

ws_router = APIRouter(prefix="/ws")

@ws_router.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    try:
        while True:
            data = await websocket.receive_text()
            await websocket.send_text(f"Message text was: {data}")
    except WebSocketDisconnect:
        print("Client disconnected")

Install with Tessl CLI