fastapi_5624

{"status": "ok", "stdout": "./docs/en/docs/advanced/security/oauth2-scopes.md:133:But by using `Security` instead of `Depends`, **FastAPI** will know that it can declare security scopes, use them internally, and document the API with OpenAPI.\n./docs/en/docs/advanced/security/oauth2-scopes.md:147:Because this dependency function doesn't have any scope requirements itself, we can use `Depends` with `oauth2_scheme`, we don't have to use `Security` when we don't need to specify security scopes.\n./docs/en/docs/advanced/security/oauth2-scopes.md:230:It will always have the security scopes declared in the current `Security` dependencies and all the dependants for **that specific** *path operation* and **that specific** dependency tree.\n./docs/en/docs/release-notes.md:5096:* Fix testing OAuth2 security scopes when using dependency overrides. PR [#1549](https://github.com/tiangolo/fastapi/pull/1549) by [@amacfie](https://github.com/amacfie).\n./docs/ru/docs/advanced/security/oauth2-scopes.md:133:\u041d\u043e \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u044f `Security` \u0432\u043c\u0435\u0441\u0442\u043e `Depends`, **FastAPI** \u0431\u0443\u0434\u0435\u0442 \u0437\u043d\u0430\u0442\u044c, \u0447\u0442\u043e \u043c\u043e\u0436\u043d\u043e \u043e\u0431\u044a\u044f\u0432\u043b\u044f\u0442\u044c security scopes, \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c \u0438\u0445 \u0432\u043d\u0443\u0442\u0440\u0438 \u0438 \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0438\u0440\u043e\u0432\u0430\u0442\u044c API \u0432 OpenAPI.\n./docs/ru/docs/advanced/security/oauth2-scopes.md:147:\u041f\u043e\u0441\u043a\u043e\u043b\u044c\u043a\u0443 \u0443 \u044d\u0442\u043e\u0439 \u0444\u0443\u043d\u043a\u0446\u0438\u0438\u2011\u0437\u0430\u0432\u0438\u0441\u0438\u043c\u043e\u0441\u0442\u0438 \u043d\u0435\u0442 \u0441\u043e\u0431\u0441\u0442\u0432\u0435\u043d\u043d\u044b\u0445 \u0442\u0440\u0435\u0431\u043e\u0432\u0430\u043d\u0438\u0439 \u043f\u043e scopes, \u043

{"status": "ok", "stdout": "./fastapi/dependencies/utils.py:130:    if isinstance(depends, params.Security) and depends.scopes:\n./fastapi/dependencies/utils.py:693:        values[dependant.security_scopes_param_name] = SecurityScopes(\n./fastapi/param_functions.py:2318:            OAuth2 scopes required for the *path operation* that uses this Security\n./fastapi/param_functions.py:2376:        current_user: Annotated[User, Security(get_current_active_user, scopes=[\"items\"])]\n./fastapi/param_functions.py:2381:    return params.Security(dependency=dependency, scopes=scopes, use_cache=use_cache)\n./tests/test_dependency_security_overrides.py:10:def get_user(required_scopes: SecurityScopes):\n./tests/test_dependency_security_overrides.py:14:def get_user_override(required_scopes: SecurityScopes):\n./tests/test_dependency_security_overrides.py:28:    user_data: Tuple[str, List[str]] = Security(get_user, scopes=[\"foo\", \"bar\"]),\n./tests/test_dependency_paramless.py:18:    security_scopes: SecurityScopes,\n./tests/test_dependency_paramless.py:31:    credentials: Annotated[dict, Security(process_auth, scopes=[\"a\", \"b\"])],\n./tests/test_dependency_paramless.py:38:    dependencies=[Security(process_auth, scopes=[\"a\", \"b\"])],\n./tests/test_dependency_cache.py:41:    scope_count_1: int = Security(dep_counter, scopes=[\"scope\"]),\n./tests/test_dependency_cache.py:42:    scope_count_2: int = Security(dep_counter, scopes=[\"scope\"]),\n./docs/es/docs/advanced/security/oauth2-scopes.md:107:Para esto, importamos y usamos `Security` de `fastapi`.\n./docs/es/docs/advanced/security/oauth2-scopes.md:109:Puedes usar `Security` para declarar dependencias (igual que `Depends`), pero `Security` tambi\u00e9n recibe un par\u00e1metro `scopes` con una lista de scopes (strings).\n./docs/es/docs/advanced/security/oauth2-scopes.md:111:En este caso, pasamos una funci\u00f3n de dependencia `get_current_active_user` a `Security` (de la misma manera que har\u00edamos con `Depends`).\n

{"status": "ok", "stdout": "./fastapi/dependencies/utils.py:61:from fastapi.security.oauth2 import OAuth2, SecurityScopes\n./fastapi/dependencies/utils.py:329:    elif lenient_issubclass(type_annotation, SecurityScopes):\n./fastapi/dependencies/utils.py:443:            SecurityScopes,\n./fastapi/dependencies/utils.py:693:        values[dependant.security_scopes_param_name] = SecurityScopes(\n./fastapi/security/__init__.py:14:from .oauth2 import SecurityScopes as SecurityScopes\n./fastapi/security/oauth2.py:626:class SecurityScopes:\n./tests/test_dependency_security_overrides.py:4:from fastapi.security import SecurityScopes\n./tests/test_dependency_security_overrides.py:10:def get_user(required_scopes: SecurityScopes):\n./tests/test_dependency_security_overrides.py:14:def get_user_override(required_scopes: SecurityScopes):\n./tests/test_dependency_paramless.py:6:    SecurityScopes,\n./tests/test_dependency_paramless.py:18:    security_scopes: SecurityScopes,\n./docs/es/docs/advanced/security/oauth2-scopes.md:139:## Usar `SecurityScopes`\n./docs/es/docs/advanced/security/oauth2-scopes.md:149:Tambi\u00e9n declaramos un par\u00e1metro especial de tipo `SecurityScopes`, importado de `fastapi.security`.\n./docs/es/docs/advanced/security/oauth2-scopes.md:151:Esta clase `SecurityScopes` es similar a `Request` (`Request` se us\u00f3 para obtener el objeto request directamente).\n./docs/es/docs/advanced/security/oauth2-scopes.md:157:El par\u00e1metro `security_scopes` ser\u00e1 del tipo `SecurityScopes`.\n./docs/es/docs/advanced/security/oauth2-scopes.md:161:El objeto `security_scopes` (de la clase `SecurityScopes`) tambi\u00e9n proporciona un atributo `scope_str` con un \u00fanico string, que contiene esos scopes separados por espacios (lo vamos a usar).\n./docs/es/docs/advanced/security/oauth2-scopes.md:212:                    * Un par\u00e1metro `security_scopes` de tipo `SecurityScopes`:\n./docs/es/docs/advanced/security/oauth2-scopes.md:226:## M\u00e1s detalles sobre `Se

{"status": "ok", "stdout": "import dataclasses\nimport inspect\nfrom contextlib import AsyncExitStack, contextmanager\nfrom copy import copy, deepcopy\nfrom dataclasses import dataclass\nfrom typing import (\n    Any,\n    Callable,\n    Coroutine,\n    Dict,\n    ForwardRef,\n    List,\n    Mapping,\n    Optional,\n    Sequence,\n    Tuple,\n    Type,\n    Union,\n    cast,\n)\n\nimport anyio\nfrom fastapi import params\nfrom fastapi._compat import (\n    PYDANTIC_V2,\n    ModelField,\n    RequiredParam,\n    Undefined,\n    _is_error_wrapper,\n    _is_model_class,\n    copy_field_info,\n    create_body_model,\n    evaluate_forwardref,\n    field_annotation_is_scalar,\n    get_annotation_from_field_info,\n    get_cached_model_fields,\n    get_missing_field_error,\n    is_bytes_field,\n    is_bytes_sequence_field,\n    is_scalar_field,\n    is_scalar_sequence_field,\n    is_sequence_field,\n    is_uploadfile_or_nonable_uploadfile_annotation,\n    is_uploadfile_sequence_annotation,\n    lenient_issubclass,\n    may_v1,\n    sequence_types,\n    serialize_sequence_value,\n    value_is_sequence,\n)\nfrom fastapi._compat.shared import annotation_is_pydantic_v1\nfrom fastapi.background import BackgroundTasks\nfrom fastapi.concurrency import (\n    asynccontextmanager,\n    contextmanager_in_threadpool,\n)\nfrom fastapi.dependencies.models import Dependant, SecurityRequirement\nfrom fastapi.exceptions import DependencyScopeError\nfrom fastapi.logger import logger\nfrom fastapi.security.base import SecurityBase\nfrom fastapi.security.oauth2 import OAuth2, SecurityScopes\nfrom fastapi.security.open_id_connect_url import OpenIdConnect\nfrom fastapi.types import DependencyCacheKey\nfrom fastapi.utils import create_model_field, get_path_param_names\nfrom pydantic import BaseModel\nfrom pydantic.fields import FieldInfo\nfrom starlette.background import BackgroundTasks as StarletteBackgroundTasks\nfrom starlette.concurrency import run_in_threadpool\nfrom starlette.datastructures

{"status": "ok", "stdout": "330:        dependant.security_scopes_param_name = param_name\n692:    if dependant.security_scopes_param_name:\n693:        values[dependant.security_scopes_param_name] = SecurityScopes(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    if dependant.http_connection_param_name:\n        values[dependant.http_connection_param_name] = request\n    if dependant.request_param_name and isinstance(request, Request):\n        values[dependant.request_param_name] = request\n    elif dependant.websocket_param_name and isinstance(request, WebSocket):\n        values[dependant.websocket_param_name] = request\n    if dependant.background_tasks_param_name:\n        if background_tasks is None:\n            background_tasks = BackgroundTasks()\n        values[dependant.background_tasks_param_name] = background_tasks\n    if dependant.response_param_name:\n        values[dependant.response_param_name] = response\n    if dependant.security_scopes_param_name:\n        values[dependant.security_scopes_param_name] = SecurityScopes(\n            scopes=dependant.security_scopes\n        )\n    return SolvedDependency(\n        values=values,\n        errors=errors,\n        background_tasks=background_tasks,\n        response=response,\n        dependency_cache=dependency_cache,\n    )\n\n\ndef _validate_value_with_model_field(\n    *, field: ModelField, value: Any, values: Dict[str, Any], loc: Tuple[str, ...]\n) -> Tuple[Any, List[Any]]:\n    if value is None:\n        if field.required:\n            return None, [get_missing_field_error(loc=loc)]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "129:    use_security_scopes: List[str] = []\n131:        use_security_scopes.extend(depends.scopes)\n136:        security_scopes=use_security_scopes,\n235:    security_scopes: Optional[List[str]] = None,\n243:        security_scopes=security_scopes,\n253:            use_scopes = security_scopes or use_scopes\n278:            use_security_scopes = security_scopes or []\n281:                    use_security_scopes.extend(param_details.depends.scopes)\n286:                security_scopes=use_security_scopes,\n330:        dependant.security_scopes_param_name = param_name\n612:                security_scopes=sub_dependant.security_scopes,\n692:    if dependant.security_scopes_param_name:\n693:        values[dependant.security_scopes_param_name] = SecurityScopes(\n694:            scopes=dependant.security_scopes\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            dependency_overrides_provider\n            and dependency_overrides_provider.dependency_overrides\n        ):\n            original_call = sub_dependant.call\n            call = getattr(\n                dependency_overrides_provider, \"dependency_overrides\", {}\n            ).get(original_call, original_call)\n            use_path: str = sub_dependant.path  # type: ignore\n            use_sub_dependant = get_dependant(\n                path=use_path,\n                call=call,\n                name=sub_dependant.name,\n                security_scopes=sub_dependant.security_scopes,\n                scope=sub_dependant.scope,\n            )\n\n        solved_result = await solve_dependencies(\n            request=request,\n            dependant=use_sub_dependant,\n            body=body,\n            background_tasks=background_tasks,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "565:async def solve_dependencies(\n616:        solved_result = await solve_dependencies(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "async def solve_dependencies(\n    *,\n    request: Union[Request, WebSocket],\n    dependant: Dependant,\n    body: Optional[Union[Dict[str, Any], FormData]] = None,\n    background_tasks: Optional[StarletteBackgroundTasks] = None,\n    response: Optional[Response] = None,\n    dependency_overrides_provider: Optional[Any] = None,\n    dependency_cache: Optional[Dict[DependencyCacheKey, Any]] = None,\n    # TODO: remove this parameter later, no longer used, not removing it yet as some\n    # people might be monkey patching this function (although that's not supported)\n    async_exit_stack: AsyncExitStack,\n    embed_body_fields: bool,\n) -> SolvedDependency:\n    request_astack = request.scope.get(\"fastapi_inner_astack\")\n    assert isinstance(request_astack, AsyncExitStack), (\n        \"fastapi_inner_astack not found in request scope\"\n    )\n    function_astack = request.scope.get(\"fastapi_function_astack\")\n    assert isinstance(function_astack, AsyncExitStack), (\n        \"fastapi_function_astack not found in request scope\"\n    )\n    values: Dict[str, Any] = {}\n    errors: List[Any] = []\n    if response is None:\n        response = Response()\n        del response.headers[\"content-length\"]\n        response.status_code = None  # type: ignore\n    if dependency_cache is None:\n        dependency_cache = {}\n    for sub_dependant in dependant.dependencies:\n        sub_dependant.call = cast(Callable[..., Any], sub_dependant.call)\n        call = sub_dependant.call\n        use_sub_dependant = sub_dependant\n        if (\n            dependency_overrides_provider\n            and dependency_overrides_provider.dependency_overrides\n        ):\n            original_call = sub_dependant.call\n            call = getattr(\n                dependency_overrides_provider, \"dependency_overrides\", {}\n            ).get(original_call, original_call)\n            use_path: str = sub_dependant.path  # type: ignore\n            use_su

{"status": "ok", "stdout": "    if dependant.http_connection_param_name:\n        values[dependant.http_connection_param_name] = request\n    if dependant.request_param_name and isinstance(request, Request):\n        values[dependant.request_param_name] = request\n    elif dependant.websocket_param_name and isinstance(request, WebSocket):\n        values[dependant.websocket_param_name] = request\n    if dependant.background_tasks_param_name:\n        if background_tasks is None:\n            background_tasks = BackgroundTasks()\n        values[dependant.background_tasks_param_name] = background_tasks\n    if dependant.response_param_name:\n        values[dependant.response_param_name] = response\n    if dependant.security_scopes_param_name:\n        values[dependant.security_scopes_param_name] = SecurityScopes(\n            scopes=dependant.security_scopes\n        )\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "129:    use_security_scopes: List[str] = []\n131:        use_security_scopes.extend(depends.scopes)\n136:        security_scopes=use_security_scopes,\n235:    security_scopes: Optional[List[str]] = None,\n243:        security_scopes=security_scopes,\n253:            use_scopes = security_scopes or use_scopes\n278:            use_security_scopes = security_scopes or []\n281:                    use_security_scopes.extend(param_details.depends.scopes)\n286:                security_scopes=use_security_scopes,\n612:                security_scopes=sub_dependant.security_scopes,\n694:            scopes=dependant.security_scopes\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_dependant(\n    *,\n    path: str,\n    call: Callable[..., Any],\n    name: Optional[str] = None,\n    security_scopes: Optional[List[str]] = None,\n    use_cache: bool = True,\n    scope: Union[Literal[\"function\", \"request\"], None] = None,\n) -> Dependant:\n    dependant = Dependant(\n        call=call,\n        name=name,\n        path=path,\n        security_scopes=security_scopes,\n        use_cache=use_cache,\n        scope=scope,\n    )\n    path_param_names = get_path_param_names(path)\n    endpoint_signature = get_typed_signature(call)\n    signature_params = endpoint_signature.parameters\n    if isinstance(call, SecurityBase):\n        use_scopes: List[str] = []\n        if isinstance(call, (OAuth2, OpenIdConnect)):\n            use_scopes = security_scopes or use_scopes\n        security_requirement = SecurityRequirement(\n            security_scheme=call, scopes=use_scopes\n        )\n        dependant.security_requirements.append(security_requirement)\n    for param_name, param in signature_params.items():\n        is_path_param = param_name in path_param_names\n        param_details = analyze_param(\n            param_name=param_name,\n            annotation=param.annotation,\n            value=param.default,\n            is_path_param=is_path_param,\n        )\n        if param_details.depends is not None:\n            assert param_details.depends.dependency\n            if (\n                (dependant.is_gen_callable or dependant.is_async_gen_callable)\n                and dependant.computed_scope == \"request\"\n                and param_details.depends.scope == \"function\"\n            ):\n                assert dependant.call\n                raise DependencyScopeError(\n                    f'The dependency \"{dependant.call.__name__}\" has a scope of '\n                    '\"request\", it cannot depend on dependencies with scope \"function\".'\n                )\n            use_security_scopes = securit

{"status": "ok", "stdout": "626:class SecurityScopes:\n627-    \"\"\"\n628-    This is a special class that you can define in a parameter in a dependency to\n629-    obtain the OAuth2 scopes required by all the dependencies in the same chain.\n630-\n631-    This way, multiple dependencies can have different scopes, even when used in the\n632-    same *path operation*. And with this, you can access all the scopes required in\n633-    all those dependencies in a single place.\n634-\n635-    Read more about it in the\n636-    [FastAPI docs for OAuth2 scopes](https://fastapi.tiangolo.com/advanced/security/oauth2-scopes/).\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "class SecurityScopes:\n    \"\"\"\n    This is a special class that you can define in a parameter in a dependency to\n    obtain the OAuth2 scopes required by all the dependencies in the same chain.\n\n    This way, multiple dependencies can have different scopes, even when used in the\n    same *path operation*. And with this, you can access all the scopes required in\n    all those dependencies in a single place.\n\n    Read more about it in the\n    [FastAPI docs for OAuth2 scopes](https://fastapi.tiangolo.com/advanced/security/oauth2-scopes/).\n    \"\"\"\n\n    def __init__(\n        self,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n    def __init__(\n        self,\n        scopes: Annotated[\n            Optional[List[str]],\n            Doc(\n                \"\"\"\n                This will be filled by FastAPI.\n                \"\"\"\n            ),\n        ] = None,\n    ):\n        self.scopes: Annotated[\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                This will be filled by FastAPI.\n                \"\"\"\n            ),\n        ] = None,\n    ):\n        self.scopes: Annotated[\n            List[str],\n            Doc(\n                \"\"\"\n                The list of all the scopes required by dependencies.\n                \"\"\"\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                \"\"\"\n            ),\n        ] = scopes or []\n        self.scope_str: Annotated[\n            str,\n            Doc(\n                \"\"\"\n                All the scopes required by all the dependencies in a single string\n                separated by spaces, as defined in the OAuth2 specification.\n                \"\"\"\n            ),\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            ),\n        ] = \" \".join(self.scopes)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "25:class Dependant:\n26-    path_params: List[ModelField] = field(default_factory=list)\n27-    query_params: List[ModelField] = field(default_factory=list)\n28-    header_params: List[ModelField] = field(default_factory=list)\n29-    cookie_params: List[ModelField] = field(default_factory=list)\n30-    body_params: List[ModelField] = field(default_factory=list)\n31-    dependencies: List[\"Dependant\"] = field(default_factory=list)\n32-    security_requirements: List[SecurityRequirement] = field(default_factory=list)\n33-    name: Optional[str] = None\n34-    call: Optional[Callable[..., Any]] = None\n35-    request_param_name: Optional[str] = None\n36-    websocket_param_name: Optional[str] = None\n37-    http_connection_param_name: Optional[str] = None\n38-    response_param_name: Optional[str] = None\n39-    background_tasks_param_name: Optional[str] = None\n40-    security_scopes_param_name: Optional[str] = None\n41-    security_scopes: Optional[List[str]] = None\n42-    use_cache: bool = True\n43-    path: Optional[str] = None\n44-    scope: Union[Literal[\"function\", \"request\"], None] = None\n45-\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "129:    use_security_scopes: List[str] = []\n131:        use_security_scopes.extend(depends.scopes)\n136:        security_scopes=use_security_scopes,\n235:    security_scopes: Optional[List[str]] = None,\n243:        security_scopes=security_scopes,\n253:            use_scopes = security_scopes or use_scopes\n278:            use_security_scopes = security_scopes or []\n281:                    use_security_scopes.extend(param_details.depends.scopes)\n286:                security_scopes=use_security_scopes,\n612:                security_scopes=sub_dependant.security_scopes,\n694:            scopes=dependant.security_scopes\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    if dependant.response_param_name:\n        values[dependant.response_param_name] = response\n    if dependant.security_scopes_param_name:\n        values[dependant.security_scopes_param_name] = SecurityScopes(\n            scopes=dependant.security_scopes\n        )\n    return SolvedDependency(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "async def solve_dependencies(\n    *,\n    request: Union[Request, WebSocket],\n    dependant: Dependant,\n    body: Optional[Union[Dict[str, Any], FormData]] = None,\n    background_tasks: Optional[StarletteBackgroundTasks] = None,\n    response: Optional[Response] = None,\n    dependency_overrides_provider: Optional[Any] = None,\n    dependency_cache: Optional[Dict[DependencyCacheKey, Any]] = None,\n    # TODO: remove this parameter later, no longer used, not removing it yet as some\n    # people might be monkey patching this function (although that's not supported)\n    async_exit_stack: AsyncExitStack,\n    embed_body_fields: bool,\n) -> SolvedDependency:\n    request_astack = request.scope.get(\"fastapi_inner_astack\")\n    assert isinstance(request_astack, AsyncExitStack), (\n        \"fastapi_inner_astack not found in request scope\"\n    )\n    function_astack = request.scope.get(\"fastapi_function_astack\")\n    assert isinstance(function_astack, AsyncExitStack), (\n        \"fastapi_function_astack not found in request scope\"\n    )\n    values: Dict[str, Any] = {}\n    errors: List[Any] = []\n    if response is None:\n        response = Response()\n        del response.headers[\"content-length\"]\n        response.status_code = None  # type: ignore\n    if dependency_cache is None:\n        dependency_cache = {}\n    for sub_dependant in dependant.dependencies:\n        sub_dependant.call = cast(Callable[..., Any], sub_dependant.call)\n        call = sub_dependant.call\n        use_sub_dependant = sub_dependant\n        if (\n            dependency_overrides_provider\n            and dependency_overrides_provider.dependency_overrides\n        ):\n            original_call = sub_dependant.call\n            call = getattr(\n                dependency_overrides_provider, \"dependency_overrides\", {}\n            ).get(original_call, original_call)\n            use_path: str = sub_dependant.path  # type: ignore\n            use_su

{"status": "ok", "stdout": "                call=call,\n                name=sub_dependant.name,\n                security_scopes=sub_dependant.security_scopes,\n                scope=sub_dependant.scope,\n            )\n\n        solved_result = await solve_dependencies(\n            request=request,\n            dependant=use_sub_dependant,\n            body=body,\n            background_tasks=background_tasks,\n            response=response,\n            dependency_overrides_provider=dependency_overrides_provider,\n            dependency_cache=dependency_cache,\n            async_exit_stack=async_exit_stack,\n            embed_body_fields=embed_body_fields,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                dependant=use_sub_dependant,\n                stack=use_astack,\n                sub_values=solved_result.values,\n            )\n        elif use_sub_dependant.is_coroutine_callable:\n            solved = await call(**solved_result.values)\n        else:\n            solved = await run_in_threadpool(call, **solved_result.values)\n        if sub_dependant.name is not None:\n            values[sub_dependant.name] = solved\n        if sub_dependant.cache_key not in dependency_cache:\n            dependency_cache[sub_dependant.cache_key] = solved\n    path_values, path_errors = request_params_to_args(\n        dependant.path_params, request.path_params\n    )\n    query_values, query_errors = request_params_to_args(\n        dependant.query_params, request.query_params\n    )\n    header_values, header_errors = request_params_to_args(\n        dependant.header_params, request.headers\n    )\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    )\n    cookie_values, cookie_errors = request_params_to_args(\n        dependant.cookie_params, request.cookies\n    )\n    values.update(path_values)\n    values.update(query_values)\n    values.update(header_values)\n    values.update(cookie_values)\n    errors += path_errors + query_errors + header_errors + cookie_errors\n    if dependant.body_params:\n        (\n            body_values,\n            body_errors,\n        ) = await request_body_to_args(  # body_params checked above\n            body_fields=dependant.body_params,\n            received_body=body,\n            embed_body_fields=embed_body_fields,\n        )\n        values.update(body_values)\n        errors.extend(body_errors)\n    if dependant.http_connection_param_name:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    if dependant.http_connection_param_name:\n        values[dependant.http_connection_param_name] = request\n    if dependant.request_param_name and isinstance(request, Request):\n        values[dependant.request_param_name] = request\n    elif dependant.websocket_param_name and isinstance(request, WebSocket):\n        values[dependant.websocket_param_name] = request\n    if dependant.background_tasks_param_name:\n        if background_tasks is None:\n            background_tasks = BackgroundTasks()\n        values[dependant.background_tasks_param_name] = background_tasks\n    if dependant.response_param_name:\n        values[dependant.response_param_name] = response\n    if dependant.security_scopes_param_name:\n        values[dependant.security_scopes_param_name] = SecurityScopes(\n            scopes=dependant.security_scopes\n        )\n    return SolvedDependency(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "129:    use_security_scopes: List[str] = []\n131:        use_security_scopes.extend(depends.scopes)\n136:        security_scopes=use_security_scopes,\n235:    security_scopes: Optional[List[str]] = None,\n243:        security_scopes=security_scopes,\n253:            use_scopes = security_scopes or use_scopes\n278:            use_security_scopes = security_scopes or []\n281:                    use_security_scopes.extend(param_details.depends.scopes)\n286:                security_scopes=use_security_scopes,\n612:                security_scopes=sub_dependant.security_scopes,\n694:            scopes=dependant.security_scopes\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                and dependant.computed_scope == \"request\"\n                and param_details.depends.scope == \"function\"\n            ):\n                assert dependant.call\n                raise DependencyScopeError(\n                    f'The dependency \"{dependant.call.__name__}\" has a scope of '\n                    '\"request\", it cannot depend on dependencies with scope \"function\".'\n                )\n            use_security_scopes = security_scopes or []\n            if isinstance(param_details.depends, params.Security):\n                if param_details.depends.scopes:\n                    use_security_scopes.extend(param_details.depends.scopes)\n            sub_dependant = get_dependant(\n                path=path,\n                call=param_details.depends.dependency,\n                name=param_name,\n                security_scopes=use_security_scopes,\n                use_cache=param_details.depends.use_cache,\n                scope=param_details.depends.scope,\n            )\n            dependant.dependencies.append(sub_dependant)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            use_security_scopes = security_scopes or []\n            if isinstance(param_details.depends, params.Security):\n                if param_details.depends.scopes:\n                    use_security_scopes.extend(param_details.depends.scopes)\n            sub_dependant = get_dependant(\n                path=path,\n                call=param_details.depends.dependency,\n                name=param_name,\n                security_scopes=use_security_scopes,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            use_security_scopes = security_scopes or []\n            if isinstance(param_details.depends, params.Security):\n                if param_details.depends.scopes:\n                    use_security_scopes.extend(param_details.depends.scopes)\n", "stderr": "", "exit_code": 0}