265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314

def__init__(self,*,name:Annotated[str,Doc("Cookie name.")],scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if the cookie is not provided, `APIKeyCookie` will            automatically cancel the request and send the client an error.            If `auto_error` is set to `False`, when the cookie is not available,            instead of erroring out, the dependency result will be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, in a cookie or            in an HTTP Bearer token).            """),]=True,):super().__init__(location=APIKeyIn.cookie,name=name,scheme_name=scheme_name,description=description,auto_error=auto_error,)

177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226

def__init__(self,*,name:Annotated[str,Doc("Header name.")],scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if the header is not provided, `APIKeyHeader` will            automatically cancel the request and send the client an error.            If `auto_error` is set to `False`, when the header is not available,            instead of erroring out, the dependency result will be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, in a header or            in an HTTP Bearer token).            """),]=True,):super().__init__(location=APIKeyIn.header,name=name,scheme_name=scheme_name,description=description,auto_error=auto_error,)

 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138

def__init__(self,*,name:Annotated[str,Doc("Query parameter name."),],scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if the query parameter is not provided, `APIKeyQuery` will            automatically cancel the request and send the client an error.            If `auto_error` is set to `False`, when the query parameter is not            available, instead of erroring out, the dependency result will be            `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, in a query            parameter or in an HTTP Bearer token).            """),]=True,):super().__init__(location=APIKeyIn.query,name=name,scheme_name=scheme_name,description=description,auto_error=auto_error,)

140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195

def__init__(self,*,scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,realm:Annotated[str|None,Doc("""            HTTP Basic authentication realm.            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if the HTTP Basic authentication is not provided (a            header), `HTTPBasic` will automatically cancel the request and send the            client an error.            If `auto_error` is set to `False`, when the HTTP Basic authentication            is not available, instead of erroring out, the dependency result will            be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, in HTTP Basic            authentication or in an HTTP Bearer token).            """),]=True,):self.model=HTTPBaseModel(scheme="basic",description=description)self.scheme_name=scheme_nameorself.__class__.__name__self.realm=realmself.auto_error=auto_error

254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301

def__init__(self,*,bearerFormat:Annotated[str|None,Doc("Bearer token format.")]=None,scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if the HTTP Bearer token is not provided (in an            `Authorization` header), `HTTPBearer` will automatically cancel the            request and send the client an error.            If `auto_error` is set to `False`, when the HTTP Bearer token            is not available, instead of erroring out, the dependency result will            be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, in an HTTP            Bearer token or in a cookie).            """),]=True,):self.model=HTTPBearerModel(bearerFormat=bearerFormat,description=description)self.scheme_name=scheme_nameorself.__class__.__name__self.auto_error=auto_error

357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402

def__init__(self,*,scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if the HTTP Digest is not provided, `HTTPDigest` will            automatically cancel the request and send the client an error.            If `auto_error` is set to `False`, when the HTTP Digest is not            available, instead of erroring out, the dependency result will            be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, in HTTP            Digest or in a cookie).            """),]=True,):self.model=HTTPBaseModel(scheme="digest",description=description)self.scheme_name=scheme_nameorself.__class__.__name__self.auto_error=auto_error

343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399

def__init__(self,*,flows:Annotated[OAuthFlowsModel|dict[str,dict[str,Any]],Doc("""            The dictionary of OAuth2 flows.            """),]=OAuthFlowsModel(),scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if no HTTP Authorization header is provided, required for            OAuth2 authentication, it will automatically cancel the request and            send the client an error.            If `auto_error` is set to `False`, when the HTTP Authorization header            is not available, instead of erroring out, the dependency result will            be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, with OAuth2            or in a cookie).            """),]=True,):self.model=OAuth2Model(flows=cast(OAuthFlowsModel,flows),description=description)self.scheme_name=scheme_nameorself.__class__.__name__self.auto_error=auto_error

553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640

def__init__(self,authorizationUrl:str,tokenUrl:Annotated[str,Doc("""            The URL to obtain the OAuth2 token.            """),],refreshUrl:Annotated[str|None,Doc("""            The URL to refresh the token and obtain a new one.            """),]=None,scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,scopes:Annotated[dict[str,str]|None,Doc("""            The OAuth2 scopes that would be required by the *path operations* that            use this dependency.            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if no HTTP Authorization header is provided, required for            OAuth2 authentication, it will automatically cancel the request and            send the client an error.            If `auto_error` is set to `False`, when the HTTP Authorization header            is not available, instead of erroring out, the dependency result will            be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, with OAuth2            or in a cookie).            """),]=True,):ifnotscopes:scopes={}flows=OAuthFlowsModel(authorizationCode=cast(Any,{"authorizationUrl":authorizationUrl,"tokenUrl":tokenUrl,"refreshUrl":refreshUrl,"scopes":scopes,},))super().__init__(flows=flows,scheme_name=scheme_name,description=description,auto_error=auto_error,)

442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534

def__init__(self,tokenUrl:Annotated[str,Doc("""            The URL to obtain the OAuth2 token. This would be the *path operation*            that has `OAuth2PasswordRequestForm` as a dependency.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),],scheme_name:Annotated[str|None,Doc("""            Security scheme name.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,scopes:Annotated[dict[str,str]|None,Doc("""            The OAuth2 scopes that would be required by the *path operations* that            use this dependency.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),]=None,description:Annotated[str|None,Doc("""            Security scheme description.            It will be included in the generated OpenAPI (e.g. visible at `/docs`).            """),]=None,auto_error:Annotated[bool,Doc("""            By default, if no HTTP Authorization header is provided, required for            OAuth2 authentication, it will automatically cancel the request and            send the client an error.            If `auto_error` is set to `False`, when the HTTP Authorization header            is not available, instead of erroring out, the dependency result will            be `None`.            This is useful when you want to have optional authentication.            It is also useful when you want to have authentication that can be            provided in one of multiple optional ways (for example, with OAuth2            or in a cookie).            """),]=True,refreshUrl:Annotated[str|None,Doc("""            The URL to refresh the token and obtain a new one.            """),]=None,):ifnotscopes:scopes={}flows=OAuthFlowsModel(password=cast(Any,{"tokenUrl":tokenUrl,"refreshUrl":refreshUrl,"scopes":scopes,},))super().__init__(flows=flows,scheme_name=scheme_name,description=description,auto_error=auto_error,)

 59 60 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 99100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159

def__init__(self,*,grant_type:Annotated[str|None,Form(pattern="^password$"),Doc("""            The OAuth2 spec says it is required and MUST be the fixed string            "password". Nevertheless, this dependency class is permissive and            allows not passing it. If you want to enforce it, use instead the            `OAuth2PasswordRequestFormStrict` dependency.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),]=None,username:Annotated[str,Form(),Doc("""            `username` string. The OAuth2 spec requires the exact field name            `username`.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),],password:Annotated[str,Form(json_schema_extra={"format":"password"}),Doc("""            `password` string. The OAuth2 spec requires the exact field name            `password`.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),],scope:Annotated[str,Form(),Doc("""            A single string with actually several scopes separated by spaces. Each            scope is also a string.            For example, a single string with:            ```python            "items:read items:write users:read profile openid"            ````            would represent the scopes:            * `items:read`            * `items:write`            * `users:read`            * `profile`            * `openid`            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),]="",client_id:Annotated[str|None,Form(),Doc("""            If there's a `client_id`, it can be sent as part of the form fields.            But the OAuth2 specification recommends sending the `client_id` and            `client_secret` (if any) using HTTP Basic auth.            """),]=None,client_secret:Annotated[str|None,Form(json_schema_extra={"format":"password"}),Doc("""            If there's a `client_password` (and a `client_id`), they can be sent            as part of the form fields. But the OAuth2 specification recommends            sending the `client_id` and `client_secret` (if any) using HTTP Basic            auth.            """),]=None,):self.grant_type=grant_typeself.username=usernameself.password=passwordself.scopes=scope.split()self.client_id=client_idself.client_secret=client_secret

