From 4ee39e7b8e687ebb95f175424fdfa32340c2c522 Mon Sep 17 00:00:00 2001 From: Kinuax Date: Tue, 29 Apr 2025 00:23:28 +0200 Subject: [PATCH] Add support for enabling/disabling input and url fields in validation errors --- fastapi/_compat.py | 33 ++++++++++++++---- fastapi/applications.py | 26 +++++++++++++++ fastapi/dependencies/utils.py | 20 +++++++++-- fastapi/routing.py | 63 +++++++++++++++++++++++++++++++++-- fastapi/utils.py | 11 +++++- 5 files changed, 141 insertions(+), 12 deletions(-) diff --git a/fastapi/_compat.py b/fastapi/_compat.py index c07e4a3b0..dbc5251e5 100644 --- a/fastapi/_compat.py +++ b/fastapi/_compat.py @@ -89,6 +89,8 @@ if PYDANTIC_V2: field_info: FieldInfo name: str mode: Literal["validation", "serialization"] = "validation" + include_error_input: bool = True + include_error_url: bool = False @property def alias(self) -> str: @@ -131,7 +133,11 @@ if PYDANTIC_V2: ) except ValidationError as exc: return None, _regenerate_error_with_loc( - errors=exc.errors(include_url=False), loc_prefix=loc + errors=exc.errors( + include_input=self.include_error_input, + include_url=self.include_error_url, + ), + loc_prefix=loc, ) def serialize( @@ -267,11 +273,16 @@ if PYDANTIC_V2: assert issubclass(origin_type, sequence_types) # type: ignore[arg-type] return sequence_annotation_to_type[origin_type](value) # type: ignore[no-any-return] - def get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]: + def get_missing_field_error( + loc: Tuple[str, ...], + include_error_input: bool = True, + include_error_url: bool = False, + ) -> Dict[str, Any]: error = ValidationError.from_exception_data( "Field required", [{"type": "missing", "loc": loc, "input": {}}] - ).errors(include_url=False)[0] - error["input"] = None + ).errors(include_url=include_error_url)[0] + if include_error_input: + error["input"] = None return error # type: ignore[return-value] def create_body_model( @@ -509,10 +520,18 @@ else: def serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]: return sequence_shape_to_type[field.shape](value) # type: ignore[no-any-return,attr-defined] - def get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]: + def get_missing_field_error( + loc: Tuple[str, ...], + include_error_input: bool = True, + include_error_url: bool = False, + ) -> Dict[str, Any]: missing_field_error = ErrorWrapper(MissingError(), loc=loc) # type: ignore[call-arg] - new_error = ValidationError([missing_field_error], RequestErrorModel) - return new_error.errors()[0] # type: ignore[return-value] + new_error = ValidationError([missing_field_error], RequestErrorModel).errors( + include_url=include_error_url + )[0] + if include_error_input: + new_error["input"] = None + return new_error # type: ignore[return-value] def create_body_model( *, fields: Sequence[ModelField], model_name: str diff --git a/fastapi/applications.py b/fastapi/applications.py index 6d427cdc2..ecd53746a 100644 --- a/fastapi/applications.py +++ b/fastapi/applications.py @@ -752,6 +752,22 @@ class FastAPI(Starlette): """ ), ] = True, + include_error_input: Annotated[ + bool, + Doc( + """ + TODO + """ + ), + ] = True, + include_error_url: Annotated[ + bool, + Doc( + """ + TODO + """ + ), + ] = False, swagger_ui_parameters: Annotated[ Optional[Dict[str, Any]], Doc( @@ -941,6 +957,8 @@ class FastAPI(Starlette): callbacks=callbacks, deprecated=deprecated, include_in_schema=include_in_schema, + include_error_input=include_error_input, + include_error_url=include_error_url, responses=responses, generate_unique_id_function=generate_unique_id_function, ) @@ -1076,6 +1094,8 @@ class FastAPI(Starlette): response_model_exclude_defaults: bool = False, response_model_exclude_none: bool = False, include_in_schema: bool = True, + include_error_input: bool = True, + include_error_url: bool = False, response_class: Union[Type[Response], DefaultPlaceholder] = Default( JSONResponse ), @@ -1106,6 +1126,8 @@ class FastAPI(Starlette): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=include_error_input, + include_error_url=include_error_url, response_class=response_class, name=name, openapi_extra=openapi_extra, @@ -1134,6 +1156,8 @@ class FastAPI(Starlette): response_model_exclude_defaults: bool = False, response_model_exclude_none: bool = False, include_in_schema: bool = True, + include_error_input: bool = True, + include_error_url: bool = False, response_class: Type[Response] = Default(JSONResponse), name: Optional[str] = None, openapi_extra: Optional[Dict[str, Any]] = None, @@ -1163,6 +1187,8 @@ class FastAPI(Starlette): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=include_error_input, + include_error_url=include_error_url, response_class=response_class, name=name, openapi_extra=openapi_extra, diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py index 84dfa4d03..eb39f3e61 100644 --- a/fastapi/dependencies/utils.py +++ b/fastapi/dependencies/utils.py @@ -269,6 +269,8 @@ def get_dependant( name: Optional[str] = None, security_scopes: Optional[List[str]] = None, use_cache: bool = True, + include_error_input: bool = True, + include_error_url: bool = False, ) -> Dependant: path_param_names = get_path_param_names(path) endpoint_signature = get_typed_signature(call) @@ -287,6 +289,8 @@ def get_dependant( annotation=param.annotation, value=param.default, is_path_param=is_path_param, + include_error_input=include_error_input, + include_error_url=include_error_url, ) if param_details.depends is not None: sub_dependant = get_param_sub_dependant( @@ -351,6 +355,8 @@ def analyze_param( annotation: Any, value: Any, is_path_param: bool, + include_error_input: bool, + include_error_url: bool, ) -> ParamDetails: field_info = None depends = None @@ -492,6 +498,8 @@ def analyze_param( alias=alias, required=field_info.default in (RequiredParam, Undefined), field_info=field_info, + include_error_input=include_error_input, + include_error_url=include_error_url, ) if is_path_param: assert is_scalar_field(field=field), ( @@ -700,7 +708,11 @@ def _validate_value_with_model_field( ) -> Tuple[Any, List[Any]]: if value is None: if field.required: - return None, [get_missing_field_error(loc=loc)] + return None, [ + get_missing_field_error( + loc, field.include_error_input, field.include_error_url + ) + ] else: return deepcopy(field.default), [] v_, errors_ = field.validate(value, values, loc=loc) @@ -915,7 +927,11 @@ async def request_body_to_args( value = body_to_process.get(field.alias) # If the received body is a list, not a dict except AttributeError: - errors.append(get_missing_field_error(loc)) + errors.append( + get_missing_field_error( + loc, field.include_error_input, field.include_error_url + ) + ) continue v_, errors_ = _validate_value_with_model_field( field=field, value=value, values=values, loc=loc diff --git a/fastapi/routing.py b/fastapi/routing.py index 457481e32..0bb443941 100644 --- a/fastapi/routing.py +++ b/fastapi/routing.py @@ -450,6 +450,8 @@ class APIRoute(routing.Route): response_model_exclude_defaults: bool = False, response_model_exclude_none: bool = False, include_in_schema: bool = True, + include_error_input: bool = True, + include_error_url: bool = False, response_class: Union[Type[Response], DefaultPlaceholder] = Default( JSONResponse ), @@ -480,6 +482,8 @@ class APIRoute(routing.Route): 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.include_error_input = include_error_input + self.include_error_url = include_error_url self.response_class = response_class self.dependency_overrides_provider = dependency_overrides_provider self.callbacks = callbacks @@ -512,6 +516,8 @@ class APIRoute(routing.Route): name=response_name, type_=self.response_model, mode="serialization", + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, ) # 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 @@ -542,7 +548,11 @@ class APIRoute(routing.Route): ) response_name = f"Response_{additional_status_code}_{self.unique_id}" response_field = create_model_field( - name=response_name, type_=model, mode="serialization" + name=response_name, + type_=model, + mode="serialization", + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, ) response_fields[additional_status_code] = response_field if response_fields: @@ -551,7 +561,12 @@ class APIRoute(routing.Route): self.response_fields = {} assert callable(endpoint), "An endpoint must be a callable" - self.dependant = get_dependant(path=self.path_format, call=self.endpoint) + self.dependant = get_dependant( + path=self.path_format, + call=self.endpoint, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, + ) for depends in self.dependencies[::-1]: self.dependant.dependencies.insert( 0, @@ -818,6 +833,22 @@ class APIRouter(routing.Router): """ ), ] = True, + include_error_input: Annotated[ + bool, + Doc( + """ + TODO + """ + ), + ] = True, + include_error_url: Annotated[ + bool, + Doc( + """ + TODO + """ + ), + ] = False, generate_unique_id_function: Annotated[ Callable[[APIRoute], str], Doc( @@ -852,6 +883,8 @@ class APIRouter(routing.Router): self.dependencies = list(dependencies or []) self.deprecated = deprecated self.include_in_schema = include_in_schema + self.include_error_input = include_error_input + self.include_error_url = include_error_url self.responses = responses or {} self.callbacks = callbacks or [] self.dependency_overrides_provider = dependency_overrides_provider @@ -901,6 +934,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults: bool = False, response_model_exclude_none: bool = False, include_in_schema: bool = True, + include_error_input: bool = True, + include_error_url: bool = False, response_class: Union[Type[Response], DefaultPlaceholder] = Default( JSONResponse ), @@ -951,6 +986,8 @@ class APIRouter(routing.Router): 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, + include_error_input=include_error_input, + include_error_url=include_error_url, response_class=current_response_class, name=name, dependency_overrides_provider=self.dependency_overrides_provider, @@ -982,6 +1019,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults: bool = False, response_model_exclude_none: bool = False, include_in_schema: bool = True, + include_error_input: bool = True, + include_error_url: bool = False, response_class: Type[Response] = Default(JSONResponse), name: Optional[str] = None, callbacks: Optional[List[BaseRoute]] = None, @@ -1012,6 +1051,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=include_error_input, + include_error_url=include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -1322,6 +1363,8 @@ class APIRouter(routing.Router): include_in_schema=route.include_in_schema and self.include_in_schema and include_in_schema, + include_error_input=route.include_error_input, + include_error_url=route.include_error_url, response_class=use_response_class, name=route.name, route_class_override=type(route), @@ -1733,6 +1776,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -2115,6 +2160,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -2497,6 +2544,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -2874,6 +2923,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -3251,6 +3302,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -3633,6 +3686,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -4015,6 +4070,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, @@ -4397,6 +4454,8 @@ class APIRouter(routing.Router): response_model_exclude_defaults=response_model_exclude_defaults, response_model_exclude_none=response_model_exclude_none, include_in_schema=include_in_schema, + include_error_input=self.include_error_input, + include_error_url=self.include_error_url, response_class=response_class, name=name, callbacks=callbacks, diff --git a/fastapi/utils.py b/fastapi/utils.py index 4c7350fea..84b83be3a 100644 --- a/fastapi/utils.py +++ b/fastapi/utils.py @@ -70,6 +70,8 @@ def create_model_field( field_info: Optional[FieldInfo] = None, alias: Optional[str] = None, mode: Literal["validation", "serialization"] = "validation", + include_error_input: bool = True, + include_error_url: bool = False, ) -> ModelField: class_validators = class_validators or {} if PYDANTIC_V2: @@ -78,7 +80,12 @@ def create_model_field( ) else: field_info = field_info or FieldInfo() - kwargs = {"name": name, "field_info": field_info} + kwargs = { + "name": name, + "field_info": field_info, + "include_error_input": include_error_input, + "include_error_url": include_error_url, + } if PYDANTIC_V2: kwargs.update({"mode": mode}) else: @@ -140,6 +147,8 @@ def create_cloned_field( new_field.required = field.required # type: ignore[misc] new_field.model_config = field.model_config # type: ignore[attr-defined] new_field.field_info = field.field_info + new_field.include_error_input = field.include_error_input + new_field.include_error_url = field.include_error_url new_field.allow_none = field.allow_none # type: ignore[attr-defined] new_field.validate_always = field.validate_always # type: ignore[attr-defined] if field.sub_fields: # type: ignore[attr-defined]