fastapi_14458

{
 "command": "grep -rn \"is_coroutine_callable\" . | head -20"
}

{
 "command": "grep -rn \"is_async_gen_callable\" . | head -20"
}

{
 "command": "grep -rn \"is_gen_callable\" . | head -20"
}

{
 "command": "sed -n '100,200p' fastapi/dependencies/models.py"
}

{
 "command": "python3 -c \"import inspect; print(inspect.isclass)\""
}

{
 "command": "cat > /tmp/reproduce_issue.py <<'PY'\nimport inspect\nfrom fastapi import FastAPI, Depends\nfrom fastapi.dependencies.models import Dependant\nfrom fastapi.routing import APIRoute\n\n# Mocking the necessary parts of Dependant\nclass MockDependant:\n    def __init__(self, call):\n        self.call = call\n\n    @property\n    def is_gen_callable(self):\n        if self.call is None: return False\n        if inspect.isgeneratorfunction(self.call): return True\n        dunder_call = getattr(self.call, \"__call__\", None)\n        if dunder_call and inspect.isgeneratorfunction(dunder_call):\n            return True\n        return False\n\n    @property\n    def is_async_gen_callable(self):\n        if self.call is None: return False\n        if inspect.isasyncgenfunction(self.call): return True\n        dunder_call = getattr(self.call, \"__call__\", None)\n        if dunder_call and inspect.isasyncgenfunction(dunder_call):\n            return True\n        return False\n\n    @property\n    def is_coroutine_callable(self):\n        if self.call is None: return False\n        if inspect.iscoroutinefunction(self.call): return True\n        dunder_call = getattr(self.call, \"__call__\", None)\n        if dunder_call and inspect.iscoroutinefunction(dunder_call):\n            return True\n        return False\n\nclass MyDep:\n    def __call__(self):\n        yield 1\n\ndef test_issue():\n    # When MyDep is used as a class dependency\n    dep = MockDependant(MyDep)\n    print(f\"is_gen_callable: {dep.is_gen_callable}\")\n    print(f\"is_async_gen_callable: {dep.is_async_gen_callable}\")\n    print(f\"is_coroutine_callable: {dep.is_coroutine_callable}\")\n\nif __name__ == \"__main__\":\n    test_issue()\nPY\npython3 /tmp/reproduce_issue.py\n"
}

{
 "command": "cat > /tmp/reproduce_issue.py <<'PY'\nimport inspect\nimport asyncio\nfrom fastapi.dependencies.models import Dependant\n\nclass MyDep:\n    def __call__(self):\n        yield 1\n\nclass MyAsyncDep:\n    async def __call__(self, x):\n        return x\n\nclass MyAsyncGenDep:\n    async def __call__(self, x):\n        yield x\n\n# We need to create a real Dependant object to test this, \n# but it's easier to just mock it or use the real Dependant class \n# if we can initialize it.\n# However, Dependant is a Pydantic model, let's see how to instantiate it.\n\nfrom fastapi.dependencies.models import Dependant\n# Dependant is likely a Pydantic model. Let's try to instantiate it.\n# We can't easily instantiate Dependant because it requires many arguments.\n# Let's just use a simple class that implements the properties as in the real fastapi.\n# Instead of actually running it, let's just check if we can reproduce the logic.\n\ndef check_logic(call):\n    # simplified version of is_gen_callable logic\n    if call is None: return False\n    # simulate inspect.isgeneratorfunction(_impartial(self.call))\n    if inspect.isgeneratorfunction(call): return True\n    dunder_call = getattr(call, \"__call__\", None)\n    if dunder_call is None: return False\n    if inspect.isgeneratorfunction(dunder_call): return True\n    return False\n\ndef check_coroutine_logic(call):\n    if call is None: return False\n    if inspect.iscoroutinefunction(call): return True\n    dunder_call = getattr(call, \"__call__\", None)\n    if dunder_call is None: return False\n    if inspect.iscoroutinefunction(dunder_call): return True\n    return False\n\nclass GenClass:\n    def __call__(self):\n        yield 1\n\nclass CoroClass:\n    async def __call__(self):\n        return 1\n\nprint(f\"GenClass is_gen: {check_logic(GenClass)}\")\nprint(f\"CoroClass is_coro: {check_coroutine_logic(CoroClass)}\")\nPY\npython3 /tmp/reproduce_issue.py\n"
}

