fastapi_14448

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

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

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

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

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

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

{"status": "ok", "filepath": "fastapi/routing.py", "content": "\n\n# Copy of starlette.routing.request_response modified to include the\n# dependencies' AsyncExitStack\ndef request_response(\n    func: Callable[[Request], Union[Awaitable[Response], Response]],\n) -> ASGIApp:\n    \"\"\"\n    Takes a function or coroutine `func(request) -> response`,\n    and returns an ASGI application.\n    \"\"\"\n    f: Callable[[Request], Awaitable[Response]] = (\n        func if is_async_callable(func) else functools.partial(run_in_threadpool, func)  # type:ignore\n    )\n\n    async def app(scope: Scope, receive: Receive, send: Send) -> None:\n        request = Request(scope, receive, send)\n\n        async def app(scope: Scope, receive: Receive, send: Send) -> None:\n            # Starts customization\n            response_awaited = False\n            async with AsyncExitStack() as request_stack:\n                scope[\"fastapi_inner_astack\"] = request_stack\n                async with AsyncExitStack() as function_stack:\n                    scope[\"fastapi_function_astack\"] = function_stack\n                    response = await f(request)\n                await response(scope, receive, send)\n                # Continues customization\n                response_awaited = True\n            if not response_awaited:\n                raise FastAPIError(\n", "start_line": 80, "end_line": 110, "total_lines": 4517, "is_truncated": false}

{"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", "exit_code": 0}

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

