fastapi_14448

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

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

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

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "content": "            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", "start_line": 70, "end_line": 85, "total_lines": 116, "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", "filepath": "fastapi/routing.py", "content": "    is_body_allowed_for_status_code,\n)\nfrom pydantic import BaseModel\nfrom starlette import routing\nfrom starlette._exception_handler import wrap_app_handling_exceptions\nfrom starlette._utils import is_async_callable\nfrom starlette.concurrency import run_in_threadpool\nfrom starlette.exceptions import HTTPException\nfrom starlette.requests import Request\nfrom starlette.responses import JSONResponse, Response\nfrom starlette.routing import (\n    BaseRoute,\n    Match,\n    compile_path,\n    get_name,\n)\nfrom starlette.routing import Mount as Mount  # noqa\nfrom starlette.types import AppType, ASGIApp, Lifespan, Receive, Scope, Send\nfrom starlette.websockets import WebSocket\nfrom typing_extensions import Annotated, deprecated\n\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", "start_line": 60, "end_line": 100, "total_lines": 4517, "is_truncated": false}

{"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/models.py:102:    def is_coroutine_callable(self) -> bool:\nfastapi/dependencies/utils.py:646:        elif use_sub_dependant.is_coroutine_callable:\nfastapi/routing.py:305:    is_coroutine = dependant.is_coroutine_callable\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/routing.py", "content": "    # facilitate profiling endpoints, since inner functions are harder to profile.\n    assert dependant.call is not None, \"dependant.call must be a function\"\n\n    if is_coroutine:\n        return await dependant.call(**values)\n    else:\n        return await run_in_threadpool(dependant.call, **values)\n\n\ndef get_request_handler(\n    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    else:\n        actual_response_class = response_class\n\n    async def app(request: Request) -> Response:\n        response: Union[Response, None] = None\n        file_stack = request.scope.get(\"fastapi_middleware_astack\")\n        assert isinstance(file_stack, AsyncExitStack), (\n            \"fastapi_middleware_astack not found in request scope\"\n        )\n\n", "start_line": 280, "end_line": 320, "total_lines": 4517, "is_truncated": false}

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

{"status": "ok", "filepath": "/tmp/test_wraps_partial.py", "size": 1903}

{"status": "error", "error_type": "CommandError", "error_message": "Command failed with exit code 2", "details": {"stdout": "", "stderr": "python3: can't open file '/tmp/swe_work/eval4_submission/fastapi_14448/a/tmp/test_wraps_partial.py': [Errno 2] No such file or directory\n", "exit_code": 2}}

{"status": "ok", "stdout": "/tmp/swe_work/eval4_submission/fastapi_14448/a/tmp:\n", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "Command failed with exit code 1", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    import inspect; from functools import partial; import asyncio; from fastapi.dependencies.models import Dependant; from fastapi.routing import get_request_handler; from fastapi import FastAPI, Depends; from starlette.testclient import TestClient; async def async_func(): return 'async'; def sync_func(): return 'sync'; def wraps(func): def wrapped(*args, **kwargs): return func(*args, **kwargs); wrapped.__wrapped__ = func; return wrapped; app = FastAPI(); @wraps async def dep_async_wrapped_sync(): return 'async_wrapped_sync'; async def dep_sync_wrapped_async(): return sync_func(); @app.get('/async_wrapped_sync') async def route1(d = Depends(dep_async_wrapped_sync)): return d; @app.get('/sync_wrapped_async') async def route2(d = Depends(dep_sync_wrapped_async)): return d; client = TestClient(app); resp1 = client.get('/async_wrapped_sync'); assert resp1.status_code == 200; assert resp1.json() == 'async_wrapped_sync'; resp2 = client.get('/sync_wrapped_async'); assert resp2.status_code == 200; assert resp2.json() == 'sync'; print('All tests passed!')\n                                                                                                                                                                                                                                                          ^^^^^\nSyntaxError: invalid syntax\n", "exit_code": 1}}

{"status": "ok", "stdout": "Case 1: 200, async_wrapped_sync\nCase 2: 200, sync_wrapped_async\n", "exit_code": 0}

{"status": "ok", "stdout": "Async Wrapped Sync: async_wrapped_sync\nSync Wrapped Sync: sync_wrapped_sync\nPartial Async: {'detail': [{'type': 'missing', 'loc': ['query', 'b'], 'msg': 'Field required', 'input': None}]}\nPartial Sync: {'detail': [{'type': 'missing', 'loc': ['query', 'b'], 'msg': 'Field required', 'input': None}]}\n", "exit_code": 0}

{"status": "ok", "stdout": "Async Wrapped Sync: async_wrapped_sync\nPartial Async: async_1\n", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "Command failed with exit code 1", "details": {"stdout": "", "stderr": "Traceback (most recent call last):\n  File \"/workspace/fastapi/encoders.py\", line 337, in jsonable_encoder\n    data = dict(obj)\nTypeError: 'coroutine' object is not iterable\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n  File \"/workspace/fastapi/encoders.py\", line 342, in jsonable_encoder\n    data = vars(obj)\nTypeError: vars() argument must have __dict__ attribute\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"<string>\", line 28, in <module>\n    print(f'Partial Wrapped Async: {client.get(\"/partial_wrapped_async\").json()}')\n                                    ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/kaggle/tmp/envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py\", line 473, in get\n    return super().get(\n           ~~~~~~~~~~~^\n        url,\n        ^^^^\n    ...<6 lines>...\n        extensions=extensions,\n        ^^^^^^^^^^^^^^^^^^^^^^\n    )\n    ^\n  File \"/kaggle/tmp/envs/fastapi/lib/python3.13/site-packages/httpx/_client.py\", line 1053, in get\n    return self.request(\n           ~~~~~~~~~~~~^\n        \"GET\",\n        ^^^^^^\n    ...<7 lines>...\n        extensions=extensions,\n        ^^^^^^^^^^^^^^^^^^^^^^\n    )\n    ^\n  File \"/kaggle/tmp/envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py\", line 445, in request\n    return super().request(\n           ~~~~~~~~~~~~~~~^\n        method,\n        ^^^^^^^\n    ...<11 lines>...\n        extensions=extensions,\n        ^^^^^^^^^^^^^^^^^^^^^^\n    )\n    ^\n  File \"/kaggle/tmp/envs/fastapi/lib/python3.13/site-packages/httpx/_client.py\", line 825, in request\n    return self.send(request, auth=auth, follow_redirects=follow_redirects)\n           ~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^

{"status": "ok", "filepath": "fastapi/dependencies/models.py", "content": "            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", "start_line": 70, "end_line": 85, "total_lines": 116, "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@@ -79,10 +79,16 @@\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+        current = self.call\n+        while True:\n+            unwrapped = inspect.unwrap(current)\n+            if isinstance(unwrapped, partial):\n+                current = unwrapped.func\n+                continue\n+            current = unwrapped\n+            break\n+        return current\n \n     @cached_property\n     def is_gen_callable(self) -> bool:\n", "is_truncated": false}

{"status": "ok", "stdout": "Partial Wrapped Async: async_1\n", "exit_code": 0}

{"status": "ok", "stdout": "Wrapped Partial Async: async_1\n", "exit_code": 0}

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