You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1238 lines
52 KiB
1238 lines
52 KiB
2 years ago
|
import asyncio
|
||
|
|
import dataclasses
|
||
|
|
import email.message
|
||
|
|
import inspect
|
||
|
|
import json
|
||
|
|
from enum import Enum, IntEnum
|
||
|
|
from typing import (
|
||
|
|
Any,
|
||
|
|
Callable,
|
||
|
|
Coroutine,
|
||
|
|
Dict,
|
||
|
|
List,
|
||
|
|
Optional,
|
||
|
|
Sequence,
|
||
|
|
Set,
|
||
|
|
Tuple,
|
||
|
|
Type,
|
||
|
|
Union,
|
||
|
|
)
|
||
|
|
|
||
|
|
from fastapi import params
|
||
|
|
from fastapi.datastructures import Default, DefaultPlaceholder
|
||
|
|
from fastapi.dependencies.models import Dependant
|
||
|
|
from fastapi.dependencies.utils import (
|
||
|
|
get_body_field,
|
||
|
|
get_dependant,
|
||
|
|
get_parameterless_sub_dependant,
|
||
|
|
solve_dependencies,
|
||
|
|
)
|
||
|
|
from fastapi.encoders import DictIntStrAny, SetIntStr, jsonable_encoder
|
||
|
|
from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
|
||
|
|
from fastapi.types import DecoratedCallable
|
||
|
|
from fastapi.utils import (
|
||
|
|
create_cloned_field,
|
||
|
|
create_response_field,
|
||
|
|
generate_unique_id,
|
||
|
|
get_value_or_default,
|
||
|
|
is_body_allowed_for_status_code,
|
||
|
|
)
|
||
|
|
from pydantic import BaseModel
|
||
|
|
from pydantic.error_wrappers import ErrorWrapper, ValidationError
|
||
|
|
from pydantic.fields import ModelField, Undefined
|
||
|
|
from starlette import routing
|
||
|
|
from starlette.concurrency import run_in_threadpool
|
||
|
|
from starlette.exceptions import HTTPException
|
||
|
|
from starlette.requests import Request
|
||
|
|
from starlette.responses import JSONResponse, Response
|
||
|
|
from starlette.routing import BaseRoute, Match
|
||
|
|
from starlette.routing import Mount as Mount # noqa
|
||
|
|
from starlette.routing import (
|
||
|
|
compile_path,
|
||
|
|
get_name,
|
||
|
|
request_response,
|
||
|
|
websocket_session,
|
||
|
|
)
|
||
|
|
from starlette.status import WS_1008_POLICY_VIOLATION
|
||
|
|
from starlette.types import ASGIApp, Scope
|
||
|
|
from starlette.websockets import WebSocket
|
||
|
|
|
||
|
|
|
||
|
|
def _prepare_response_content(
|
||
|
|
res: Any,
|
||
|
|
*,
|
||
|
|
exclude_unset: bool,
|
||
|
|
exclude_defaults: bool = False,
|
||
|
|
exclude_none: bool = False,
|
||
|
|
) -> Any:
|
||
|
|
if isinstance(res, BaseModel):
|
||
|
|
read_with_orm_mode = getattr(res.__config__, "read_with_orm_mode", None)
|
||
|
|
if read_with_orm_mode:
|
||
|
|
# Let from_orm extract the data from this model instead of converting
|
||
|
|
# it now to a dict.
|
||
|
|
# Otherwise there's no way to extract lazy data that requires attribute
|
||
|
|
# access instead of dict iteration, e.g. lazy relationships.
|
||
|
|
return res
|
||
|
|
return res.dict(
|
||
|
|
by_alias=True,
|
||
|
|
exclude_unset=exclude_unset,
|
||
|
|
exclude_defaults=exclude_defaults,
|
||
|
|
exclude_none=exclude_none,
|
||
|
|
)
|
||
|
|
elif isinstance(res, list):
|
||
|
|
return [
|
||
|
|
_prepare_response_content(
|
||
|
|
item,
|
||
|
|
exclude_unset=exclude_unset,
|
||
|
|
exclude_defaults=exclude_defaults,
|
||
|
|
exclude_none=exclude_none,
|
||
|
|
)
|
||
|
|
for item in res
|
||
|
|
]
|
||
|
|
elif isinstance(res, dict):
|
||
|
|
return {
|
||
|
|
k: _prepare_response_content(
|
||
|
|
v,
|
||
|
|
exclude_unset=exclude_unset,
|
||
|
|
exclude_defaults=exclude_defaults,
|
||
|
|
exclude_none=exclude_none,
|
||
|
|
)
|
||
|
|
for k, v in res.items()
|
||
|
|
}
|
||
|
|
elif dataclasses.is_dataclass(res):
|
||
|
|
return dataclasses.asdict(res)
|
||
|
|
return res
|
||
|
|
|
||
|
|
|
||
|
|
async def serialize_response(
|
||
|
|
*,
|
||
|
|
field: Optional[ModelField] = None,
|
||
|
|
response_content: Any,
|
||
|
|
include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
|
||
|
|
exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
|
||
|
|
by_alias: bool = True,
|
||
|
|
exclude_unset: bool = False,
|
||
|
|
exclude_defaults: bool = False,
|
||
|
|
exclude_none: bool = False,
|
||
|
|
is_coroutine: bool = True,
|
||
|
|
) -> Any:
|
||
|
|
if field:
|
||
|
|
errors = []
|
||
|
|
response_content = _prepare_response_content(
|
||
|
|
response_content,
|
||
|
|
exclude_unset=exclude_unset,
|
||
|
|
exclude_defaults=exclude_defaults,
|
||
|
|
exclude_none=exclude_none,
|
||
|
|
)
|
||
|
|
if is_coroutine:
|
||
|
|
value, errors_ = field.validate(response_content, {}, loc=("response",))
|
||
|
|
else:
|
||
|
|
value, errors_ = await run_in_threadpool( # type: ignore[misc]
|
||
|
|
field.validate, response_content, {}, loc=("response",)
|
||
|
|
)
|
||
|
|
if isinstance(errors_, ErrorWrapper):
|
||
|
|
errors.append(errors_)
|
||
|
|
elif isinstance(errors_, list):
|
||
|
|
errors.extend(errors_)
|
||
|
|
if errors:
|
||
|
|
raise ValidationError(errors, field.type_)
|
||
|
|
return jsonable_encoder(
|
||
|
|
value,
|
||
|
|
include=include,
|
||
|
|
exclude=exclude,
|
||
|
|
by_alias=by_alias,
|
||
|
|
exclude_unset=exclude_unset,
|
||
|
|
exclude_defaults=exclude_defaults,
|
||
|
|
exclude_none=exclude_none,
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
return jsonable_encoder(response_content)
|
||
|
|
|
||
|
|
|
||
|
|
async def run_endpoint_function(
|
||
|
|
*, dependant: Dependant, values: Dict[str, Any], is_coroutine: bool
|
||
|
|
) -> Any:
|
||
|
|
# Only called by get_request_handler. Has been split into its own function to
|
||
|
|
# facilitate profiling endpoints, since inner functions are harder to profile.
|
||
|
|
assert dependant.call is not None, "dependant.call must be a function"
|
||
|
|
|
||
|
|
if is_coroutine:
|
||
|
|
return await dependant.call(**values)
|
||
|
|
else:
|
||
|
|
return await run_in_threadpool(dependant.call, **values)
|
||
|
|
|
||
|
|
|
||
|
|
def get_request_handler(
|
||
|
|
dependant: Dependant,
|
||
|
|
body_field: Optional[ModelField] = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
response_class: Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse),
|
||
|
|
response_field: Optional[ModelField] = 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,
|
||
|
|
dependency_overrides_provider: Optional[Any] = None,
|
||
|
|
) -> Callable[[Request], Coroutine[Any, Any, Response]]:
|
||
|
|
assert dependant.call is not None, "dependant.call must be a function"
|
||
|
|
is_coroutine = asyncio.iscoroutinefunction(dependant.call)
|
||
|
|
is_body_form = body_field and isinstance(body_field.field_info, params.Form)
|
||
|
|
if isinstance(response_class, DefaultPlaceholder):
|
||
|
|
actual_response_class: Type[Response] = response_class.value
|
||
|
|
else:
|
||
|
|
actual_response_class = response_class
|
||
|
|
|
||
|
|
async def app(request: Request) -> Response:
|
||
|
|
try:
|
||
|
|
body: Any = None
|
||
|
|
if body_field:
|
||
|
|
if is_body_form:
|
||
|
|
body = await request.form()
|
||
|
|
else:
|
||
|
|
body_bytes = await request.body()
|
||
|
|
if body_bytes:
|
||
|
|
json_body: Any = Undefined
|
||
|
|
content_type_value = request.headers.get("content-type")
|
||
|
|
if not content_type_value:
|
||
|
|
json_body = await request.json()
|
||
|
|
else:
|
||
|
|
message = email.message.Message()
|
||
|
|
message["content-type"] = content_type_value
|
||
|
|
if message.get_content_maintype() == "application":
|
||
|
|
subtype = message.get_content_subtype()
|
||
|
|
if subtype == "json" or subtype.endswith("+json"):
|
||
|
|
json_body = await request.json()
|
||
|
|
if json_body != Undefined:
|
||
|
|
body = json_body
|
||
|
|
else:
|
||
|
|
body = body_bytes
|
||
|
|
except json.JSONDecodeError as e:
|
||
|
|
raise RequestValidationError(
|
||
|
|
[ErrorWrapper(e, ("body", e.pos))], body=e.doc
|
||
|
|
) from e
|
||
|
|
except HTTPException:
|
||
|
|
raise
|
||
|
|
except Exception as e:
|
||
|
|
raise HTTPException(
|
||
|
|
status_code=400, detail="There was an error parsing the body"
|
||
|
|
) from e
|
||
|
|
solved_result = await solve_dependencies(
|
||
|
|
request=request,
|
||
|
|
dependant=dependant,
|
||
|
|
body=body,
|
||
|
|
dependency_overrides_provider=dependency_overrides_provider,
|
||
|
|
)
|
||
|
|
values, errors, background_tasks, sub_response, _ = solved_result
|
||
|
|
if errors:
|
||
|
|
raise RequestValidationError(errors, body=body)
|
||
|
|
else:
|
||
|
|
raw_response = await run_endpoint_function(
|
||
|
|
dependant=dependant, values=values, is_coroutine=is_coroutine
|
||
|
|
)
|
||
|
|
|
||
|
|
if isinstance(raw_response, Response):
|
||
|
|
if raw_response.background is None:
|
||
|
|
raw_response.background = background_tasks
|
||
|
|
return raw_response
|
||
|
|
response_args: Dict[str, Any] = {"background": background_tasks}
|
||
|
|
# If status_code was set, use it, otherwise use the default from the
|
||
|
|
# response class, in the case of redirect it's 307
|
||
|
|
current_status_code = (
|
||
|
|
status_code if status_code else sub_response.status_code
|
||
|
|
)
|
||
|
|
if current_status_code is not None:
|
||
|
|
response_args["status_code"] = current_status_code
|
||
|
|
if sub_response.status_code:
|
||
|
|
response_args["status_code"] = sub_response.status_code
|
||
|
|
content = await serialize_response(
|
||
|
|
field=response_field,
|
||
|
|
response_content=raw_response,
|
||
|
|
include=response_model_include,
|
||
|
|
exclude=response_model_exclude,
|
||
|
|
by_alias=response_model_by_alias,
|
||
|
|
exclude_unset=response_model_exclude_unset,
|
||
|
|
exclude_defaults=response_model_exclude_defaults,
|
||
|
|
exclude_none=response_model_exclude_none,
|
||
|
|
is_coroutine=is_coroutine,
|
||
|
|
)
|
||
|
|
response = actual_response_class(content, **response_args)
|
||
|
|
if not is_body_allowed_for_status_code(status_code):
|
||
|
|
response.body = b""
|
||
|
|
response.headers.raw.extend(sub_response.headers.raw)
|
||
|
|
return response
|
||
|
|
|
||
|
|
return app
|
||
|
|
|
||
|
|
|
||
|
|
def get_websocket_app(
|
||
|
|
dependant: Dependant, dependency_overrides_provider: Optional[Any] = None
|
||
|
|
) -> Callable[[WebSocket], Coroutine[Any, Any, Any]]:
|
||
|
|
async def app(websocket: WebSocket) -> None:
|
||
|
|
solved_result = await solve_dependencies(
|
||
|
|
request=websocket,
|
||
|
|
dependant=dependant,
|
||
|
|
dependency_overrides_provider=dependency_overrides_provider,
|
||
|
|
)
|
||
|
|
values, errors, _, _2, _3 = solved_result
|
||
|
|
if errors:
|
||
|
|
await websocket.close(code=WS_1008_POLICY_VIOLATION)
|
||
|
|
raise WebSocketRequestValidationError(errors)
|
||
|
|
assert dependant.call is not None, "dependant.call must be a function"
|
||
|
|
await dependant.call(**values)
|
||
|
|
|
||
|
|
return app
|
||
|
|
|
||
|
|
|
||
|
|
class APIWebSocketRoute(routing.WebSocketRoute):
|
||
|
|
def __init__(
|
||
|
|
self,
|
||
|
|
path: str,
|
||
|
|
endpoint: Callable[..., Any],
|
||
|
|
*,
|
||
|
|
name: Optional[str] = None,
|
||
|
|
dependency_overrides_provider: Optional[Any] = None,
|
||
|
|
) -> None:
|
||
|
|
self.path = path
|
||
|
|
self.endpoint = endpoint
|
||
|
|
self.name = get_name(endpoint) if name is None else name
|
||
|
|
self.dependant = get_dependant(path=path, call=self.endpoint)
|
||
|
|
self.app = websocket_session(
|
||
|
|
get_websocket_app(
|
||
|
|
dependant=self.dependant,
|
||
|
|
dependency_overrides_provider=dependency_overrides_provider,
|
||
|
|
)
|
||
|
|
)
|
||
|
|
self.path_regex, self.path_format, self.param_convertors = compile_path(path)
|
||
|
|
|
||
|
|
def matches(self, scope: Scope) -> Tuple[Match, Scope]:
|
||
|
|
match, child_scope = super().matches(scope)
|
||
|
|
if match != Match.NONE:
|
||
|
|
child_scope["route"] = self
|
||
|
|
return match, child_scope
|
||
|
|
|
||
|
|
|
||
|
|
class APIRoute(routing.Route):
|
||
|
|
def __init__(
|
||
|
|
self,
|
||
|
|
path: str,
|
||
|
|
endpoint: Callable[..., Any],
|
||
|
|
*,
|
||
|
|
response_model: Any = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
name: Optional[str] = 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
|
||
|
|
),
|
||
|
|
dependency_overrides_provider: Optional[Any] = 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:
|
||
|
|
self.path = path
|
||
|
|
self.endpoint = endpoint
|
||
|
|
self.response_model = response_model
|
||
|
|
self.summary = summary
|
||
|
|
self.response_description = response_description
|
||
|
|
self.deprecated = deprecated
|
||
|
|
self.operation_id = operation_id
|
||
|
|
self.response_model_include = response_model_include
|
||
|
|
self.response_model_exclude = response_model_exclude
|
||
|
|
self.response_model_by_alias = response_model_by_alias
|
||
|
|
self.response_model_exclude_unset = response_model_exclude_unset
|
||
|
|
self.response_model_exclude_defaults = response_model_exclude_defaults
|
||
|
|
self.response_model_exclude_none = response_model_exclude_none
|
||
|
|
self.include_in_schema = include_in_schema
|
||
|
|
self.response_class = response_class
|
||
|
|
self.dependency_overrides_provider = dependency_overrides_provider
|
||
|
|
self.callbacks = callbacks
|
||
|
|
self.openapi_extra = openapi_extra
|
||
|
|
self.generate_unique_id_function = generate_unique_id_function
|
||
|
|
self.tags = tags or []
|
||
|
|
self.responses = responses or {}
|
||
|
|
self.name = get_name(endpoint) if name is None else name
|
||
|
|
self.path_regex, self.path_format, self.param_convertors = compile_path(path)
|
||
|
|
if methods is None:
|
||
|
|
methods = ["GET"]
|
||
|
|
self.methods: Set[str] = {method.upper() for method in methods}
|
||
|
|
if isinstance(generate_unique_id_function, DefaultPlaceholder):
|
||
|
|
current_generate_unique_id: Callable[
|
||
|
|
["APIRoute"], str
|
||
|
|
] = generate_unique_id_function.value
|
||
|
|
else:
|
||
|
|
current_generate_unique_id = generate_unique_id_function
|
||
|
|
self.unique_id = self.operation_id or current_generate_unique_id(self)
|
||
|
|
# normalize enums e.g. http.HTTPStatus
|
||
|
|
if isinstance(status_code, IntEnum):
|
||
|
|
status_code = int(status_code)
|
||
|
|
self.status_code = status_code
|
||
|
|
if self.response_model:
|
||
|
|
assert is_body_allowed_for_status_code(
|
||
|
|
status_code
|
||
|
|
), f"Status code {status_code} must not have a response body"
|
||
|
|
response_name = "Response_" + self.unique_id
|
||
|
|
self.response_field = create_response_field(
|
||
|
|
name=response_name, type_=self.response_model
|
||
|
|
)
|
||
|
|
# Create a clone of the field, so that a Pydantic submodel is not returned
|
||
|
|
# as is just because it's an instance of a subclass of a more limited class
|
||
|
|
# e.g. UserInDB (containing hashed_password) could be a subclass of User
|
||
|
|
# that doesn't have the hashed_password. But because it's a subclass, it
|
||
|
|
# would pass the validation and be returned as is.
|
||
|
|
# By being a new field, no inheritance will be passed as is. A new model
|
||
|
|
# will be always created.
|
||
|
|
self.secure_cloned_response_field: Optional[
|
||
|
|
ModelField
|
||
|
|
] = create_cloned_field(self.response_field)
|
||
|
|
else:
|
||
|
|
self.response_field = None # type: ignore
|
||
|
|
self.secure_cloned_response_field = None
|
||
|
|
if dependencies:
|
||
|
|
self.dependencies = list(dependencies)
|
||
|
|
else:
|
||
|
|
self.dependencies = []
|
||
|
|
self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
|
||
|
|
# if a "form feed" character (page break) is found in the description text,
|
||
|
|
# truncate description text to the content preceding the first "form feed"
|
||
|
|
self.description = self.description.split("\f")[0].strip()
|
||
|
|
response_fields = {}
|
||
|
|
for additional_status_code, response in self.responses.items():
|
||
|
|
assert isinstance(response, dict), "An additional response must be a dict"
|
||
|
|
model = response.get("model")
|
||
|
|
if model:
|
||
|
|
assert is_body_allowed_for_status_code(
|
||
|
|
additional_status_code
|
||
|
|
), f"Status code {additional_status_code} must not have a response body"
|
||
|
|
response_name = f"Response_{additional_status_code}_{self.unique_id}"
|
||
|
|
response_field = create_response_field(name=response_name, type_=model)
|
||
|
|
response_fields[additional_status_code] = response_field
|
||
|
|
if response_fields:
|
||
|
|
self.response_fields: Dict[Union[int, str], ModelField] = response_fields
|
||
|
|
else:
|
||
|
|
self.response_fields = {}
|
||
|
|
|
||
|
|
assert callable(endpoint), "An endpoint must be a callable"
|
||
|
|
self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
|
||
|
|
for depends in self.dependencies[::-1]:
|
||
|
|
self.dependant.dependencies.insert(
|
||
|
|
0,
|
||
|
|
get_parameterless_sub_dependant(depends=depends, path=self.path_format),
|
||
|
|
)
|
||
|
|
self.body_field = get_body_field(dependant=self.dependant, name=self.unique_id)
|
||
|
|
self.app = request_response(self.get_route_handler())
|
||
|
|
|
||
|
|
def get_route_handler(self) -> Callable[[Request], Coroutine[Any, Any, Response]]:
|
||
|
|
return get_request_handler(
|
||
|
|
dependant=self.dependant,
|
||
|
|
body_field=self.body_field,
|
||
|
|
status_code=self.status_code,
|
||
|
|
response_class=self.response_class,
|
||
|
|
response_field=self.secure_cloned_response_field,
|
||
|
|
response_model_include=self.response_model_include,
|
||
|
|
response_model_exclude=self.response_model_exclude,
|
||
|
|
response_model_by_alias=self.response_model_by_alias,
|
||
|
|
response_model_exclude_unset=self.response_model_exclude_unset,
|
||
|
|
response_model_exclude_defaults=self.response_model_exclude_defaults,
|
||
|
|
response_model_exclude_none=self.response_model_exclude_none,
|
||
|
|
dependency_overrides_provider=self.dependency_overrides_provider,
|
||
|
|
)
|
||
|
|
|
||
|
|
def matches(self, scope: Scope) -> Tuple[Match, Scope]:
|
||
|
|
match, child_scope = super().matches(scope)
|
||
|
|
if match != Match.NONE:
|
||
|
|
child_scope["route"] = self
|
||
|
|
return match, child_scope
|
||
|
|
|
||
|
|
|
||
|
|
class APIRouter(routing.Router):
|
||
|
|
def __init__(
|
||
|
|
self,
|
||
|
|
*,
|
||
|
|
prefix: str = "",
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
dependencies: Optional[Sequence[params.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[routing.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[[], Any]]] = None,
|
||
|
|
on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
|
||
|
|
deprecated: Optional[bool] = None,
|
||
|
|
include_in_schema: bool = True,
|
||
|
|
generate_unique_id_function: Callable[[APIRoute], str] = Default(
|
||
|
|
generate_unique_id
|
||
|
|
),
|
||
|
|
) -> None:
|
||
|
|
super().__init__(
|
||
|
|
routes=routes,
|
||
|
|
redirect_slashes=redirect_slashes,
|
||
|
|
default=default,
|
||
|
|
on_startup=on_startup,
|
||
|
|
on_shutdown=on_shutdown,
|
||
|
|
)
|
||
|
|
if prefix:
|
||
|
|
assert prefix.startswith("/"), "A path prefix must start with '/'"
|
||
|
|
assert not prefix.endswith(
|
||
|
|
"/"
|
||
|
|
), "A path prefix must not end with '/', as the routes will start with '/'"
|
||
|
|
self.prefix = prefix
|
||
|
|
self.tags: List[Union[str, Enum]] = tags or []
|
||
|
|
self.dependencies = list(dependencies or []) or []
|
||
|
|
self.deprecated = deprecated
|
||
|
|
self.include_in_schema = include_in_schema
|
||
|
|
self.responses = responses or {}
|
||
|
|
self.callbacks = callbacks or []
|
||
|
|
self.dependency_overrides_provider = dependency_overrides_provider
|
||
|
|
self.route_class = route_class
|
||
|
|
self.default_response_class = default_response_class
|
||
|
|
self.generate_unique_id_function = generate_unique_id_function
|
||
|
|
|
||
|
|
def add_api_route(
|
||
|
|
self,
|
||
|
|
path: str,
|
||
|
|
endpoint: Callable[..., Any],
|
||
|
|
*,
|
||
|
|
response_model: Any = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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)
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 add_api_websocket_route(
|
||
|
|
self, path: str, endpoint: Callable[..., Any], name: Optional[str] = None
|
||
|
|
) -> None:
|
||
|
|
route = APIWebSocketRoute(
|
||
|
|
self.prefix + path,
|
||
|
|
endpoint=endpoint,
|
||
|
|
name=name,
|
||
|
|
dependency_overrides_provider=self.dependency_overrides_provider,
|
||
|
|
)
|
||
|
|
self.routes.append(route)
|
||
|
|
|
||
|
|
def websocket(
|
||
|
|
self, path: str, name: Optional[str] = None
|
||
|
|
) -> Callable[[DecoratedCallable], DecoratedCallable]:
|
||
|
|
def decorator(func: DecoratedCallable) -> DecoratedCallable:
|
||
|
|
self.add_api_websocket_route(path, func, name=name)
|
||
|
|
return func
|
||
|
|
|
||
|
|
return decorator
|
||
|
|
|
||
|
|
def include_router(
|
||
|
|
self,
|
||
|
|
router: "APIRouter",
|
||
|
|
*,
|
||
|
|
prefix: str = "",
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
dependencies: Optional[Sequence[params.Depends]] = None,
|
||
|
|
default_response_class: Type[Response] = Default(JSONResponse),
|
||
|
|
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
|
||
|
|
callbacks: Optional[List[BaseRoute]] = None,
|
||
|
|
deprecated: Optional[bool] = None,
|
||
|
|
include_in_schema: bool = True,
|
||
|
|
generate_unique_id_function: Callable[[APIRoute], str] = Default(
|
||
|
|
generate_unique_id
|
||
|
|
),
|
||
|
|
) -> None:
|
||
|
|
if prefix:
|
||
|
|
assert prefix.startswith("/"), "A path prefix must start with '/'"
|
||
|
|
assert not prefix.endswith(
|
||
|
|
"/"
|
||
|
|
), "A path prefix must not end with '/', as the routes will start with '/'"
|
||
|
|
else:
|
||
|
|
for r in router.routes:
|
||
|
|
path = getattr(r, "path")
|
||
|
|
name = getattr(r, "name", "unknown")
|
||
|
|
if path is not None and not path:
|
||
|
|
raise Exception(
|
||
|
|
f"Prefix and path cannot be both empty (path operation: {name})"
|
||
|
|
)
|
||
|
|
if responses is None:
|
||
|
|
responses = {}
|
||
|
|
for route in router.routes:
|
||
|
|
if isinstance(route, APIRoute):
|
||
|
|
combined_responses = {**responses, **route.responses}
|
||
|
|
use_response_class = get_value_or_default(
|
||
|
|
route.response_class,
|
||
|
|
router.default_response_class,
|
||
|
|
default_response_class,
|
||
|
|
self.default_response_class,
|
||
|
|
)
|
||
|
|
current_tags = []
|
||
|
|
if tags:
|
||
|
|
current_tags.extend(tags)
|
||
|
|
if route.tags:
|
||
|
|
current_tags.extend(route.tags)
|
||
|
|
current_dependencies: List[params.Depends] = []
|
||
|
|
if dependencies:
|
||
|
|
current_dependencies.extend(dependencies)
|
||
|
|
if route.dependencies:
|
||
|
|
current_dependencies.extend(route.dependencies)
|
||
|
|
current_callbacks = []
|
||
|
|
if callbacks:
|
||
|
|
current_callbacks.extend(callbacks)
|
||
|
|
if route.callbacks:
|
||
|
|
current_callbacks.extend(route.callbacks)
|
||
|
|
current_generate_unique_id = get_value_or_default(
|
||
|
|
route.generate_unique_id_function,
|
||
|
|
router.generate_unique_id_function,
|
||
|
|
generate_unique_id_function,
|
||
|
|
self.generate_unique_id_function,
|
||
|
|
)
|
||
|
|
self.add_api_route(
|
||
|
|
prefix + route.path,
|
||
|
|
route.endpoint,
|
||
|
|
response_model=route.response_model,
|
||
|
|
status_code=route.status_code,
|
||
|
|
tags=current_tags,
|
||
|
|
dependencies=current_dependencies,
|
||
|
|
summary=route.summary,
|
||
|
|
description=route.description,
|
||
|
|
response_description=route.response_description,
|
||
|
|
responses=combined_responses,
|
||
|
|
deprecated=route.deprecated or deprecated or self.deprecated,
|
||
|
|
methods=route.methods,
|
||
|
|
operation_id=route.operation_id,
|
||
|
|
response_model_include=route.response_model_include,
|
||
|
|
response_model_exclude=route.response_model_exclude,
|
||
|
|
response_model_by_alias=route.response_model_by_alias,
|
||
|
|
response_model_exclude_unset=route.response_model_exclude_unset,
|
||
|
|
response_model_exclude_defaults=route.response_model_exclude_defaults,
|
||
|
|
response_model_exclude_none=route.response_model_exclude_none,
|
||
|
|
include_in_schema=route.include_in_schema
|
||
|
|
and self.include_in_schema
|
||
|
|
and include_in_schema,
|
||
|
|
response_class=use_response_class,
|
||
|
|
name=route.name,
|
||
|
|
route_class_override=type(route),
|
||
|
|
callbacks=current_callbacks,
|
||
|
|
openapi_extra=route.openapi_extra,
|
||
|
|
generate_unique_id_function=current_generate_unique_id,
|
||
|
|
)
|
||
|
|
elif isinstance(route, routing.Route):
|
||
|
|
methods = list(route.methods or [])
|
||
|
|
self.add_route(
|
||
|
|
prefix + route.path,
|
||
|
|
route.endpoint,
|
||
|
|
methods=methods,
|
||
|
|
include_in_schema=route.include_in_schema,
|
||
|
|
name=route.name,
|
||
|
|
)
|
||
|
|
elif isinstance(route, APIWebSocketRoute):
|
||
|
|
self.add_api_websocket_route(
|
||
|
|
prefix + route.path, route.endpoint, name=route.name
|
||
|
|
)
|
||
|
|
elif isinstance(route, routing.WebSocketRoute):
|
||
|
|
self.add_websocket_route(
|
||
|
|
prefix + route.path, route.endpoint, name=route.name
|
||
|
|
)
|
||
|
|
for handler in router.on_startup:
|
||
|
|
self.add_event_handler("startup", handler)
|
||
|
|
for handler in router.on_shutdown:
|
||
|
|
self.add_event_handler("shutdown", handler)
|
||
|
|
|
||
|
|
def get(
|
||
|
|
self,
|
||
|
|
path: str,
|
||
|
|
*,
|
||
|
|
response_model: Any = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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 = None,
|
||
|
|
status_code: Optional[int] = None,
|
||
|
|
tags: Optional[List[Union[str, Enum]]] = None,
|
||
|
|
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,
|
||
|
|
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,
|
||
|
|
)
|