226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327

def__init__(self,grant_type:Annotated[str,Form(pattern="^password$"),Doc("""            The OAuth2 spec says it is required and MUST be the fixed string            "password". This dependency is strict about it. If you want to be            permissive, use instead the `OAuth2PasswordRequestForm` dependency            class.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),],username:Annotated[str,Form(),Doc("""            `username` string. The OAuth2 spec requires the exact field name            `username`.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),],password:Annotated[str,Form(),Doc("""            `password` string. The OAuth2 spec requires the exact field name            `password`.            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),],scope:Annotated[str,Form(),Doc("""            A single string with actually several scopes separated by spaces. Each            scope is also a string.            For example, a single string with:            ```python            "items:read items:write users:read profile openid"            ````            would represent the scopes:            * `items:read`            * `items:write`            * `users:read`            * `profile`            * `openid`            Read more about it in the            [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).            """),]="",client_id:Annotated[str|None,Form(),Doc("""            If there's a `client_id`, it can be sent as part of the form fields.            But the OAuth2 specification recommends sending the `client_id` and            `client_secret` (if any) using HTTP Basic auth.            """),]=None,client_secret:Annotated[str|None,Form(),Doc("""            If there's a `client_password` (and a `client_id`), they can be sent            as part of the form fields. But the OAuth2 specification recommends            sending the `client_id` and `client_secret` (if any) using HTTP Basic            auth.            """),]=None,):super().__init__(grant_type=grant_type,username=username,password=password,scope=scope,client_id=client_id,client_secret=client_secret,)

666667668669670671672673674675676677678679680681682683684685686687688689690691692693

def__init__(self,scopes:Annotated[list[str]|None,Doc("""            This will be filled by FastAPI.            """),]=None,):self.scopes:Annotated[list[str],Doc("""            The list of all the scopes required by dependencies.            """),]=scopesor[]self.scope_str:Annotated[str,Doc("""            All the scopes required by all the dependencies in a single string            separated by spaces, as defined in the OAuth2 specification.            """),]=" ".join(self.scopes)