61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995

def__init__(self:AppType,*,debug:Annotated[bool,Doc("""            Boolean indicating if debug tracebacks should be returned on server            errors.            Read more in the            [Starlette docs for Applications](https://www.starlette.dev/applications/#instantiating-the-application).            """),]=False,routes:Annotated[list[BaseRoute]|None,Doc("""            **Note**: you probably shouldn't use this parameter, it is inherited            from Starlette and supported for compatibility.            ---            A list of routes to serve incoming HTTP and WebSocket requests.            """),deprecated("""            You normally wouldn't use this parameter with FastAPI, it is inherited            from Starlette and supported for compatibility.            In FastAPI, you normally would use the *path operation methods*,            like `app.get()`, `app.post()`, etc.            """),]=None,title:Annotated[str,Doc("""            The title of the API.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-api).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(title="ChimichangApp")            ```            """),]="FastAPI",summary:Annotated[str|None,Doc("""            A short summary of the API.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-api).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(summary="Deadpond's favorite app. Nuff said.")            ```            """),]=None,description:Annotated[str,Doc('''            A description of the API. Supports Markdown (using            [CommonMark syntax](https://commonmark.org/)).            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-api).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(                description="""                            ChimichangApp API helps you do awesome stuff. 🚀                            ## Items                            You can **read items**.                            ## Users                            You will be able to:                            * **Create users** (_not implemented_).                            * **Read users** (_not implemented_).                            """            )            ```            '''),]="",version:Annotated[str,Doc("""            The version of the API.            **Note** This is the version of your application, not the version of            the OpenAPI specification nor the version of FastAPI being used.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-api).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(version="0.0.1")            ```            """),]="0.1.0",openapi_url:Annotated[str|None,Doc("""            The URL where the OpenAPI schema will be served from.            If you set it to `None`, no OpenAPI schema will be served publicly, and            the default automatic endpoints `/docs` and `/redoc` will also be            disabled.            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#openapi-url).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(openapi_url="/api/v1/openapi.json")            ```            """),]="/openapi.json",openapi_tags:Annotated[list[dict[str,Any]]|None,Doc("""            A list of tags used by OpenAPI, these are the same `tags` you can set            in the *path operations*, like:            * `@app.get("/users/", tags=["users"])`            * `@app.get("/items/", tags=["items"])`            The order of the tags can be used to specify the order shown in            tools like Swagger UI, used in the automatic path `/docs`.            It's not required to specify all the tags used.            The tags that are not declared MAY be organized randomly or based            on the tools' logic. Each tag name in the list MUST be unique.            The value of each item is a `dict` containing:            * `name`: The name of the tag.            * `description`: A short description of the tag.                [CommonMark syntax](https://commonmark.org/) MAY be used for rich                text representation.            * `externalDocs`: Additional external documentation for this tag. If                provided, it would contain a `dict` with:                * `description`: A short description of the target documentation.                    [CommonMark syntax](https://commonmark.org/) MAY be used for                    rich text representation.                * `url`: The URL for the target documentation. Value MUST be in                    the form of a URL.            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-tags).            **Example**            ```python            from fastapi import FastAPI            tags_metadata = [                {                    "name": "users",                    "description": "Operations with users. The **login** logic is also here.",                },                {                    "name": "items",                    "description": "Manage items. So _fancy_ they have their own docs.",                    "externalDocs": {                        "description": "Items external docs",                        "url": "https://fastapi.tiangolo.com/",                    },                },            ]            app = FastAPI(openapi_tags=tags_metadata)            ```            """),]=None,servers:Annotated[list[dict[str,str|Any]]|None,Doc("""            A `list` of `dict`s with connectivity information to a target server.            You would use it, for example, if your application is served from            different domains and you want to use the same Swagger UI in the            browser to interact with each of them (instead of having multiple            browser tabs open). Or if you want to leave fixed the possible URLs.            If the servers `list` is not provided, or is an empty `list`, the            `servers` property in the generated OpenAPI will be:            * a `dict` with a `url` value of the application's mounting point            (`root_path`) if it's different from `/`.            * otherwise, the `servers` property will be omitted from the OpenAPI            schema.            Each item in the `list` is a `dict` containing:            * `url`: A URL to the target host. This URL supports Server Variables            and MAY be relative, to indicate that the host location is relative            to the location where the OpenAPI document is being served. Variable            substitutions will be made when a variable is named in `{`brackets`}`.            * `description`: An optional string describing the host designated by            the URL. [CommonMark syntax](https://commonmark.org/) MAY be used for            rich text representation.            * `variables`: A `dict` between a variable name and its value. The value                is used for substitution in the server's URL template.            Read more in the            [FastAPI docs for Behind a Proxy](https://fastapi.tiangolo.com/advanced/behind-a-proxy/#additional-servers).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(                servers=[                    {"url": "https://stag.example.com", "description": "Staging environment"},                    {"url": "https://prod.example.com", "description": "Production environment"},                ]            )            ```            """),]=None,dependencies:Annotated[Sequence[Depends]|None,Doc("""            A list of global dependencies, they will be applied to each            *path operation*, including in sub-routers.            Read more about it in the            [FastAPI docs for Global Dependencies](https://fastapi.tiangolo.com/tutorial/dependencies/global-dependencies/).            **Example**            ```python            from fastapi import Depends, FastAPI            from .dependencies import func_dep_1, func_dep_2            app = FastAPI(dependencies=[Depends(func_dep_1), Depends(func_dep_2)])            ```            """),]=None,default_response_class:Annotated[type[Response],Doc("""            The default response class to be used.            Read more in the            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.tiangolo.com/advanced/custom-response/#default-response-class).            **Example**            ```python            from fastapi import FastAPI            from fastapi.responses import ORJSONResponse            app = FastAPI(default_response_class=ORJSONResponse)            ```            """),]=Default(JSONResponse),redirect_slashes:Annotated[bool,Doc("""            Whether to detect and redirect slashes in URLs when the client doesn't            use the same format.            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(redirect_slashes=True)  # the default            @app.get("/items/")            async def read_items():                return [{"item_id": "Foo"}]            ```            With this app, if a client goes to `/items` (without a trailing slash),            they will be automatically redirected with an HTTP status code of 307            to `/items/`.            """),]=True,docs_url:Annotated[str|None,Doc("""            The path to the automatic interactive API documentation.            It is handled in the browser by Swagger UI.            The default URL is `/docs`. You can disable it by setting it to `None`.            If `openapi_url` is set to `None`, this will be automatically disabled.            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#docs-urls).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(docs_url="/documentation", redoc_url=None)            ```            """),]="/docs",redoc_url:Annotated[str|None,Doc("""            The path to the alternative automatic interactive API documentation            provided by ReDoc.            The default URL is `/redoc`. You can disable it by setting it to `None`.            If `openapi_url` is set to `None`, this will be automatically disabled.            Read more in the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#docs-urls).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(docs_url="/documentation", redoc_url="redocumentation")            ```            """),]="/redoc",swagger_ui_oauth2_redirect_url:Annotated[str|None,Doc("""            The OAuth2 redirect endpoint for the Swagger UI.            By default it is `/docs/oauth2-redirect`.            This is only used if you use OAuth2 (with the "Authorize" button)            with Swagger UI.            """),]="/docs/oauth2-redirect",swagger_ui_init_oauth:Annotated[dict[str,Any]|None,Doc("""            OAuth2 configuration for the Swagger UI, by default shown at `/docs`.            Read more about the available configuration options in the            [Swagger UI docs](https://swagger.io/docs/open-source-tools/swagger-ui/usage/oauth2/).            """),]=None,middleware:Annotated[Sequence[Middleware]|None,Doc("""            List of middleware to be added when creating the application.            In FastAPI you would normally do this with `app.add_middleware()`            instead.            Read more in the            [FastAPI docs for Middleware](https://fastapi.tiangolo.com/tutorial/middleware/).            """),]=None,exception_handlers:Annotated[dict[int|type[Exception],Callable[[Request,Any],Coroutine[Any,Any,Response]],]|None,Doc("""            A dictionary with handlers for exceptions.            In FastAPI, you would normally use the decorator            `@app.exception_handler()`.            Read more in the            [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/).            """),]=None,on_startup:Annotated[Sequence[Callable[[],Any]]|None,Doc("""            A list of startup event handler functions.            You should instead use the `lifespan` handlers.            Read more in the [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).            """),]=None,on_shutdown:Annotated[Sequence[Callable[[],Any]]|None,Doc("""            A list of shutdown event handler functions.            You should instead use the `lifespan` handlers.            Read more in the            [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).            """),]=None,lifespan:Annotated[Lifespan[AppType]|None,Doc("""            A `Lifespan` context manager handler. This replaces `startup` and            `shutdown` functions with a single context manager.            Read more in the            [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).            """),]=None,terms_of_service:Annotated[str|None,Doc("""            A URL to the Terms of Service for your API.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more at the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-api).            **Example**            ```python            app = FastAPI(terms_of_service="http://example.com/terms/")            ```            """),]=None,contact:Annotated[dict[str,str|Any]|None,Doc("""            A dictionary with the contact information for the exposed API.            It can contain several fields.            * `name`: (`str`) The name of the contact person/organization.            * `url`: (`str`) A URL pointing to the contact information. MUST be in                the format of a URL.            * `email`: (`str`) The email address of the contact person/organization.                MUST be in the format of an email address.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more at the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-api).            **Example**            ```python            app = FastAPI(                contact={                    "name": "Deadpoolio the Amazing",                    "url": "http://x-force.example.com/contact/",                    "email": "dp@x-force.example.com",                }            )            ```            """),]=None,license_info:Annotated[dict[str,str|Any]|None,Doc("""            A dictionary with the license information for the exposed API.            It can contain several fields.            * `name`: (`str`) **REQUIRED** (if a `license_info` is set). The                license name used for the API.            * `identifier`: (`str`) An [SPDX](https://spdx.dev/) license expression                for the API. The `identifier` field is mutually exclusive of the `url`                field. Available since OpenAPI 3.1.0, FastAPI 0.99.0.            * `url`: (`str`) A URL to the license used for the API. This MUST be                the format of a URL.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more at the            [FastAPI docs for Metadata and Docs URLs](https://fastapi.tiangolo.com/tutorial/metadata/#metadata-for-api).            **Example**            ```python            app = FastAPI(                license_info={                    "name": "Apache 2.0",                    "url": "https://www.apache.org/licenses/LICENSE-2.0.html",                }            )            ```            """),]=None,openapi_prefix:Annotated[str,Doc("""            A URL prefix for the OpenAPI URL.            """),deprecated("""            "openapi_prefix" has been deprecated in favor of "root_path", which            follows more closely the ASGI standard, is simpler, and more            automatic.            """),]="",root_path:Annotated[str,Doc("""            A path prefix handled by a proxy that is not seen by the application            but is seen by external clients, which affects things like Swagger UI.            Read more about it at the            [FastAPI docs for Behind a Proxy](https://fastapi.tiangolo.com/advanced/behind-a-proxy/).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(root_path="/api/v1")            ```            """),]="",root_path_in_servers:Annotated[bool,Doc("""            To disable automatically generating the URLs in the `servers` field            in the autogenerated OpenAPI using the `root_path`.            Read more about it in the            [FastAPI docs for Behind a Proxy](https://fastapi.tiangolo.com/advanced/behind-a-proxy/#disable-automatic-server-from-root-path).            **Example**            ```python            from fastapi import FastAPI            app = FastAPI(root_path_in_servers=False)            ```            """),]=True,responses:Annotated[dict[int|str,dict[str,Any]]|None,Doc("""            Additional responses to be shown in OpenAPI.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more about it in the            [FastAPI docs for Additional Responses in OpenAPI](https://fastapi.tiangolo.com/advanced/additional-responses/).            And in the            [FastAPI docs for Bigger Applications](https://fastapi.tiangolo.com/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).            """),]=None,callbacks:Annotated[list[BaseRoute]|None,Doc("""            OpenAPI callbacks that should apply to all *path operations*.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more about it in the            [FastAPI docs for OpenAPI Callbacks](https://fastapi.tiangolo.com/advanced/openapi-callbacks/).            """),]=None,webhooks:Annotated[routing.APIRouter|None,Doc("""            Add OpenAPI webhooks. This is similar to `callbacks` but it doesn't            depend on specific *path operations*.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            **Note**: This is available since OpenAPI 3.1.0, FastAPI 0.99.0.            Read more about it in the            [FastAPI docs for OpenAPI Webhooks](https://fastapi.tiangolo.com/advanced/openapi-webhooks/).            """),]=None,deprecated:Annotated[bool|None,Doc("""            Mark all *path operations* as deprecated. You probably don't need it,            but it's available.            It will be added to the generated OpenAPI (e.g. visible at `/docs`).            Read more about it in the            [FastAPI docs for Path Operation Configuration](https://fastapi.tiangolo.com/tutorial/path-operation-configuration/#deprecate-a-path-operation).            """),]=None,include_in_schema:Annotated[bool,Doc("""            To include (or not) all the *path operations* in the generated OpenAPI.            You probably don't need it, but it's available.            This affects the generated OpenAPI (e.g. visible at `/docs`).            Read more about it in the            [FastAPI docs for Query Parameters and String Validations](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#exclude-parameters-from-openapi).            """),]=True,swagger_ui_parameters:Annotated[dict[str,Any]|None,Doc("""            Parameters to configure Swagger UI, the autogenerated interactive API            documentation (by default at `/docs`).            Read more about it in the            [FastAPI docs about how to Configure Swagger UI](https://fastapi.tiangolo.com/how-to/configure-swagger-ui/).            """),]=None,generate_unique_id_function:Annotated[Callable[[routing.APIRoute],str],Doc("""            Customize the function used to generate unique IDs for the *path            operations* shown in the generated OpenAPI.            This is particularly useful when automatically generating clients or            SDKs for your API.            Read more about it in the            [FastAPI docs about how to Generate Clients](https://fastapi.tiangolo.com/advanced/generate-clients/#custom-generate-unique-id-function).            """),]=Default(generate_unique_id),separate_input_output_schemas:Annotated[bool,Doc("""            Whether to generate separate OpenAPI schemas for request body and            response body when the results would be more precise.            This is particularly useful when automatically generating clients.            For example, if you have a model like:            ```python            from pydantic import BaseModel            class Item(BaseModel):                name: str                tags: list[str] = []            ```            When `Item` is used for input, a request body, `tags` is not required,            the client doesn't have to provide it.            But when using `Item` for output, for a response body, `tags` is always            available because it has a default value, even if it's just an empty            list. So, the client should be able to always expect it.            In this case, there would be two different schemas, one for input and            another one for output.            Read more about it in the            [FastAPI docs about how to separate schemas for input and output](https://fastapi.tiangolo.com/how-to/separate-openapi-schemas)            """),]=True,openapi_external_docs:Annotated[dict[str,Any]|None,Doc("""            This field allows you to provide additional external documentation links.            If provided, it must be a dictionary containing:            * `description`: A brief description of the external documentation.            * `url`: The URL pointing to the external documentation. The value **MUST**            be a valid URL format.            **Example**:            ```python            from fastapi import FastAPI            external_docs = {                "description": "Detailed API Reference",                "url": "https://example.com/api-docs",            }            app = FastAPI(openapi_external_docs=external_docs)            ```            """),]=None,**extra:Annotated[Any,Doc("""            Extra keyword arguments to be stored in the app, not used by FastAPI            anywhere.            """),],)->None:self.debug=debugself.title=titleself.summary=summaryself.description=descriptionself.version=versionself.terms_of_service=terms_of_serviceself.contact=contactself.license_info=license_infoself.openapi_url=openapi_urlself.openapi_tags=openapi_tagsself.root_path_in_servers=root_path_in_serversself.docs_url=docs_urlself.redoc_url=redoc_urlself.swagger_ui_oauth2_redirect_url=swagger_ui_oauth2_redirect_urlself.swagger_ui_init_oauth=swagger_ui_init_oauthself.swagger_ui_parameters=swagger_ui_parametersself.servers=serversor[]self.separate_input_output_schemas=separate_input_output_schemasself.openapi_external_docs=openapi_external_docsself.extra=extraself.openapi_version:Annotated[str,Doc("""            The version string of OpenAPI.            FastAPI will generate OpenAPI version 3.1.0, and will output that as            the OpenAPI version. But some tools, even though they might be            compatible with OpenAPI 3.1.0, might not recognize it as a valid.            So you could override this value to trick those tools into using            the generated OpenAPI. Have in mind that this is a hack. But if you            avoid using features added in OpenAPI 3.1.0, it might work for your            use case.            This is not passed as a parameter to the `FastAPI` class to avoid            giving the false idea that FastAPI would generate a different OpenAPI            schema. It is only available as an attribute.            **Example**            ```python            from fastapi import FastAPI            app = FastAPI()            app.openapi_version = "3.0.2"            ```            """),]="3.1.0"self.openapi_schema:dict[str,Any]|None=Noneifself.openapi_url:assertself.title,"A title must be provided for OpenAPI, e.g.: 'My API'"assertself.version,"A version must be provided for OpenAPI, e.g.: '2.1.0'"# TODO: remove when discarding the openapi_prefix parameterifopenapi_prefix:logger.warning('"openapi_prefix" has been deprecated in favor of "root_path", which '"follows more closely the ASGI standard, is simpler, and more ""automatic. Check the docs at ""https://fastapi.tiangolo.com/advanced/sub-applications/")self.webhooks:Annotated[routing.APIRouter,Doc("""            The `app.webhooks` attribute is an `APIRouter` with the *path            operations* that will be used just for documentation of webhooks.            Read more about it in the            [FastAPI docs for OpenAPI Webhooks](https://fastapi.tiangolo.com/advanced/openapi-webhooks/).            """),]=webhooksorrouting.APIRouter()self.root_path=root_pathoropenapi_prefixself.state:Annotated[State,Doc("""            A state object for the application. This is the same object for the            entire application, it doesn't change from request to request.            You normally wouldn't use this in FastAPI, for most of the cases you            would instead use FastAPI dependencies.            This is simply inherited from Starlette.            Read more about it in the            [Starlette docs for Applications](https://www.starlette.dev/applications/#storing-state-on-the-app-instance).            """),]=State()self.dependency_overrides:Annotated[dict[Callable[...,Any],Callable[...,Any]],Doc("""            A dictionary with overrides for the dependencies.            Each key is the original dependency callable, and the value is the            actual dependency that should be called.            This is for testing, to replace expensive dependencies with testing            versions.            Read more about it in the            [FastAPI docs for Testing Dependencies with Overrides](https://fastapi.tiangolo.com/advanced/testing-dependencies/).            """),]={}self.router:routing.APIRouter=routing.APIRouter(routes=routes,redirect_slashes=redirect_slashes,dependency_overrides_provider=self,on_startup=on_startup,on_shutdown=on_shutdown,lifespan=lifespan,default_response_class=default_response_class,dependencies=dependencies,callbacks=callbacks,deprecated=deprecated,include_in_schema=include_in_schema,responses=responses,generate_unique_id_function=generate_unique_id_function,)self.exception_handlers:dict[Any,Callable[[Request,Any],Response|Awaitable[Response]]]={}ifexception_handlersisNoneelsedict(exception_handlers)self.exception_handlers.setdefault(HTTPException,http_exception_handler)self.exception_handlers.setdefault(RequestValidationError,request_validation_exception_handler)self.exception_handlers.setdefault(WebSocketRequestValidationError,# Starlette still has incorrect type specification for the handlerswebsocket_request_validation_exception_handler,# type: ignore)self.user_middleware:list[Middleware]=([]ifmiddlewareisNoneelselist(middleware))self.middleware_stack:ASGIApp|None=Noneself.setup()