FastAPI 接口文档全局登录验证依赖过滤指定接口

已于 2023-02-24 11:31:03 修改
阅读量1k 收藏 5
点赞数 2
文章标签： fastapi python
于 2023-02-24 11:29:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29983177/article/details/129197286
版权

FastAPI 接口文档全局登录验证依赖过滤指定接口

在学习FastAPI过程中，发现接口登录验证不好管理，添加全局验证依赖之后，所有接口都需要登录验证，如果有的接口不需要登录验证，那该如何实现？
并没有找到官方解决方法。在这里插入图片描述

那如何解决？

查看APIRouter源码发现，每个http方法的依赖由add_api_route中dependencies决定，要更改每个接口的依赖项，需要修改源码中：
在这里插入图片描述

如何修改？
重写APIRouter类，重写其add_api_route、api_route、get、post、delete、update、options、head、patch、trace方法，新增参数unload_dependencies
关键实现：
在这里插入图片描述

源码 applications.py

from enum import Enum
from typing import (
    Any,
    Callable,
    Dict,
    List,
    Optional,
    Sequence,
    Set,
    Type,
    Union
)

from fastapi import params
from fastapi.datastructures import Default, DefaultPlaceholder
from fastapi.encoders import DictIntStrAny, SetIntStr
from fastapi.routing import APIRoute, APIRouter
from fastapi.types import DecoratedCallable
from fastapi.utils import (
    generate_unique_id,
    get_value_or_default,
)
from starlette.responses import JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.routing import Mount as Mount  # noqa


