fastapi_5624

        errors: List[Any] = []
        if response is None:
            response = Response()
            del response.headers["content-length"]
            response.status_code = None  # type: ignore
        if dependency_cache is None:
            dependency_cache = {}
        for sub_dependant in dependant.dependencies:
            sub_dependant.call = cast(Callable[..., Any], sub_dependant.call)
            call = sub_dependant.call
            use_sub_dependant = sub_dependant
            if (
                dependency_overrides_provider
                and dependency_overrides_provider.dependency_overrides
            ):
                original_call = sub_dependant.call
                call = getattr(
                    dependency_overrides_provider, "dependency_overrides", {}
                ).get(original_call, original_call)
                use_path: str = sub_dependant.path  # type: ignore
                use_sub_dependant = get_dependant(
                    path=use_path,
                    call=call,
                    name=sub_dependant.name,
                    security_scopes=sub_dependant.security_scopes,
                    scope=sub_dependant.scope,
                )
    
            solved_result = await solve_dependencies(
                request=request,
                dependant=use_sub_dependant,
                body=body,
                background_tasks=background_tasks,
                response=response,
                dependency_overrides_provider=dependency_overrides_provider,
                dependency_cache=dependency_cache,
                async_exit_stack=async_exit_stack,
                embed_body_fields=embed_body_fields,
            )
            background_tasks = solved_result.background_tasks
            if solved_result.errors:
                errors.extend(solved_result.errors)
                continue
            if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:
                solved = dependency_cache[sub_dependant.cache_key]
            elif (
                use_sub_dependant.is_gen_callable or use_sub_dependant.is_async_gen_callable
            ):
                use_astack = request_astack
                if sub_dependant.scope == "function":
                    use_astack = function_astack
                solved = await _solve_generator(
                    dependant=use_sub_dependant,
                    stack=use_astack,
                    sub_values=solved_result.values,
                )
            elif use_sub_dependant.is_coroutine_callable:
                solved = await call(**solved_result.values)
            else:
                solved = await run_in_threadpool(call, **solved_result.values)
            if sub_dependant.name is not None:
                values[sub_dependant.name] = solved
            if sub_dependant.cache_key not in dependency_cache:
                dependency_cache[sub_dependant.cache_key] = solved
        path_values, path_errors = request_params_to_args(
            dependant.path_params, request.path_params
        )
        query_values, query_errors = request_params_to_args(
            dependant.query_params, request.query_params
        )
        header_values, header_errors = request_params_to_args(
            dependant.header_params, request.headers
        )
        cookie_values, cookie_errors = request_params_to_args(
            dependant.cookie_params, request.cookies
        )
        values.update(path_values)
        values.update(query_values)
        values.update(header_values)
        values.update(cookie_values)
        errors += path_errors + query_errors + header_errors + cookie_errors
        if dependant.body_params:
            (
                body_values,
                body_errors,
            ) = await request_body_to_args(  # body_params checked above
                body_fields=dependant.body_params,
                received_body=body,
                embed_body_fields=embed_body_fields,
            )
            values.update(body_values)
            errors.extend(body_errors)
        if dependant.http_connection_param_name:
            values[dependant.http_connection_param_name] = request
        if dependant.request_param_name and isinstance(request, Request):
            values[dependant.request_param_name] = request
        elif dependant.websocket_param_name and isinstance(request, WebSocket):
            values[dependant.websocket_param_name] = request
        if dependant.background_tasks_param_name:
            if background_tasks is None:
                background_tasks = BackgroundTasks()
            values[dependant.background_tasks_param_name] = background_tasks
        if dependant.response_param_name:
            values[dependant.response_param_name] = response
        if dependant.security_scopes_param_name:
            # Use the scopes from the dependant, but also include scopes from the parent dependants
            # to support hierarchical security scope propagation.
            scopes = set(dependant.security_scopes)
>           for parent_dependant in dependant.parent_dependants:
                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
E           AttributeError: 'Dependant' object has no attribute 'parent_dependants'

fastapi/dependencies/utils.py:696: AttributeError
=============================== warnings summary ===============================
../../../../../../kaggle/tmp/envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py:45
  /kaggle/tmp/envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py:45: DeprecationWarning: The anyio.abc.BlockingPortal alias is deprecated, use anyio.from_thread.BlockingPortal instead.
    _PortalFactoryType = Callable[[], AbstractContextManager[anyio.abc.BlockingPortal]]

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed, 1 warning in 0.90s