fastapi_14448

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/models.py:4:from functools import cached_property, partial\nfastapi/_compat/main.py:2:from functools import lru_cache\nfastapi/routing.py:3:import functools\nfastapi/routing.py:92:        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/routing.py:65:from starlette._utils import is_async_callable\nfastapi/routing.py:92:        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "", "stderr": "grep: starlette: No such file or directory\n", "exit_code": 0}

{"status": "ok", "stdout": "./fastapi/routing.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/models.py:95:    def is_async_gen_callable(self) -> bool:\nfastapi/dependencies/models.py:114:        if self.is_gen_callable or self.is_async_gen_callable:\nfastapi/dependencies/utils.py:270:                (dependant.is_gen_callable or dependant.is_async_gen_callable)\nfastapi/dependencies/utils.py:553:    elif dependant.is_async_gen_callable:\nfastapi/dependencies/utils.py:636:            use_sub_dependant.is_gen_callable or use_sub_dependant.is_async_gen_callable\nfastapi/routing.py:65:from starlette._utils import is_async_callable\nfastapi/routing.py:92:        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        if self.call is None:\n            return self.call  # pragma: no cover\n        unwrapped = inspect.unwrap(self.call)\n        if isinstance(unwrapped, partial):\n            unwrapped = unwrapped.func\n        return unwrapped\n\n    @cached_property\n    def is_gen_callable(self) -> bool:\n        if inspect.isgeneratorfunction(self._unwrapped_call):\n            return True\n        dunder_call = getattr(self._unwrapped_call, \"__call__\", None)  # noqa: B004\n        return inspect.isgeneratorfunction(dunder_call)\n\n    @cached_property\n    def is_async_gen_callable(self) -> bool:\n        if inspect.isasyncgenfunction(self._unwrapped_call):\n            return True\n        dunder_call = getattr(self._unwrapped_call, \"__call__\", None)  # noqa: B004\n        return inspect.isasyncgenfunction(dunder_call)\n\n    @cached_property\n    def is_coroutine_callable(self) -> bool:\n        if inspect.isroutine(self._unwrapped_call):\n            return iscoroutinefunction(self._unwrapped_call)\n        if inspect.isclass(self._unwrapped_call):\n            return False\n        dunder_call = getattr(self._unwrapped_call, \"__call__\", None)  # noqa: B004\n        return iscoroutinefunction(dunder_call)\n\n    @cached_property\n    def computed_scope(self) -> Union[str, None]:\n        if self.scope:\n            return self.scope\n        if self.is_gen_callable or self.is_async_gen_callable:\n            return \"request\"\n        return None\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            return True\n        if self.security_scopes_param_name is not None:\n            return True\n        for sub_dep in self.dependencies:\n            if sub_dep._uses_scopes:\n                return True\n        return False\n\n    @cached_property\n    def _unwrapped_call(self) -> Any:\n        if self.call is None:\n            return self.call  # pragma: no cover\n        unwrapped = inspect.unwrap(self.call)\n        if isinstance(unwrapped, partial):\n            unwrapped = unwrapped.func\n        return unwrapped\n\n    @cached_property\n    def is_gen_callable(self) -> bool:\n        if inspect.isgeneratorfunction(self._unwrapped_call):\n            return True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/models.py:13:    from inspect import iscoroutinefunction\nfastapi/dependencies/models.py:15:    from asyncio import iscoroutinefunction\nfastapi/dependencies/models.py:104:            return iscoroutinefunction(self._unwrapped_call)\nfastapi/dependencies/models.py:108:        return iscoroutinefunction(dunder_call)\nfastapi/routing.py:132:    # assert asyncio.iscoroutinefunction(func), \"WebSocket endpoints must be async\"\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import inspect\nimport sys\nfrom dataclasses import dataclass, field\nfrom functools import cached_property, partial\nfrom typing import Any, Callable, List, Optional, Sequence, Union\n\nfrom fastapi._compat import ModelField\nfrom fastapi.security.base import SecurityBase\nfrom fastapi.types import DependencyCacheKey\nfrom typing_extensions import Literal\n\nif sys.version_info >= (3, 13):  # pragma: no cover\n    from inspect import iscoroutinefunction\nelse:  # pragma: no cover\n    from asyncio import iscoroutinefunction\n\n\n@dataclass\nclass SecurityRequirement:\n    security_scheme: SecurityBase\n    scopes: Optional[Sequence[str]] = None\n\n\n@dataclass\nclass Dependant:\n    path_params: List[ModelField] = field(default_factory=list)\n    query_params: List[ModelField] = field(default_factory=list)\n    header_params: List[ModelField] = field(default_factory=list)\n    cookie_params: List[ModelField] = field(default_factory=list)\n    body_params: List[ModelField] = field(default_factory=list)\n    dependencies: List[\"Dependant\"] = field(default_factory=list)\n    security_requirements: List[SecurityRequirement] = field(default_factory=list)\n    name: Optional[str] = None\n    call: Optional[Callable[..., Any]] = None\n    request_param_name: Optional[str] = None\n    websocket_param_name: Optional[str] = None\n    http_connection_param_name: Optional[str] = None\n    response_param_name: Optional[str] = None\n    background_tasks_param_name: Optional[str] = None\n    security_scopes_param_name: Optional[str] = None\n    own_oauth_scopes: Optional[List[str]] = None\n    parent_oauth_scopes: Optional[List[str]] = None\n    use_cache: bool = True\n    path: Optional[str] = None\n    scope: Union[Literal[\"function\", \"request\"], None] = None\n\n    @cached_property\n    def oauth_scopes(self) -> List[str]:\n        scopes = self.parent_oauth_scopes.copy() if self.parent_oauth_scopes else []\n        # This doesn't use a set to

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "65:from starlette._utils import is_async_callable\n92:        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:67:from starlette.concurrency import run_in_threadpool\nfastapi/dependencies/utils.py:649:            solved = await run_in_threadpool(call, **solved_result.values)\nfastapi/routing.py:66:from starlette.concurrency import run_in_threadpool\nfastapi/routing.py:92:        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\nfastapi/routing.py:240:            value, errors_ = await run_in_threadpool(\nfastapi/routing.py:286:        return await run_in_threadpool(dependant.call, **values)\nfastapi/concurrency.py:7:from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa\nfastapi/concurrency.py:27:        yield await run_in_threadpool(cm.__enter__)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "646:        elif use_sub_dependant.is_coroutine_callable:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        if solved_result.errors:\n            errors.extend(solved_result.errors)\n            continue\n        if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:\n            solved = dependency_cache[sub_dependant.cache_key]\n        elif (\n            use_sub_dependant.is_gen_callable or use_sub_dependant.is_async_gen_callable\n        ):\n            use_astack = request_astack\n            if sub_dependant.scope == \"function\":\n                use_astack = function_astack\n            solved = await _solve_generator(\n                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", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                use_astack = function_astack\n            solved = await _solve_generator(\n                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", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "7:        elif use_sub_dependant.is_coroutine_callable:\n8:            solved = await call(**solved_result.values)\n10:            solved = await run_in_threadpool(call, **solved_result.values)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        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_sub_dependant = get_dependant(\n                path=use_path,\n                call=call,\n                name=sub_dependant.name,\n                parent_oauth_scopes=sub_dependant.oauth_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        )\n        background_tasks = solved_result.background_tasks\n        if solved_result.errors:\n            errors.extend(solved_result.errors)\n            continue\n        if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:\n            solved = dependency_cache[sub_dependant.cache_key]\n        elif (\n            use_sub_dependant.is_gen_callable or use_sub_dependant.is_async_gen_callable\n        ):\n            use_astack = request_astack\n            if sub_dependant.scope == \"function\":\n                use_astack = function_astack\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            return True\n        if self.security_scopes_param_name is not None:\n            return True\n        for sub_dep in self.dependencies:\n            if sub_dep._uses_scopes:\n                return True\n        return False\n\n    @cached_property\n    def _unwrapped_call(self) -> Any:\n        if self.call is None:\n            return self.call  # pragma: no cover\n        unwrapped = inspect.unwrap(self.call)\n        if isinstance(unwrapped, partial):\n            unwrapped = unwrapped.func\n        return unwrapped\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./fastapi/routing.py:65:from starlette._utils import is_async_callable\n./fastapi/routing.py:92:        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./fastapi/dependencies/models.py:102:    def is_coroutine_callable(self) -> bool:\n./fastapi/dependencies/utils.py:646:        elif use_sub_dependant.is_coroutine_callable:\n./fastapi/routing.py:305:    is_coroutine = dependant.is_coroutine_callable\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    response_model_exclude_none: bool = False,\n    dependency_overrides_provider: Optional[Any] = None,\n    embed_body_fields: bool = False,\n) -> Callable[[Request], Coroutine[Any, Any, Response]]:\n    assert dependant.call is not None, \"dependant.call must be a function\"\n    is_coroutine = dependant.is_coroutine_callable\n    is_body_form = body_field and isinstance(\n        body_field.field_info, (params.Form, temp_pydantic_v1_params.Form)\n    )\n    if isinstance(response_class, DefaultPlaceholder):\n        actual_response_class: Type[Response] = response_class.value\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    dependant: Dependant,\n    body_field: Optional[ModelField] = None,\n    status_code: Optional[int] = None,\n    response_class: Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse),\n    response_field: Optional[ModelField] = None,\n    response_model_include: Optional[IncEx] = None,\n    response_model_exclude: Optional[IncEx] = None,\n    response_model_by_alias: bool = True,\n    response_model_exclude_unset: bool = False,\n    response_model_exclude_defaults: bool = False,\n    response_model_exclude_none: bool = False,\n    dependency_overrides_provider: Optional[Any] = None,\n    embed_body_fields: bool = False,\n) -> Callable[[Request], Coroutine[Any, Any, Response]]:\n    assert dependant.call is not None, \"dependant.call must be a function\"\n    is_coroutine = dependant.is_coroutine_callable\n    is_body_form = body_field and isinstance(\n        body_field.field_info, (params.Form, temp_pydantic_v1_params.Form)\n    )\n    if isinstance(response_class, DefaultPlaceholder):\n        actual_response_class: Type[Response] = response_class.value\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import inspect\nimport sys\nfrom dataclasses import dataclass, field\nfrom functools import cached_property, partial\nfrom typing import Any, Callable, List, Optional, Sequence, Union\n\nfrom fastapi._compat import ModelField\nfrom fastapi.security.base import SecurityBase\nfrom fastapi.types import DependencyCacheKey\nfrom typing_extensions import Literal\n\nif sys.version_info >= (3, 13):  # pragma: no cover\n    from inspect import iscoroutinefunction\nelse:  # pragma: no cover\n    from asyncio import iscoroutinefunction\n\n\n@dataclass\nclass SecurityRequirement:\n    security_scheme: SecurityBase\n    scopes: Optional[Sequence[str]] = None\n\n\n@dataclass\nclass Dependant:\n    path_params: List[ModelField] = field(default_factory=list)\n    query_params: List[ModelField] = field(default_factory=list)\n    header_params: List[ModelField] = field(default_factory=list)\n    cookie_params: List[ModelField] = field(default_factory=list)\n    body_params: List[ModelField] = field(default_factory=list)\n    dependencies: List[\"Dependant\"] = field(default_factory=list)\n    security_requirements: List[SecurityRequirement] = field(default_factory=list)\n    name: Optional[str] = None\n    call: Optional[Callable[..., Any]] = None\n    request_param_name: Optional[str] = None\n    websocket_param_name: Optional[str] = None\n    http_connection_param_name: Optional[str] = None\n    response_param_name: Optional[str] = None\n    background_tasks_param_name: Optional[str] = None\n    security_scopes_param_name: Optional[str] = None\n    own_oauth_scopes: Optional[List[str]] = None\n    parent_oauth_scopes: Optional[List[str]] = None\n    use_cache: bool = True\n    path: Optional[str] = None\n    scope: Union[Literal[\"function\", \"request\"], None] = None\n\n    @cached_property\n    def oauth_scopes(self) -> List[str]:\n        scopes = self.parent_oauth_scopes.copy() if self.parent_oauth_scopes else []\n        # This doesn't use a set to

{"status": "ok", "stdout": "./fastapi/routing.py:65:from starlette._utils import is_async_callable\n./fastapi/routing.py:92:        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "", "stderr": "grep: starlette: No such file or directory\n", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "grep: /usr/local/lib/python3.10/site-packages/starlette/_utils.py: No such file or directory\n", "details": {"stdout": "", "stderr": "grep: /usr/local/lib/python3.10/site-packages/starlette/_utils.py: No such file or directory\n", "exit_code": 2}}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "/bin/bash: line 1: pip: command not found\n", "details": {"stdout": "", "stderr": "/bin/bash: line 1: pip: command not found\n", "exit_code": 127}}

{"status": "ok", "stdout": "/kaggle/tmp/envs/overlays/starlette-0.50.0-py3-none-any/starlette/__init__.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "31:def is_async_callable(obj: AwaitableCallable[T]) -> TypeIs[AwaitableCallable[T]]: ...\n35:def is_async_callable(obj: Any) -> TypeIs[AwaitableCallable[Any]]: ...\n38:def is_async_callable(obj: Any) -> Any:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "@overload\ndef is_async_callable(obj: AwaitableCallable[T]) -> TypeIs[AwaitableCallable[T]]: ...\n\n\n@overload\ndef is_async_callable(obj: Any) -> TypeIs[AwaitableCallable[Any]]: ...\n\n\ndef is_async_callable(obj: Any) -> Any:\n    while isinstance(obj, functools.partial):\n        obj = obj.func\n\n    return iscoroutinefunction(obj) or (callable(obj) and iscoroutinefunction(obj.__call__))\n\n\nT_co = TypeVar(\"T_co\", covariant=True)\n\n\nclass AwaitableOrContextManager(Awaitable[T_co], AbstractAsyncContextManager[T_co], Protocol[T_co]): ...\n\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            return True\n        if self.security_scopes_param_name is not None:\n            return True\n        for sub_dep in self.dependencies:\n            if sub_dep._uses_scopes:\n                return True\n        return False\n\n    @cached_property\n    def _unwrapped_call(self) -> Any:\n        if self.call is None:\n            return self.call  # pragma: no cover\n        unwrapped = inspect.unwrap(self.call)\n        if isinstance(unwrapped, partial):\n            unwrapped = unwrapped.func\n        return unwrapped\n", "stderr": "", "exit_code": 0}