class MyAPIRouter(APIRouter):
    def add_api_route(
            self,
            path: str,
            endpoint: Callable[..., Any],
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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: Union[Type[Response], DefaultPlaceholder] = Default(
                JSONResponse
            ),
            name: Optional[str] = None,
            route_class_override: Optional[Type[APIRoute]] = None,
            callbacks: Optional[List[BaseRoute]] = None,
            openapi_extra: Optional[Dict[str, Any]] = None,
            generate_unique_id_function: Union[
                Callable[[APIRoute], str], DefaultPlaceholder
            ] = Default(generate_unique_id),
    ) -> None:
        route_class = route_class_override or self.route_class
        responses = responses or {}
        combined_responses = {**self.responses, **responses}
        current_response_class = get_value_or_default(
            response_class, self.default_response_class
        )
        current_tags = self.tags.copy()
        if tags:
            current_tags.extend(tags)
        current_dependencies = self.dependencies.copy()
        if dependencies:
            current_dependencies.extend(dependencies)

        unload_dependencies = [str(dp) for dp in unload_dependencies] if unload_dependencies else []
        current_dependencies = [dependent for dependent in current_dependencies if
                                str(dependent) not in unload_dependencies]

        current_callbacks = self.callbacks.copy()
        if callbacks:
            current_callbacks.extend(callbacks)
        current_generate_unique_id = get_value_or_default(
            generate_unique_id_function, self.generate_unique_id_function
        )
        route = route_class(
            self.prefix + path,
            endpoint=endpoint,
            response_model=response_model,
            status_code=status_code,
            tags=current_tags,
            dependencies=current_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=combined_responses,
            deprecated=deprecated or self.deprecated,
            methods=methods,
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema and self.include_in_schema,
            response_class=current_response_class,
            name=name,
            dependency_overrides_provider=self.dependency_overrides_provider,
            callbacks=current_callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=current_generate_unique_id,
        )
        self.routes.append(route)

    def api_route(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[List[str]] = None,
            operation_id: Optional[str] = None,
            response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        def decorator(func: DecoratedCallable) -> DecoratedCallable:
            self.add_api_route(
                path,
                func,
                response_model=response_model,
                status_code=status_code,
                tags=tags,
                dependencies=dependencies,
                unload_dependencies=unload_dependencies,
                summary=summary,
                description=description,
                response_description=response_description,
                responses=responses,
                deprecated=deprecated,
                methods=methods,
                operation_id=operation_id,
                response_model_include=response_model_include,
                response_model_exclude=response_model_exclude,
                response_model_by_alias=response_model_by_alias,
                response_model_exclude_unset=response_model_exclude_unset,
                response_model_exclude_defaults=response_model_exclude_defaults,
                response_model_exclude_none=response_model_exclude_none,
                include_in_schema=include_in_schema,
                response_class=response_class,
                name=name,
                callbacks=callbacks,
                openapi_extra=openapi_extra,
                generate_unique_id_function=generate_unique_id_function,
            )
            return func

        return decorator

    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[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["GET"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )

    def put(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["PUT"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )

    def post(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["POST"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )

    def delete(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["DELETE"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )

    def options(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["OPTIONS"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )

    def head(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["HEAD"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )

    def patch(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:
        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["PATCH"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )

    def trace(
            self,
            path: str,
            *,
            response_model: Any = Default(None),
            status_code: Optional[int] = None,
            tags: Optional[List[Union[str, Enum]]] = None,
            dependencies: Optional[Sequence[params.Depends]] = None,
            unload_dependencies: Optional[Sequence[params.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[Union[SetIntStr, DictIntStrAny]] = None,
            response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = 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]:

        return self.api_route(
            path=path,
            response_model=response_model,
            status_code=status_code,
            tags=tags,
            dependencies=dependencies,
            unload_dependencies=unload_dependencies,
            summary=summary,
            description=description,
            response_description=response_description,
            responses=responses,
            deprecated=deprecated,
            methods=["TRACE"],
            operation_id=operation_id,
            response_model_include=response_model_include,
            response_model_exclude=response_model_exclude,
            response_model_by_alias=response_model_by_alias,
            response_model_exclude_unset=response_model_exclude_unset,
            response_model_exclude_defaults=response_model_exclude_defaults,
            response_model_exclude_none=response_model_exclude_none,
            include_in_schema=include_in_schema,
            response_class=response_class,
            name=name,
            callbacks=callbacks,
            openapi_extra=openapi_extra,
            generate_unique_id_function=generate_unique_id_function,
        )
使用方法在这里插入图片描述

main.py

from fastapi import Depends, FastAPI
from fastapi.security import OAuth2PasswordBearer

from applications import MyAPIRouter

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
app = FastAPI()
router = MyAPIRouter(dependencies=[Depends(oauth2_scheme)])


@router.get("/", unload_dependencies=[Depends(oauth2_scheme)])
async def root():
    return {"message": "Hello World"}


@router.get("/hello/{name}")
async def say_hello(name: str):
    return {"message": f"Hello {name}"}


@router.get("/hello1/{name}")
async def say_hello1(name: str):
    return {"message": f"Hello {name}"}


app.include_router(router)
效果

在这里插入图片描述

Demnok Lannik
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
react+fastapi前后端分离OAuth2权限验证的用户登陆案例
10-30
User-OAuth2-Login是react+fastapi前后端分离OAuth2权限验证的用户登陆案例.后端采用fastapi创建的OpenAPI接口,后端通过OAuth2的token来验证前端的登陆请求.前端采用React+Material UI布局,通过Axios访问接口获得数据和权限验证.
yii2 开发api接口时优雅的处理全局异常的方法
01-03
前言：个人觉得，学习或温习一套Web框架，在快速阅读一遍文档后，应从路由，控制器，请求/响应对象，数据模型（Logic，Dao，Entity），全局异常处理几个方面下手，这几项了解后，框架上手就游刃有余了。然后我比较喜欢在开工前整理好框架的全局异常处理，方便写 api时错误的统一响应。 在api接口的开发过程中，我们需要对用户数据进行严格的校验，防止非法输入对服务产生安全问题，在开发过程中，我比较喜欢即时的以抛出异常的方式中断请求的处理，并以全局异常处理器格式化处理后统一返回给客户端。 今天就把 yii2 自带的全局异常处理器改写至对 api 友好（yii2的 yii\web\HttpExce
FastAPI Web框架教程 第9章 登录认证相关
此博客内容主要是小可日常工作中的一些问题解决的记录整理而成
04-01 923
对于很多应用来说，注册接口是必可不少的。你会发现就一个简单的注册接口，其实还是有很多问题需要我们思考的。首先，注册接口一般是将用户的个人信息提交给服务端，因此，我们选择POST请求然后，注册信息中一般都包含密码，所以不能简单的在查询参数中提交给后端，需要把数据放在请求体中。最后，请求体如何使用JSON格式，那注册时如果有上传文件的需求，将比较麻烦。因此我们使用Form表单的形式。结论：对于常见的注册接口，使用POST，使用Form表单来上传数据。
vue设置全局访问接口API地址操作
10-14
主要介绍了vue设置全局访问接口API地址操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
fastapi_cache:简单缓存FastAPI
05-06
FastAPI缓存 将简单的轻量级缓存系统实现为FastAPI中的依赖项。 安装 pip install fastapi-cache 用法示例 from fastapi import Depends , FastAPI from fastapi_cache import caches , close_caches from fastapi_cache . backends . redis import CACHE_KEY , RedisCacheBackend app = FastAPI () def redis_cache (): return caches . get ( CACHE_KEY ) @ app . get ( '/' ) async def hello ( cache : RedisCacheBackend = Depends ( redis_cache
FastAPI 教程翻译 - 用户指南 25 - 依赖项
人生苦短，我用Python！
05-28 1782
FastAPI 教程翻译 - 用户指南 25 - 依赖项 FastAPI Tutorial - User Guide - Dependencies First Steps 第一步 FastAPI has a very powerful but intuitive Dependency Injection system. FastAPI 具有非常强大而且直观的依赖注入系统。 It is designed to be very simple to use, and to make it very easy fo
2.API文档（FastAPI）
chenhaiy的博客
01-08 4237
FastAPI文档形式：交互式API文档、备用API文档 2.1交互式API文档 在浏览器中请求 http://127.0.0.1:8000/docs ，显示交互式API文档， 自动交互式 API 文档（由 Swagger UI 提供） ，如图： 此时可以单击某个具体的API，然后单击Try it out，然后填写参数，并单击Execute按钮来执行。 2.2备用API文档 在浏览器中请求 http://127.0.0.1:8000/redoc ，显示备用API文档， 备用的自动交互.
【web】Fastapi自动生成接口文档（Swagger、ReDoc ）
larrino的博客
11-24 2568
FastAPI是流行的Python web框架，适用于开发高吞吐量API和微服务（直接支持异步编程）FastAPI的优势之一：通过提供高级抽象和自动数据模型转换，简化请求数据的处理（用户不需要手动处理原始请求数据），并能根据路由和 Pydantic 模型自动生成 OpenAPI 接口文档。
【Python开发】FastAPI 08：Security 登录认证
尹煜的博客
06-04 4057
FastAPI提供了多种工具，可帮助你以标准的方式轻松、快速地处理安全性，而无需研究和学习所有的安全规范，这相比花费大量的精力和代码处理安全性和身份认证很有好了（比如java😂）。
FastAPI 学习之路（二十）接口文档配置相关
mr~li的博客
08-29 1961
接口文档相关配置
fastapi登录认证机制
Mr_LiMing7758的博客
07-24 590
fastapi登录认证机制
dhcp(接口和全局地址池模式）
最新发布
05-15
dhcp(接口和全局地址池模式）
fastapi身份认证
fggdgh的博客
12-10 2587
fastapi OAuth2用户认证
Android Gradle依赖管理、去除重复依赖、忽略的方式
embbls的博客
05-26 3515
常用依赖 1 2 3 4 5 6 7 8 9 10 11 //1.直接依赖第三方开源库，一般是托管在 jitpack 或者 jcenter implementation 'com.google.code.gson:gson:2.2.4' implementation 'com.android.support:cardview-v7:25.0.0' implementatio
FastAPI从入门到实战（16）——依赖项
欢迎自九陌而来的你做客九陌斋！
12-26 485
依赖注入是耳熟能详的一个词了，听起来很复杂，实际上并没那么复杂，正常的访问需要接受各种参数来构造一个对象，依赖注入就变成了只接收一个实例化对象，主要用于共享业务逻辑、共享数据库连接、实现安全、验证、权限等相关的业务功能，本文主要记录一下fastapi的依赖注入。
14.(后端)登录装饰器(验证用户是否登录)
m0_63953077的博客
10-12 373
当有业务访问时，必须登陆过才可以访问，为了避免每次编写代码，我们可以写一个装饰来验证用户是否登录。
fastapi基本使用之：入参，返回值与异常处理
weixin_38175458的博客
07-29 3133
通过HelloOut这个模型，可以过滤掉原来的字段，比如原来返回一个user类，要把password过滤掉就特别有用，同样，这个模型里设定的字段默认都是必填的，这就确保接口需要有正确的返回。todo这里response_model如果校验错误，会返回500错误，如何拦截下来，并使用我们自定义的response的内容，待补充。一个接口的基本使用就是这样，相比传统的api开发，就是输入参数不用自己管了，效率高且不容易出错，就是这样。最后是响应模型，通过response_model参数来设定。...
为fastapi提供的接口，增加身份验证功能
sfakh的博客
04-17 884
添加身份验证后的接口能够防止非法用户写入内容，能够节省一定的磁盘空间：main文件内容： 数据库的文件内容如下： 结果展示 可以通过交互式文档获得相应的语句，并且去执行post操作，实现保存用户传入内容落盘。 可以看到该api后面有一个锁的标志，即说明该api进行了身份验证的安全性操作，点击锁的标志，进行身份验证(在身份验证之前需要先创建一个合法的用户，点击register的api创建合法用户)： 创建合法用户之后就可以登录，才能验证成功： 至此，用户已经成功登录，然后点击try it out获得其认证信
fastapi 统计某个接口的并发数
05-31
要统计某个 FastAPI 接口的并发数，可以使用 Python 的 `concurrent.futures` 模块，结合 FastAPI 的 `Depends` 和 `FastAPIMiddleware`。具体步骤如下： 1. 定义一个全局变量 `concurrent_count`，用于记录当前并发数。 2. 定义一个线程池 `executor`，用于执行异步任务。 3. 定义一个 `FastAPIMiddleware`，在每个请求进入和离开时更新 `concurrent_count`。 4. 在需要统计并发数的接口函数中，使用 `Depends` 装饰器加载一个依赖函数，该函数返回一个异步可调用对象，使用线程池 `executor` 执行该对象，同时在异步函数中更新 `concurrent_count`。 下面是一个示例代码： ```python from concurrent.futures import ThreadPoolExecutor from fastapi import FastAPI, Depends from fastapi.middleware.wsgi import WSGIMiddleware from fastapi.responses import PlainTextResponse app = FastAPI() executor = ThreadPoolExecutor(max_workers=10) concurrent_count = 0 async def count_concurrent(): global concurrent_count concurrent_count += 1 return concurrent_count async def update_concurrent(result): global concurrent_count concurrent_count -= 1 return result @app.middleware("http") async def count_middleware(request, call_next): await count_concurrent() response = await call_next(request) return await update_concurrent(response) @app.get("/test", response_class=PlainTextResponse) async def test(dep: int = Depends(count_concurrent)): async def heavy_task(): # do some heavy task pass await executor.submit(heavy_task) return f"Current concurrent count: {concurrent_count}" ``` 在上面的示例代码中，我们定义了一个 `/test` 接口，该接口使用了 `Depends` 装饰器加载了一个依赖函数 `count_concurrent`，在该函数中更新了 `concurrent_count`。同时，我们使用了一个线程池 `executor`，在异步函数 `heavy_task` 中执行了一些耗时的任务。 在 `count_middleware` 中，我们在每个请求进入和离开时更新了 `concurrent_count`。最终，接口函数返回了当前的并发数。 注意，这只是一个示例代码，实际使用时需要根据自己的需求进行修改和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值