{
 "command": "cd /workspace && python3 - <<'PY'\nfrom pathlib import Path\nimport inspect\n\np = Path(\"fastapi/dependencies/models.py\")\ns = p.read_text()\n\n# Fix is_gen_callable\nold_gen = \"\"\"        dunder_call = getattr(_impartial(self.call), \"__call__\", None)  # noqa: B004\n        if dunder_call is None:\n            return False  # pragma: no cover\n        if inspect.isgeneratorfunction(\n            _impartial(dunder_call)\n        ) or inspect.isgeneratorfunction(_unwrapped_call(dunder_call)):\n            return True\"\"\"\nnew_gen = \"\"\"        dunder_call = getattr(_impartial(self.call), \"__call__\", None)  # noqa: B004\n        if dunder_call is None or inspect.isclass(self.call):\n            return False  # pragma: no cover\n        if inspect.isgeneratorfunction(\n            _impartial(dunder_call)\n        ) or inspect.isgeneratorfunction(_unwrapped_call(dunder_call)):\n            return True\"\"\"\n\n# Fix is_async_gen_callable\nold_async_gen = \"\"\"        dunder_call = getattr(_impartial(self.call), \"__call__\", None)  # noqa: B004\n        if dunder_call is None:\n            return False  # pragma: no cover\n        if inspect.isasyncgenfunction(\n            _impartial(dunder_call)\n        ) or inspect.isasyncgenfunction(_unwrapped_call(dunder_call)):\n            return True\"\"\"\nnew_async_gen = \"\"\"        dunder_call = getattr(_impartial(self.call), \"__call__\", None)  # noqa: B004\n        if dunder_call is None or inspect.isclass(self.call):\n            return False  # pragma: no cover\n        if inspect.isasyncgenfunction(\n            _impartial(dunder_call)\n        ) or inspect.isasyncgenfunction(_unwrapped_call(dunder_call)):\n            return True\"\"\"\n\n# Fix is_coroutine_callable\nold_coro = \"\"\"        dunder_call = getattr(_impartial(self.call), \"__call__\", None)  # noqa: B004\n        if dunder_call is None:\n            return False  # pragma: no cover\n        if iscoroutinefunction(_impartial(dunder_call)) or iscoroutinefunction(\n            _unwrapped_call(dunder_call)\n        ):\n            return True\"\"\"\nnew_coro = \"\"\"        dunder_call = getattr(_impartial(self.call), \"__call__\", None)  # noqa: B004\n        if dunder_call is None or inspect.isclass(self.call):\n            return False  # pragma: no cover\n        if iscoroutinefunction(_impartial(dunder_call)) or iscoroutinefunction(\n            _unwrapped_call(dunder_call)\n        ):\n            return True\"\"\"\n\ns = s.replace(old_gen, new_gen)\ns = s.replace(old_async_gen, new_async_gen)\ns = s.replace(old_coro, new_coro)\n\np.write_text(s)\nPY\n"
}

{
 "command": "cat > /tmp/verify_fix.py <<'PY'\nimport inspect\nimport asyncio\nfrom fastapi.dependencies.models import Dependant\n\nclass MyDep:\n    def __call__(self):\n        yield 1\n\nclass MyAsyncDep:\n    async def __call__(self, x):\n        return x\n\nclass MyAsyncGenDep:\n    async def __call__(self, x):\n        yield x\n\n# Mocking the Dependant for verification because it's a Pydantic model \n# and we don't want to set up a whole FastAPI app.\n# We can't easily instantiate Dependant, but we can mock it.\n# Since we modified the methods on the Dependant class, \n# let's use a dummy object that inherits from Dependant or \n# just mock the attributes.\n\n# However, the modified methods use self.call, and they use helper functions \n# _impartial and _unwrapped_call.\n# Let's look at those functions.\nPY\nrun_command: grep -n \"_impartial\" fastapi/dependencies/models.py\n"
}

{
 "command": "grep -n \"_impartial\" fastapi/dependencies/models.py"
}

{
 "command": "sed -n '20,40p' fastapi/dependencies/models.py"
}

{
 "command": "cat > /tmp/verify_fix.py <<'PY'\nimport inspect\nfrom functools import partial\nfrom fastapi.dependencies.models import Dependant\n\ndef _impartial(func):\n    while isinstance(func, partial):\n        func = func.func\n    return func\n\ndef _unwrapped_call(call):\n    return inspect.unwrap(_impartial(call))\n\nclass MyDep:\n    def __call__(self):\n        yield 1\n\nclass MyAsyncDep:\n    async def __call__(self, x):\n        return x\n\nclass MyAsyncGenDep:\n    async def __call__(self, x):\n        yield x\n\n# We need to override the methods of Dependant because we are using \n# the logic from fastapi/dependencies/models.py but Dependant is a dataclass.\n# The patched methods in models.py are using @cached_property.\n\nfrom fastapi.dependencies.models import Dependant\n\n# Create a dummy Dependant instance. \n# Dependant is a dataclass, so we can just instantiate it.\ndep_gen = Dependant(call=MyDep)\ndep_async = Dependant(call=MyAsyncDep)\ndep_async_gen = Dependant(call=MyAsyncGenDep)\n\n# Dependant methods are @cached_property, so they are handled by the class.\n# But we need to make sure they are correctly imported.\n# Wait, the methods I edited are in the Dependant class.\n\nprint(f\"GenClass is_gen: {dep_gen.is_gen_callable}\")\nprint(f\"AsyncDep is_coro: {dep_async.is_coroutine_callable}\")\nprint(f\"AsyncGenDep is_async_gen: {dep_async_gen.is_async_gen_callable}\")\n\n# Now test with instances\ndep_gen_inst = Dependant(call=MyDep())\ndep_async_inst = Dependant(call=MyAsyncDep())\ndep_async_gen_inst = Dependant(call=MyAsyncGenDep())\n\nprint(f\"GenInst is_gen: {dep_gen_inst.is_gen_callable}\")\nprint(f\"AsyncDepInst is_coro: {dep_async_inst.is_coroutine_callable}\")\nprint(f\"AsyncGenDepInst is_async_gen: {dep_async_gen_inst.is_async_gen_callable}\")\nPY\npython3 /tmp/verify_fix.py\n"
}

{
 "command": "git diff"
}

{
 "command": "submit_patch"
}

{}