From 6ed9a755f8d0671d8ac8ec40c1431dbeeb76a74e Mon Sep 17 00:00:00 2001 From: "Laurent Mignon (ACSONE)" Date: Sun, 2 Oct 2022 22:19:59 +0200 Subject: [PATCH 1/5] Fix openapi document with dependencies override (#5451) --- fastapi/dependencies/utils.py | 48 +++++ fastapi/openapi/utils.py | 18 +- tests/test_dependency_overrides_openapi.py | 193 ++++++++++++++++++ ...t_dependency_security_overrides_openapi.py | 146 +++++++++++++ 4 files changed, 404 insertions(+), 1 deletion(-) create mode 100644 tests/test_dependency_overrides_openapi.py create mode 100644 tests/test_dependency_security_overrides_openapi.py diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py index 5cebbf00f..d64c47c70 100644 --- a/fastapi/dependencies/utils.py +++ b/fastapi/dependencies/utils.py @@ -113,6 +113,7 @@ def get_param_sub_dependant( depends: params.Depends, path: str, security_scopes: Optional[List[str]] = None, + dependency_overrides: Optional[Dict[Callable[..., Any], Callable[..., Any]]] = None, ) -> Dependant: assert depends.dependency return get_sub_dependant( @@ -121,6 +122,7 @@ def get_param_sub_dependant( path=path, name=param_name, security_scopes=security_scopes, + dependency_overrides=dependency_overrides, ) @@ -138,7 +140,9 @@ def get_sub_dependant( path: str, name: Optional[str] = None, security_scopes: Optional[List[str]] = None, + dependency_overrides: Optional[Dict[Callable[..., Any], Callable[..., Any]]] = None, ) -> Dependant: + dependency = (dependency_overrides or {}).get(dependency, dependency) security_requirement = None security_scopes = security_scopes or [] if isinstance(depends, params.Security): @@ -157,6 +161,7 @@ def get_sub_dependant( name=name, security_scopes=security_scopes, use_cache=depends.use_cache, + dependency_overrides=dependency_overrides, ) if security_requirement: sub_dependant.security_requirements.append(security_requirement) @@ -254,6 +259,46 @@ def get_typed_return_annotation(call: Callable[..., Any]) -> Any: return get_typed_annotation(annotation, globalns) +def get_resolved_dependant( + *, + dependant: Dependant, + dependency_overrides: Optional[Dict[Callable[..., Any], Callable[..., Any]]] = None, +) -> Dependant: + new_call = call = dependant.call + if call: + new_call = (dependency_overrides or {}).get(call) + if new_call: + resolved_dependant = get_dependant( + path=dependant.path or "", + call=new_call, + name=dependant.name, + security_scopes=dependant.security_scopes, + use_cache=False, + dependency_overrides=dependency_overrides, + ) + else: + resolved_dependant = Dependant( + call=dependant.call, + name=dependant.name, + path=dependant.path, + security_scopes=dependant.security_scopes, + use_cache=False, + path_params=dependant.path_params.copy(), + query_params=dependant.query_params.copy(), + header_params=dependant.header_params.copy(), + cookie_params=dependant.cookie_params.copy(), + body_params=dependant.body_params.copy(), + security_schemes=dependant.security_requirements.copy(), + ) + for sub_dependant in dependant.dependencies: + resolved_dependant.dependencies.append( + get_resolved_dependant( + dependant=sub_dependant, dependency_overrides=dependency_overrides + ) + ) + return resolved_dependant + + def get_dependant( *, path: str, @@ -261,7 +306,9 @@ def get_dependant( name: Optional[str] = None, security_scopes: Optional[List[str]] = None, use_cache: bool = True, + dependency_overrides: Optional[Dict[Callable[..., Any], Callable[..., Any]]] = None, ) -> Dependant: + call = (dependency_overrides or {}).get(call, call) path_param_names = get_path_param_names(path) endpoint_signature = get_typed_signature(call) signature_params = endpoint_signature.parameters @@ -286,6 +333,7 @@ def get_dependant( depends=param_details.depends, path=path, security_scopes=security_scopes, + dependency_overrides=dependency_overrides, ) dependant.dependencies.append(sub_dependant) continue diff --git a/fastapi/openapi/utils.py b/fastapi/openapi/utils.py index 947eca948..a27304fb6 100644 --- a/fastapi/openapi/utils.py +++ b/fastapi/openapi/utils.py @@ -20,6 +20,7 @@ from fastapi.dependencies.utils import ( _get_flat_fields_from_params, get_flat_dependant, get_flat_params, + get_resolved_dependant, ) from fastapi.encoders import jsonable_encoder from fastapi.openapi.constants import METHODS_WITH_BODY, REF_PREFIX, REF_TEMPLATE @@ -256,8 +257,17 @@ def get_openapi_path( operation = get_openapi_operation_metadata( route=route, method=method, operation_ids=operation_ids ) + dependency_overrides = None + if route.dependency_overrides_provider: + dependency_overrides = ( + route.dependency_overrides_provider.dependency_overrides + ) + dependant = get_resolved_dependant( + dependant=route.dependant, + dependency_overrides=dependency_overrides, + ) parameters: List[Dict[str, Any]] = [] - flat_dependant = get_flat_dependant(route.dependant, skip_repeats=True) + flat_dependant = get_flat_dependant(dependant, skip_repeats=True) security_definitions, operation_security = get_openapi_security_definitions( flat_dependant=flat_dependant ) @@ -265,8 +275,14 @@ def get_openapi_path( operation.setdefault("security", []).extend(operation_security) if security_definitions: security_schemes.update(security_definitions) +<<<<<<< HEAD operation_parameters = _get_openapi_operation_parameters( dependant=route.dependant, +======= + all_route_params = get_flat_params(dependant) + operation_parameters = get_openapi_operation_parameters( + all_route_params=all_route_params, +>>>>>>> 022f1e79 (Fix openapi document with dependencies override (#5451)) schema_generator=schema_generator, model_name_map=model_name_map, field_mapping=field_mapping, diff --git a/tests/test_dependency_overrides_openapi.py b/tests/test_dependency_overrides_openapi.py new file mode 100644 index 000000000..82bada04c --- /dev/null +++ b/tests/test_dependency_overrides_openapi.py @@ -0,0 +1,193 @@ +from typing import Optional + +from fastapi import APIRouter, Depends, FastAPI +from fastapi.testclient import TestClient + +app = FastAPI() + +router = APIRouter() + + +async def common_parameters(q: str, skip: int = 0, limit: int = 100): + pass # pragma: no cover + + +@app.get("/main-depends/") +async def main_depends(commons: dict = Depends(common_parameters)): + pass # pragma: no cover + + +app.include_router(router) + +client = TestClient(app) + + +async def overrider_dependency_simple(q: Optional[str] = None): + pass # pragma: no cover + + +async def overrider_sub_dependency(k: str): + pass # pragma: no cover + + +async def overrider_dependency_with_sub(msg: dict = Depends(overrider_sub_dependency)): + pass # pragma: no cover + + +override_simple_openapi_schema = { + "openapi": "3.1.0", + "info": {"title": "FastAPI", "version": "0.1.0"}, + "paths": { + "/main-depends/": { + "get": { + "summary": "Main Depends", + "operationId": "main_depends_main_depends__get", + "parameters": [ + { + "required": False, + "schema": {"title": "Q", "type": "string"}, + "name": "q", + "in": "query", + }, + ], + "responses": { + "200": { + "description": "Successful Response", + "content": {"application/json": {"schema": {}}}, + }, + "422": { + "description": "Validation Error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + }, + }, + } + } + }, + "components": { + "schemas": { + "HTTPValidationError": { + "title": "HTTPValidationError", + "type": "object", + "properties": { + "detail": { + "title": "Detail", + "type": "array", + "items": {"$ref": "#/components/schemas/ValidationError"}, + } + }, + }, + "ValidationError": { + "title": "ValidationError", + "required": ["loc", "msg", "type"], + "type": "object", + "properties": { + "loc": { + "title": "Location", + "type": "array", + "items": {"anyOf": [{"type": "string"}, {"type": "integer"}]}, + }, + "msg": {"title": "Message", "type": "string"}, + "type": {"title": "Error Type", "type": "string"}, + }, + }, + } + }, +} + + +def test_override_simple_openapi(): + app.dependency_overrides[common_parameters] = overrider_dependency_simple + app.openapi_schema = None + response = client.get("/openapi.json") + assert response.status_code == 200, response.text + assert response.json() == override_simple_openapi_schema + + +overrider_dependency_with_sub_schema = { + "openapi": "3.1.0", + "info": {"title": "FastAPI", "version": "0.1.0"}, + "paths": { + "/main-depends/": { + "get": { + "summary": "Main Depends", + "operationId": "main_depends_main_depends__get", + "parameters": [ + { + "required": True, + "schema": {"title": "K", "type": "string"}, + "name": "k", + "in": "query", + }, + ], + "responses": { + "200": { + "description": "Successful Response", + "content": {"application/json": {"schema": {}}}, + }, + "422": { + "description": "Validation Error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + }, + }, + } + } + }, + "components": { + "schemas": { + "HTTPValidationError": { + "title": "HTTPValidationError", + "type": "object", + "properties": { + "detail": { + "title": "Detail", + "type": "array", + "items": {"$ref": "#/components/schemas/ValidationError"}, + } + }, + }, + "ValidationError": { + "title": "ValidationError", + "required": ["loc", "msg", "type"], + "type": "object", + "properties": { + "loc": { + "title": "Location", + "type": "array", + "items": {"anyOf": [{"type": "string"}, {"type": "integer"}]}, + }, + "msg": {"title": "Message", "type": "string"}, + "type": {"title": "Error Type", "type": "string"}, + }, + }, + } + }, +} + + +def test_overrider_dependency_with_sub(): + app.dependency_overrides[common_parameters] = overrider_dependency_with_sub + app.openapi_schema = None + response = client.get("/openapi.json") + assert response.status_code == 200, response.text + assert response.json() == overrider_dependency_with_sub_schema + + +def test_overrider_dependency_with_overriden_sub(): + app.dependency_overrides[common_parameters] = overrider_dependency_with_sub + app.dependency_overrides[overrider_sub_dependency] = overrider_dependency_simple + app.openapi_schema = None + response = client.get("/openapi.json") + assert response.status_code == 200, response.text + assert response.json() == override_simple_openapi_schema diff --git a/tests/test_dependency_security_overrides_openapi.py b/tests/test_dependency_security_overrides_openapi.py new file mode 100644 index 000000000..f6b55cf15 --- /dev/null +++ b/tests/test_dependency_security_overrides_openapi.py @@ -0,0 +1,146 @@ +from fastapi import Depends, FastAPI, Header +from fastapi.security import OAuth2PasswordBearer +from fastapi.testclient import TestClient + +app = FastAPI() + + +def get_user_id() -> int: + pass # pragma: no cover + + +def get_user(user_id=Depends(get_user_id)): + pass # pragma: no cover + + +oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") + + +def get_user_id_from_auth_override(token: str = Depends(oauth2_scheme)): + pass # pragma: no cover + + +def get_user_id_from_header_override(user_id: int = Header()): + pass # pragma: no cover + + +@app.get("/user") +def read_user( + user: str = Depends(get_user), +): + pass # pragma: no cover + + +client = TestClient(app) + + +override_with_security_schema = { + "components": { + "securitySchemes": { + "OAuth2PasswordBearer": { + "flows": {"password": {"scopes": {}, "tokenUrl": "token"}}, + "type": "oauth2", + } + } + }, + "info": {"title": "FastAPI", "version": "0.1.0"}, + "openapi": "3.1.0", + "paths": { + "/user": { + "get": { + "operationId": "read_user_user_get", + "responses": { + "200": { + "content": {"application/json": {"schema": {}}}, + "description": "Successful " "Response", + } + }, + "security": [{"OAuth2PasswordBearer": []}], + "summary": "Read User", + } + } + }, +} + + +def test_override_with_security(): + app.dependency_overrides[get_user_id] = get_user_id_from_auth_override + app.openapi_schema = None + response = client.get("/openapi.json") + assert response.status_code == 200, response.text + assert response.json() == override_with_security_schema + + +override_with_header_schema = { + "components": { + "schemas": { + "HTTPValidationError": { + "properties": { + "detail": { + "items": {"$ref": "#/components/schemas/ValidationError"}, + "title": "Detail", + "type": "array", + } + }, + "title": "HTTPValidationError", + "type": "object", + }, + "ValidationError": { + "properties": { + "loc": { + "items": {"anyOf": [{"type": "string"}, {"type": "integer"}]}, + "title": "Location", + "type": "array", + }, + "msg": {"title": "Message", "type": "string"}, + "type": {"title": "Error " "Type", "type": "string"}, + }, + "required": ["loc", "msg", "type"], + "title": "ValidationError", + "type": "object", + }, + } + }, + "info": {"title": "FastAPI", "version": "0.1.0"}, + "openapi": "3.1.0", + "paths": { + "/user": { + "get": { + "operationId": "read_user_user_get", + "parameters": [ + { + "in": "header", + "name": "user-id", + "required": True, + "schema": {"title": "User-Id", "type": "integer"}, + } + ], + "responses": { + "200": { + "content": {"application/json": {"schema": {}}}, + "description": "Successful " "Response", + }, + "422": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + "description": "Validation " "Error", + }, + }, + "summary": "Read User", + } + } + }, +} + + +def test_override_with_header(): + app.dependency_overrides[get_user_id] = get_user_id_from_header_override + app.openapi_schema = None + response = client.get("/openapi.json") + assert response.status_code == 200, response.text + assert response.json() == override_with_header_schema From aec8ee38464b40af00377f4686d2d8321b57f9e6 Mon Sep 17 00:00:00 2001 From: "Laurent Mignon (ACSONE)" Date: Fri, 6 Oct 2023 18:09:01 +0200 Subject: [PATCH 2/5] Openapi document with dependecies override with Pydantic V2 --- fastapi/_compat.py | 16 +++++++++++++++- fastapi/openapi/utils.py | 11 +++++++++++ tests/test_dependency_overrides_openapi.py | 5 ++++- 3 files changed, 30 insertions(+), 2 deletions(-) diff --git a/fastapi/_compat.py b/fastapi/_compat.py index 4b07b44fa..677745eaa 100644 --- a/fastapi/_compat.py +++ b/fastapi/_compat.py @@ -161,7 +161,21 @@ if PYDANTIC_V2: def __hash__(self) -> int: # Each ModelField is unique for our purposes, to allow making a dict from # ModelField to its JSON Schema. - return id(self) + # build a hash from the field_info and name and mode + # This method is probably not safe enough... but how can + # we easily hash and compare ModelFields builds with the same data? + return hash( + ( + repr(self.field_info), + self.name, + self.mode, + ) + ) + + def __eq__(self, other: Any) -> bool: + if not isinstance(other, ModelField): + return False + return self.__hash__() == other.__hash__() def get_annotation_from_field_info( annotation: Any, field_info: FieldInfo, field_name: str diff --git a/fastapi/openapi/utils.py b/fastapi/openapi/utils.py index a27304fb6..b1e8e71d5 100644 --- a/fastapi/openapi/utils.py +++ b/fastapi/openapi/utils.py @@ -461,6 +461,17 @@ def get_fields_from_routes( if route.callbacks: callback_flat_models.extend(get_fields_from_routes(route.callbacks)) params = get_flat_params(route.dependant) + dependency_overrides = None + if route.dependency_overrides_provider: + dependency_overrides = ( + route.dependency_overrides_provider.dependency_overrides + ) + dependant = get_resolved_dependant( + dependant=route.dependant, + dependency_overrides=dependency_overrides, + ) + params.extend(get_flat_params(dependant)) + request_fields_from_routes.extend(params) flat_models = callback_flat_models + list( diff --git a/tests/test_dependency_overrides_openapi.py b/tests/test_dependency_overrides_openapi.py index 82bada04c..5d2640cd3 100644 --- a/tests/test_dependency_overrides_openapi.py +++ b/tests/test_dependency_overrides_openapi.py @@ -45,7 +45,10 @@ override_simple_openapi_schema = { "parameters": [ { "required": False, - "schema": {"title": "Q", "type": "string"}, + "schema": { + "anyOf": [{"type": "string"}, {"type": "null"}], + "title": "Q", + }, "name": "q", "in": "query", }, From ea5c66e8481631b858c174a51de5be6387321e40 Mon Sep 17 00:00:00 2001 From: "Laurent Mignon (ACSONE)" Date: Tue, 13 Feb 2024 18:25:11 +0100 Subject: [PATCH 3/5] fixup! Openapi document with dependecies override with Pydantic V2 --- fastapi/_compat.py | 31 +++++++++++++++---------------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/fastapi/_compat.py b/fastapi/_compat.py index 677745eaa..dd43556b3 100644 --- a/fastapi/_compat.py +++ b/fastapi/_compat.py @@ -161,21 +161,7 @@ if PYDANTIC_V2: def __hash__(self) -> int: # Each ModelField is unique for our purposes, to allow making a dict from # ModelField to its JSON Schema. - # build a hash from the field_info and name and mode - # This method is probably not safe enough... but how can - # we easily hash and compare ModelFields builds with the same data? - return hash( - ( - repr(self.field_info), - self.name, - self.mode, - ) - ) - - def __eq__(self, other: Any) -> bool: - if not isinstance(other, ModelField): - return False - return self.__hash__() == other.__hash__() + return id(self) def get_annotation_from_field_info( annotation: Any, field_info: FieldInfo, field_name: str @@ -210,7 +196,20 @@ if PYDANTIC_V2: None if separate_input_output_schemas else "validation" ) # This expects that GenerateJsonSchema was already used to generate the definitions - json_schema = field_mapping[(field, override_mode or field.mode)] + try: + json_schema = field_mapping[(field, override_mode or field.mode)] + except KeyError: + inputs = [ + (field, override_mode or field.mode, field._type_adapter.core_schema) + ] + new_generator = GenerateJsonSchema( + ref_template=schema_generator.ref_template + ) + new_field_mapping, definitions = new_generator.generate_definitions( + inputs=inputs + ) + field_mapping.update(new_field_mapping) + json_schema = field_mapping[(field, override_mode or field.mode)] if "$ref" not in json_schema: # TODO remove when deprecating Pydantic v1 # Ref: https://github.com/pydantic/pydantic/blob/d61792cc42c80b13b23e3ffa74bc37ec7c77f7d1/pydantic/schema.py#L207 From 524148ea8cc7830018f684d459587922d5e3acc8 Mon Sep 17 00:00:00 2001 From: "Laurent Mignon (ACSONE)" Date: Wed, 14 Feb 2024 08:28:08 +0100 Subject: [PATCH 4/5] fixup! fixup! Openapi document with dependecies override with Pydantic V2 --- tests/test_dependency_overrides_openapi.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/test_dependency_overrides_openapi.py b/tests/test_dependency_overrides_openapi.py index 5d2640cd3..4fee7366b 100644 --- a/tests/test_dependency_overrides_openapi.py +++ b/tests/test_dependency_overrides_openapi.py @@ -1,6 +1,7 @@ from typing import Optional from fastapi import APIRouter, Depends, FastAPI +from fastapi._compat import PYDANTIC_V2 from fastapi.testclient import TestClient app = FastAPI() @@ -102,6 +103,10 @@ override_simple_openapi_schema = { } }, } +if not PYDANTIC_V2: + override_simple_openapi_schema["paths"]["/main-depends/"]["get"]["parameters"][0][ + "schema" + ] = {"title": "Q", "type": "string"} def test_override_simple_openapi(): From 8413c755a26b9a9b3dd3f293b3204bfa9d91c831 Mon Sep 17 00:00:00 2001 From: "Laurent Mignon (ACSONE)" Date: Fri, 20 Sep 2024 16:04:42 +0200 Subject: [PATCH 5/5] rebased on 0.115.0 --- fastapi/dependencies/utils.py | 2 +- fastapi/openapi/utils.py | 9 +--- ...t_dependency_security_overrides_openapi.py | 51 +++---------------- 3 files changed, 8 insertions(+), 54 deletions(-) diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py index d64c47c70..ecb654792 100644 --- a/fastapi/dependencies/utils.py +++ b/fastapi/dependencies/utils.py @@ -288,7 +288,7 @@ def get_resolved_dependant( header_params=dependant.header_params.copy(), cookie_params=dependant.cookie_params.copy(), body_params=dependant.body_params.copy(), - security_schemes=dependant.security_requirements.copy(), + security_requirements=dependant.security_requirements.copy(), ) for sub_dependant in dependant.dependencies: resolved_dependant.dependencies.append( diff --git a/fastapi/openapi/utils.py b/fastapi/openapi/utils.py index b1e8e71d5..174bd5d52 100644 --- a/fastapi/openapi/utils.py +++ b/fastapi/openapi/utils.py @@ -275,14 +275,8 @@ def get_openapi_path( operation.setdefault("security", []).extend(operation_security) if security_definitions: security_schemes.update(security_definitions) -<<<<<<< HEAD operation_parameters = _get_openapi_operation_parameters( - dependant=route.dependant, -======= - all_route_params = get_flat_params(dependant) - operation_parameters = get_openapi_operation_parameters( - all_route_params=all_route_params, ->>>>>>> 022f1e79 (Fix openapi document with dependencies override (#5451)) + dependant=dependant, schema_generator=schema_generator, model_name_map=model_name_map, field_mapping=field_mapping, @@ -471,7 +465,6 @@ def get_fields_from_routes( dependency_overrides=dependency_overrides, ) params.extend(get_flat_params(dependant)) - request_fields_from_routes.extend(params) flat_models = callback_flat_models + list( diff --git a/tests/test_dependency_security_overrides_openapi.py b/tests/test_dependency_security_overrides_openapi.py index f6b55cf15..70aa5b3ea 100644 --- a/tests/test_dependency_security_overrides_openapi.py +++ b/tests/test_dependency_security_overrides_openapi.py @@ -72,66 +72,27 @@ def test_override_with_security(): override_with_header_schema = { - "components": { - "schemas": { - "HTTPValidationError": { - "properties": { - "detail": { - "items": {"$ref": "#/components/schemas/ValidationError"}, - "title": "Detail", - "type": "array", - } - }, - "title": "HTTPValidationError", - "type": "object", - }, - "ValidationError": { - "properties": { - "loc": { - "items": {"anyOf": [{"type": "string"}, {"type": "integer"}]}, - "title": "Location", - "type": "array", - }, - "msg": {"title": "Message", "type": "string"}, - "type": {"title": "Error " "Type", "type": "string"}, - }, - "required": ["loc", "msg", "type"], - "title": "ValidationError", - "type": "object", - }, - } - }, - "info": {"title": "FastAPI", "version": "0.1.0"}, "openapi": "3.1.0", + "info": {"title": "FastAPI", "version": "0.1.0"}, "paths": { "/user": { "get": { + "summary": "Read User", "operationId": "read_user_user_get", "parameters": [ { - "in": "header", "name": "user-id", + "in": "header", "required": True, - "schema": {"title": "User-Id", "type": "integer"}, + "schema": {"type": "integer", "title": "User-Id"}, } ], "responses": { "200": { + "description": "Successful Response", "content": {"application/json": {"schema": {}}}, - "description": "Successful " "Response", - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation " "Error", - }, + } }, - "summary": "Read User", } } },