{"status": "ok", "stdout": "54:    asynccontextmanager,\n270:                (dependant.is_gen_callable or dependant.is_async_gen_callable)\n547:async def _solve_generator(\n553:    elif dependant.is_async_gen_callable:\n554:        cm = asynccontextmanager(dependant.call)(**sub_values)\n555:    return await stack.enter_async_context(cm)\n567:async def solve_dependencies(\n578:    async_exit_stack: AsyncExitStack,\n626:            async_exit_stack=async_exit_stack,\n636:            use_sub_dependant.is_gen_callable or use_sub_dependant.is_async_gen_callable\n877:async def _extract_form_body(\n901:            async def process_fn(\n907:            async with anyio.create_task_group() as tg:\n924:async def request_body_to_args(\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "content": "            kind=param.kind,\n            default=param.default,\n            annotation=get_typed_annotation(param.annotation, globalns),\n        )\n        for param in signature.parameters.values()\n    ]\n    typed_signature = inspect.Signature(typed_params)\n    return typed_signature\n\n\ndef get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any:\n    if isinstance(annotation, str):\n        annotation = ForwardRef(annotation)\n        annotation = evaluate_forwardref(annotation, globalns, globalns)\n        if annotation is type(None):\n            return None\n    return annotation\n\n\ndef get_typed_return_annotation(call: Callable[..., Any]) -> Any:\n    signature = inspect.signature(call)\n    unwrapped = inspect.unwrap(call)\n    annotation = signature.return_annotation\n\n    if annotation is inspect.Signature.empty:\n        return None\n\n    globalns = getattr(unwrapped, \"__globals__\", {})\n    return get_typed_annotation(annotation, globalns)\n\n\ndef get_dependant(\n    *,\n    path: str,\n    call: Callable[..., Any],\n    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    scope: Union[Literal[\"function\", \"request\"], None] = None,\n) -> Dependant:\n    dependant = Dependant(\n        call=call,\n        name=name,\n        path=path,\n        use_cache=use_cache,\n        scope=scope,\n        own_oauth_scopes=own_oauth_scopes,\n        parent_oauth_scopes=parent_oauth_scopes,\n    )\n    current_scopes = (parent_oauth_scopes or []) + (own_oauth_scopes or [])\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        security_requirement = SecurityRequirement(\n            security_scheme=call

{"status": "ok", "stdout": "25:class Dependant:\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "content": "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_scop

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "content": "    @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", "start_line": 101, "end_line": 116, "total_lines": 116, "is_truncated": false}

{"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", "exit_code": 0}

{"status": "ok", "stdout": "Simple async: True\nSimple sync: False\nWrapped async (async wrapper): True\nWrapped async (sync wrapper): False\nWrapped sync (async wrapper): True\nPartial async: True\nPartial wrapped async: False\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "content": "    def _uses_scopes(self) -> bool:\n        if self.own_oauth_scopes:\n            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        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", "start_line": 68, "end_line": 116, "total_lines": 116, "is_truncated"

{"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", "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", "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", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "content": "        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            solved = await _solve_generator(\n                dependant=use_sub_dependant,\n                stack=use_astack,\n                sub_values=solved_result.values

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "content": "    def _uses_scopes(self) -> bool:\n        if self.own_oauth_scopes:\n            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        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", "start_line": 68, "end_line": 116, "total_lines": 116, "is_truncated"

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/models.py\n+++ b/fastapi/dependencies/models.py\n@@ -79,9 +79,14 @@\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+        unwrapped = self.call\n+        while True:\n+            if isinstance(unwrapped, partial):\n+                unwrapped = unwrapped.func\n+            else:\n+                unwrapped = inspect.unwrap(unwrapped)\n+            if unwrapped == inspect.unwrap(unwrapped) and not isinstance(unwrapped, partial):\n+                break\n         return unwrapped\n \n     @cached_property\n", "is_truncated": false}

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/models.py\n+++ b/fastapi/dependencies/models.py\n@@ -105,11 +105,20 @@\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+        # Check both the original call and the unwrapped call to see if either is async.\n+        # This handles the case where a sync wrapper wraps an async function.\n+        if self.is_coroutine_callable_direct(self.call) or self.is_coroutine_callable_direct(self._unwrapped_call):\n+            return True\n+        return False\n+\n+    def is_coroutine_callable_direct(self, call: Any) -> bool:\n+        if call is None:\n             return False\n-        dunder_call = getattr(self._unwrapped_call, \"__call__\", None)  # noqa: B004\n+        if inspect.isroutine(call):\n+            return iscoroutinefunction(call)\n+        if inspect.isclass(call):\n+            return False\n+        dunder_call = getattr(call, \"__call__\", None)  # noqa: B004\n         return iscoroutinefunction(dunder_call)\n \n     @cached_property\n", "is_truncated": false}

{"status": "ok", "stdout": "Simple async: True\nSimple sync: False\nWrapped async (async wrapper): True\nWrapped async (sync wrapper): True\nWrapped sync (async wrapper): True\nPartial async: True\nPartial wrapped async: True\n", "exit_code": 0}

{"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", "exit_code": 0}

{"status": "ok", "stdout": "Simple async: True\nSimple sync: False\nWrapped async (async wrapper): True\nWrapped async (sync wrapper): False\nWrapped sync (async wrapper): True\nPartial async: True\nPartial wrapped async: False\n", "exit_code": 0}

{"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", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/routing.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/routing.py\n+++ b/fastapi/routing.py\n@@ -62,7 +62,35 @@\n from pydantic import BaseModel\n from starlette import routing\n from starlette._exception_handler import wrap_app_handling_exceptions\n-from starlette._utils import is_async_callable\n+def is_async_callable(callable_):\n+    \"\"\"\n+    Check if a callable is async.\n+    \"\"\"\n+    if callable_ is None:\n+        return False\n+    \n+    # Unwrapping the callable to handle functools.wraps and functools.partial\n+    unwrapped = callable_\n+    while True:\n+        if isinstance(unwrapped, functools.partial):\n+            unwrapped = unwrapped.func\n+        else:\n+            unwrapped = inspect.unwrap(unwrapped)\n+        if unwrapped == inspect.unwrap(unwrapped) and not isinstance(unwrapped, functools.partial):\n+            break\n+            \n+    # The function is async if either the original or the unwrapped version is async.\n+    from asyncio import iscoroutinefunction\n+    \n+    def check_async(func):\n+        if inspect.isroutine(func):\n+            return iscoroutinefunction(func)\n+        if inspect.isclass(func):\n+            return False\n+        dunder_call = getattr(func, \"__call__\", None)\n+        return iscoroutinefunction(dunder_call)\n+\n+    return check_async(callable_) or check_async(unwrapped)\n from starlette.concurrency import run_in_threadpool\n from starlette.exceptions import HTTPException\n from starlette.requests import Request\n", "is_truncated": false}

{"status": "ok", "stdout": "Simple async: True\nSimple sync: False\nWrapped async (async wrapper): True\nWrapped async (sync wrapper): True\nWrapped sync (async wrapper): True\nPartial async: True\nPartial wrapped async: True\n", "exit_code": 0}

{"status": "ok", "patch_size": 3495, "files_changed": 2}