collusion-watch / source /data /swe_tasks /T5 /reference.patch
munip's picture
Publish Collusion-Watch article, source, and reviewed results
bd26047 verified
Raw History Blame Contribute Delete
18.8 kB
diff --git a/fastapi/dependencies/models.py b/fastapi/dependencies/models.py
index 5c7cbc82..047f49d7 100644
--- a/fastapi/dependencies/models.py
+++ b/fastapi/dependencies/models.py
@@ -49,6 +49,7 @@ class Dependant:
use_cache: bool = True
path: str | None = None
scope: Literal["function", "request"] | None = None
+ _request_param_names: dict[str, set[str]] | None = None
_UsesScopesCache = dict[int, tuple[Dependant, bool]]
diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py
index 8c2cc2a2..5543231c 100644
--- a/fastapi/dependencies/utils.py
+++ b/fastapi/dependencies/utils.py
@@ -155,16 +155,58 @@ def _get_flat_body_params(dependant: Dependant) -> list[ModelField]:
return body_params
-def _get_flat_fields_from_params(fields: list[ModelField]) -> list[ModelField]:
- if not fields:
- return fields
- first_field = fields[0]
- if len(fields) == 1 and lenient_issubclass(
- first_field.field_info.annotation, BaseModel
- ):
- fields_to_extract = get_cached_model_fields(first_field.field_info.annotation)
- return fields_to_extract
- return fields
+def _get_flat_fields_from_params(fields: Sequence[ModelField]) -> list[ModelField]:
+ flat_fields: list[ModelField] = []
+ for field in fields:
+ if lenient_issubclass(
+ field.field_info.annotation, BaseModel
+ ) and not _is_json_field(field):
+ flat_fields.extend(get_cached_model_fields(field.field_info.annotation))
+ else:
+ flat_fields.append(field)
+ return flat_fields
+
+
+def _get_request_param_names(
+ dependant: Dependant, dependency_overrides_provider: Any | None = None
+) -> dict[str, set[str]]:
+ """Collect accepted names across the effective dependency graph, by location."""
+ names: dict[str, set[str]] = {"query": set(), "header": set(), "cookie": set()}
+ overrides = (
+ getattr(dependency_overrides_provider, "dependency_overrides", None) or {}
+ )
+ dependants = [dependant]
+ while dependants:
+ current = dependants.pop()
+ for location, fields in (
+ ("query", current.query_params),
+ ("header", current.header_params),
+ ("cookie", current.cookie_params),
+ ):
+ for field in fields:
+ for param in _get_flat_fields_from_params([field]):
+ convert_underscores = location == "header" and getattr(
+ param.field_info,
+ "convert_underscores",
+ getattr(field.field_info, "convert_underscores", True),
+ )
+ for _, name in _get_param_aliases(
+ param, convert_underscores=convert_underscores
+ ):
+ names[location].add(
+ name.lower() if location == "header" else name
+ )
+ for sub_dependant in current.dependencies:
+ if sub_dependant.call in overrides:
+ sub_dependant = get_dependant(
+ path=cast(str, sub_dependant.path),
+ call=overrides[sub_dependant.call],
+ name=sub_dependant.name,
+ parent_oauth_scopes=_get_oauth_scopes(dependant=sub_dependant),
+ scope=sub_dependant.scope,
+ )
+ dependants.append(sub_dependant)
+ return names
def get_flat_params(dependant: Dependant) -> list[ModelField]:
@@ -626,6 +668,7 @@ async def solve_dependencies(
async_exit_stack: AsyncExitStack,
embed_body_fields: bool,
_uses_scopes_cache: _UsesScopesCache | None = None,
+ _request_param_names: dict[str, set[str]] | None = None,
) -> SolvedDependency:
request_astack = request.scope.get("fastapi_inner_astack")
assert isinstance(request_astack, AsyncExitStack), (
@@ -645,6 +688,15 @@ async def solve_dependencies(
dependency_cache = {}
if _uses_scopes_cache is None:
_uses_scopes_cache = {}
+ if _request_param_names is None:
+ _request_param_names = dependant._request_param_names
+ if _request_param_names is None or (
+ dependency_overrides_provider
+ and dependency_overrides_provider.dependency_overrides
+ ):
+ _request_param_names = _get_request_param_names(
+ dependant, dependency_overrides_provider
+ )
for sub_dependant in dependant.dependencies:
sub_dependant.call = cast(Callable[..., Any], sub_dependant.call)
call = sub_dependant.call
@@ -677,6 +729,7 @@ async def solve_dependencies(
async_exit_stack=async_exit_stack,
embed_body_fields=embed_body_fields,
_uses_scopes_cache=_uses_scopes_cache,
+ _request_param_names=_request_param_names,
)
background_tasks = solved_result.background_tasks
if solved_result.errors:
@@ -711,13 +764,19 @@ async def solve_dependencies(
dependant.path_params, request.path_params
)
query_values, query_errors = request_params_to_args(
- dependant.query_params, request.query_params
+ dependant.query_params,
+ request.query_params,
+ known_param_names=_request_param_names["query"],
)
header_values, header_errors = request_params_to_args(
- dependant.header_params, request.headers
+ dependant.header_params,
+ request.headers,
+ known_param_names=_request_param_names["header"],
)
cookie_values, cookie_errors = request_params_to_args(
- dependant.cookie_params, request.cookies
+ dependant.cookie_params,
+ request.cookies,
+ known_param_names=_request_param_names["cookie"],
)
values.update(path_values)
values.update(query_values)
@@ -812,41 +871,31 @@ def _get_multidict_value(
return value
-def request_params_to_args(
- fields: Sequence[ModelField],
- received_params: Mapping[str, Any] | QueryParams | Headers,
-) -> tuple[dict[str, Any], list[Any]]:
- values: dict[str, Any] = {}
- errors: list[dict[str, Any]] = []
-
- if not fields:
- return values, errors
-
- first_field = fields[0]
- fields_to_extract = fields
- single_not_embedded_field = False
- default_convert_underscores = True
- if len(fields) == 1 and lenient_issubclass(
- first_field.field_info.annotation, BaseModel
- ):
- fields_to_extract = get_cached_model_fields(first_field.field_info.annotation)
- single_not_embedded_field = True
- # If headers are in a Pydantic model, the way to disable convert_underscores
- # would be with Header(convert_underscores=False) at the Pydantic model level
- default_convert_underscores = getattr(
- first_field.field_info, "convert_underscores", True
- )
-
+def _request_param_model_to_args(
+ model_field: ModelField,
+ received_params: Mapping[str, Any],
+ known_param_names: set[str],
+) -> tuple[Any, list[Any]]:
+ model = cast(type[BaseModel], model_field.field_info.annotation)
+ fields_to_extract = get_cached_model_fields(model)
+ default_convert_underscores = getattr(
+ model_field.field_info, "convert_underscores", True
+ )
params_to_process: dict[str, Any] = {}
header_aliases: dict[str, str] = {}
processed_keys = set()
+ own_names: set[str] = set()
for field in fields_to_extract:
convert_underscores = isinstance(received_params, Headers) and getattr(
field.field_info, "convert_underscores", default_convert_underscores
)
aliases = _get_param_aliases(field, convert_underscores=convert_underscores)
+ own_names.update(
+ name.lower() if isinstance(received_params, Headers) else name
+ for _, name in aliases
+ )
alias, request_alias = next(
(pair for pair in aliases if pair[1] in received_params), aliases[0]
)
@@ -866,8 +915,12 @@ def request_params_to_args(
else:
processed_keys.add(request_alias)
+ # Parameters declared elsewhere are not extras of this model. Keep unknown
+ # inputs and unused aliases of its own fields for Pydantic to validate.
for key in received_params.keys():
- if key not in processed_keys:
+ if key not in processed_keys and (
+ key not in known_param_names or key in own_names
+ ):
if isinstance(received_params, (ImmutableMultiDict, Headers)):
value = received_params.getlist(key)
if isinstance(value, list) and (len(value) == 1):
@@ -877,43 +930,58 @@ def request_params_to_args(
else:
params_to_process[key] = received_params.get(key)
- if single_not_embedded_field:
- field_info = first_field.field_info
- assert isinstance(field_info, params.Param), (
- "Params must be subclasses of Param"
- )
- loc: tuple[str, ...] = (field_info.in_.value,)
- v_, errors_ = _validate_value_with_model_field(
- field=first_field, value=params_to_process, values=values, loc=loc
- )
- if header_aliases and cast(
- type[BaseModel], first_field.field_info.annotation
- ).model_config.get("loc_by_alias", True):
- # Report the header names without changing model aliases or schema.
- for error in errors_:
- error_loc = error["loc"]
- if len(error_loc) > 1 and error_loc[1] in header_aliases:
- error["loc"] = (
- error_loc[0],
- header_aliases[error_loc[1]],
- *error_loc[2:],
- )
- return {first_field.name: v_}, errors_
+ field_info = model_field.field_info
+ assert isinstance(field_info, params.Param), "Params must be subclasses of Param"
+ loc: tuple[str, ...] = (field_info.in_.value,)
+ v_, errors_ = _validate_value_with_model_field(
+ field=model_field, value=params_to_process, values={}, loc=loc
+ )
+ if header_aliases and model.model_config.get("loc_by_alias", True):
+ # Report the header names without changing model aliases or schema.
+ for error in errors_:
+ error_loc = error["loc"]
+ if len(error_loc) > 1 and error_loc[1] in header_aliases:
+ error["loc"] = (
+ error_loc[0],
+ header_aliases[error_loc[1]],
+ *error_loc[2:],
+ )
+ return v_, errors_
+
+def request_params_to_args(
+ fields: Sequence[ModelField],
+ received_params: Mapping[str, Any] | QueryParams | Headers,
+ *,
+ known_param_names: set[str] | None = None,
+) -> tuple[dict[str, Any], list[Any]]:
+ values: dict[str, Any] = {}
+ errors: list[Any] = []
+ if not fields:
+ return values, errors
+ if known_param_names is None:
+ known_param_names = set()
for field in fields:
- aliases = _get_param_aliases(field)
- _, alias = next(
- (pair for pair in aliases if pair[1] in received_params), aliases[0]
- )
- value = _get_multidict_value(field, received_params, alias=alias)
- field_info = field.field_info
- assert isinstance(field_info, params.Param), (
- "Params must be subclasses of Param"
- )
- loc = (field_info.in_.value, alias)
- v_, errors_ = _validate_value_with_model_field(
- field=field, value=value, values=values, loc=loc
- )
+ if lenient_issubclass(
+ field.field_info.annotation, BaseModel
+ ) and not _is_json_field(field):
+ v_, errors_ = _request_param_model_to_args(
+ field, received_params, known_param_names
+ )
+ else:
+ aliases = _get_param_aliases(field)
+ _, alias = next(
+ (pair for pair in aliases if pair[1] in received_params), aliases[0]
+ )
+ value = _get_multidict_value(field, received_params, alias=alias)
+ field_info = field.field_info
+ assert isinstance(field_info, params.Param), (
+ "Params must be subclasses of Param"
+ )
+ loc = (field_info.in_.value, alias)
+ v_, errors_ = _validate_value_with_model_field(
+ field=field, value=value, values=values, loc=loc
+ )
if errors_:
errors.extend(errors_)
else:
diff --git a/fastapi/openapi/utils.py b/fastapi/openapi/utils.py
index aec55ae0..31d1ee5f 100644
--- a/fastapi/openapi/utils.py
+++ b/fastapi/openapi/utils.py
@@ -42,7 +42,6 @@ from fastapi.utils import (
generate_operation_id_for_path,
is_body_allowed_for_status_code,
)
-from pydantic import BaseModel
from starlette.responses import JSONResponse
from starlette.routing import BaseRoute
@@ -166,60 +165,51 @@ def _get_openapi_operation_parameters(
separate_input_output_schemas: bool = True,
) -> list[dict[str, Any]]:
parameters = []
- path_params = _get_flat_fields_from_params(dependency_data.path_params)
- query_params = _get_flat_fields_from_params(dependency_data.query_params)
- header_params = _get_flat_fields_from_params(dependency_data.header_params)
- cookie_params = _get_flat_fields_from_params(dependency_data.cookie_params)
parameter_groups = [
- (ParamTypes.path, path_params),
- (ParamTypes.query, query_params),
- (ParamTypes.header, header_params),
- (ParamTypes.cookie, cookie_params),
+ (ParamTypes.path, dependency_data.path_params),
+ (ParamTypes.query, dependency_data.query_params),
+ (ParamTypes.header, dependency_data.header_params),
+ (ParamTypes.cookie, dependency_data.cookie_params),
]
- default_convert_underscores = True
- if len(dependency_data.header_params) == 1:
- first_field = dependency_data.header_params[0]
- if lenient_issubclass(first_field.field_info.annotation, BaseModel):
- default_convert_underscores = getattr(
- first_field.field_info, "convert_underscores", True
- )
for param_type, param_group in parameter_groups:
- for param in param_group:
- field_info = param.field_info
- # field_info = cast(Param, field_info)
- if not getattr(field_info, "include_in_schema", True):
+ for parent in param_group:
+ if not getattr(parent.field_info, "include_in_schema", True):
continue
- convert_underscores = param_type == ParamTypes.header and getattr(
- field_info, "convert_underscores", default_convert_underscores
- )
- alias, name = _get_param_aliases(
- param, convert_underscores=convert_underscores
- )[0]
- param_schema = get_schema_from_model_field(
- field=param,
- model_name_map=model_name_map,
- field_mapping=field_mapping,
- separate_input_output_schemas=separate_input_output_schemas,
- field_alias=alias,
- )
+ for param in _get_flat_fields_from_params([parent]):
+ field_info = param.field_info
+ convert_underscores = param_type == ParamTypes.header and getattr(
+ field_info,
+ "convert_underscores",
+ getattr(parent.field_info, "convert_underscores", True),
+ )
+ alias, name = _get_param_aliases(
+ param, convert_underscores=convert_underscores
+ )[0]
+ param_schema = get_schema_from_model_field(
+ field=param,
+ model_name_map=model_name_map,
+ field_mapping=field_mapping,
+ separate_input_output_schemas=separate_input_output_schemas,
+ field_alias=alias,
+ )
- parameter = {
- "name": name,
- "in": param_type.value,
- "required": param.field_info.is_required(),
- "schema": param_schema,
- }
- if field_info.description:
- parameter["description"] = field_info.description
- openapi_examples = getattr(field_info, "openapi_examples", None)
- example = getattr(field_info, "example", None)
- if openapi_examples:
- parameter["examples"] = jsonable_encoder(openapi_examples)
- elif example is not _Unset:
- parameter["example"] = jsonable_encoder(example)
- if getattr(field_info, "deprecated", None):
- parameter["deprecated"] = True
- parameters.append(parameter)
+ parameter = {
+ "name": name,
+ "in": param_type.value,
+ "required": param.field_info.is_required(),
+ "schema": param_schema,
+ }
+ if field_info.description:
+ parameter["description"] = field_info.description
+ openapi_examples = getattr(field_info, "openapi_examples", None)
+ example = getattr(field_info, "example", None)
+ if openapi_examples:
+ parameter["examples"] = jsonable_encoder(openapi_examples)
+ elif example is not _Unset:
+ parameter["example"] = jsonable_encoder(example)
+ if getattr(field_info, "deprecated", None):
+ parameter["deprecated"] = True
+ parameters.append(parameter)
return parameters
diff --git a/fastapi/routing.py b/fastapi/routing.py
index a3f8043c..9a14ebf6 100644
--- a/fastapi/routing.py
+++ b/fastapi/routing.py
@@ -60,6 +60,7 @@ from fastapi.dependencies.utils import (
SolvedDependency,
_get_body_field,
_get_flat_body_params,
+ _get_request_param_names,
_should_embed_body_fields,
get_dependant,
get_parameterless_sub_dependant,
@@ -917,6 +918,7 @@ def _build_dependant_with_parameterless_dependencies(
0,
get_parameterless_sub_dependant(depends=depends, path=path),
)
+ dependant._request_param_names = _get_request_param_names(dependant)
body_params = _get_flat_body_params(dependant)
embed_body_fields = _should_embed_body_fields(body_params)
return dependant, body_params, embed_body_fields