fastapi_14448

{
 "command": "grep -rn \"async\" --include=\"*.py\" fastapi/ | grep \"is_async_gen\" -A 5 | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

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

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

{
 "command": "grep -rn \"inspect.unwrap\" fastapi/ | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "sed -n '190,230p' fastapi/dependencies/utils.py"
}

{
 "command": "grep -rn \"inspect.iscoroutinefunction\" fastapi/ | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "grep -rn \"iscoroutinefunction\" fastapi/ | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "grep -rn \"asyncio.iscoroutinefunction\" fastapi/ | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "grep -rn \"is_async_callable\" fastapi/ | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "sed -n '80,100p' fastapi/routing.py"
}

{
 "command": "grep -rn \"is_async_callable\" starlette/ | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "# I need to find where is_async_callable is defined. It's imported from starlette._utils.\n# Since starlette is not in /workspace, I cannot check its source.\n# However, the problem statement says we need to fix support for functools.wraps and partial combined.\n# The current implementation of _unwrapped_call in fastapi/dependencies/models.py is:\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# This only unwraps once. If it's a partial of a wrapped function, or a wrapped partial, it might not be enough.\n# Let's see if we need a loop.\n# Also, if either the wrapper or the original function is async, it should be considered async.\n\n# Let's check fastapi/dependencies/models.py again.\nsed -n '70,110p' fastapi/dependencies/models.py"
}

{
 "command": "cat > /tmp/repro.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\nfrom typing import Any, Callable\nfrom fastapi.dependencies.models import Dependant\nfrom fastapi.dependencies.utils import solve_dependencies\nfrom fastapi.routing import APIRoute\nfrom fastapi import Request\nfrom starlette.testclient import TestClient\nfrom fastapi import FastAPI\n\ndef is_coroutine_function(func):\n    return asyncio.iscoroutinefunction(func)\n\n# Case 1: regular function\ndef regular_fn():\n    return \"regular\"\n\n# Case 2: async function\nasync def async_fn():\n    return \"async\"\n\n# Case 3: partial of regular\npartial_regular = functools.partial(regular_fn)\n\n# Case 4: partial of async\npartial_async = functools.partial(async_fn)\n\ndef wrap_sync(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\ndef wrap_async(f):\n    @functools.wraps(f)\n    async def wrapper(*args, **kwargs):\n        return await f(*args, **kwargs)\n    return wrapper\n\n# Case 5: wrapped regular\nwrapped_regular = wrap_sync(regular_fn)\n\n# Case 6: wrapped async\nwrapped_async = wrap_async(async_fn)\n\n# Case 7: partial of wrapped regular\npartial_wrapped_regular = functools.partial(wrapped_regular)\n\n# Case 8: partial of wrapped async\npartial_wrapped_async = functools.partial(wrapped_async)\n\n# Case 9: wrapped partial regular\nwrapped_partial_regular = wrap_sync(partial_regular)\n\n# Case 10: wrapped partial async\nwrapped_partial_async = wrap_async(partial_async)\n\ntest_cases = [\n    (\"regular\", regular_fn),\n    (\"partial_regular\", partial_regular),\n    (\"wrapped_regular\", wrapped_regular),\n    (\"partial_wrapped_regular\", partial_wrapped_regular),\n    (\"wrapped_partial_regular\", wrapped_partial_regular),\n    (\"async\", async_fn),\n    (\"partial_async\", partial_async),\n    (\"wrapped_async\", wrapped_async),\n    (\"partial_wrapped_async\", partial_wrapped_async),\n    (\"wrapped_partial_async\", wrapped_partial_async),\n]\n\nfor name, fn in test_cases:\n    # Use a dummy Dependant to test _unwrapped_call and the callable properties\n    dep = Dependant(call=fn)\n    unwrapped = dep._unwrapped_call\n    is_async = dep.is_coroutine_callable\n    is_async_gen = dep.is_async_gen_callable\n    print(f\"{name}: unwrapped={unwrapped}, is_async={is_async}, is_async_gen={is_async_gen}\")\n\nPY\npython3 /tmp/repro.py\n"
}

{
 "command": "cat > /tmp/repro_async_check.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\nfrom fastapi.dependencies.models import Dependant\n\ndef wrap_sync(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\nasync def wrap_async(f):\n    # This is not a decorator in the usual sense, but let's see.\n    # The goal is to test if a wrapper is async but the original is sync.\n    pass\n\ndef sync_fn():\n    return \"sync\"\n\nasync def async_fn():\n    return \"async\"\n\n# Case: sync function wrapped by async wrapper\ndef async_wrapper_for_sync(f):\n    @functools.wraps(f)\n    async def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\n# Case: async function wrapped by sync wrapper\ndef sync_wrapper_for_async(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return asyncio.run(f(*args, **kwargs)) # simplified\n    return wrapper\n\nwrapped_sync_in_async = async_wrapper_for_sync(sync_fn)\nwrapped_async_in_sync = sync_wrapper_for_async(async_fn)\n\nprint(f\"wrapped_sync_in_async: is_async={Dependant(call=wrapped_sync_in_async).is_coroutine_callable}\")\nprint(f\"wrapped_async_in_sync: is_async={Dependant(call=wrapped_async_in_sync).is_coroutine_callable}\")\nPY\npython3 /tmp/repro_async_check.py\n"
}

{
 "command": "cat > /tmp/repro_async_check.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\nfrom fastapi.dependencies.models import Dependant\n\ndef wrap_sync(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\ndef sync_fn():\n    return \"sync\"\n\nasync def async_fn():\n    return \"async\"\n\ndef async_wrapper_for_sync(f):\n    @functools.wraps(f)\n    async def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\ndef sync_wrapper_for_async(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        # Note: this is just for testing the property\n        return asyncio.run(f(*args, **kwargs)) \n    return wrapper\n\nwrapped_sync_in_async = async_wrapper_for_sync(sync_fn)\nwrapped_async_in_sync = sync_wrapper_for_async(async_fn)\n\ndep_sync_in_async = Dependant(call=wrapped_sync_in_async)\nprint(f\"wrapped_sync_in_async: unwrapped={dep_sync_in_async._unwrapped_call}, is_async={dep_sync_in_async.is_coroutine_callable}\")\n\ndep_async_in_sync = Dependant(call=wrapped_async_in_sync)\nprint(f\"wrapped_async_in_sync: unwrapped={dep_async_in_sync._unwrapped_call}, is_async={dep_async_in_sync.is_coroutine_callable}\")\nPY\npython3 /tmp/repro_async_check.py\n"
}

{
 "command": "cat > /tmp/repro_complex.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\nfrom fastapi.dependencies.models import Dependant\n\ndef sync_fn():\n    return \"sync\"\n\nasync def async_fn():\n    return \"async\"\n\ndef sync_wrapper(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\ndef async_wrapper(f):\n    @functools.wraps(f)\n    async def wrapper(*args, **kwargs):\n        res = f(*args, **kwargs)\n        if inspect.isawaitable(res):\n            await res\n        return res\n    return wrapper\n\n# 1. Partial(sync_fn) -> Wrapped by sync_wrapper\n# Wrapper is sync, original is sync. Result: sync.\nc1 = sync_wrapper(functools.partial(sync_fn))\n\n# 2. Partial(async_fn) -> Wrapped by sync_wrapper\n# Wrapper is sync, original is async. Result: SHOULD BE async (since it returns a coroutine)\nc2 = sync_wrapper(functools.partial(async_fn))\n\n# 3. Partial(sync_fn) -> Wrapped by async_wrapper\n# Wrapper is async, original is sync. Result: SHOULD BE async.\nc3 = async_wrapper(functools.partial(sync_fn))\n\n# 4. Partial(async_fn) -> Wrapped by async_wrapper\n# Wrapper is async, original is async. Result: SHOULD BE async.\nc4 = async_wrapper(functools.partial(async_fn))\n\ncases = [\n    (\"PartialSync-SyncWrap\", c1),\n    (\"PartialAsync-SyncWrap\", c2),\n    (\"PartialSync-AsyncWrap\", c3),\n    (\"PartialAsync-AsyncWrap\", c4),\n]\n\nfor name, fn in cases:\n    dep = Dependant(call=fn)\n    print(f\"{name}: is_async={dep.is_coroutine_callable}\")\nPY\npython3 /tmp/repro_complex.py\n"
}

{
 "command": "cat > /tmp/repro_complex_2.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\nfrom fastapi.dependencies.models import Dependant\n\ndef sync_fn():\n    return \"sync\"\n\nasync def async_fn():\n    return \"async\"\n\ndef sync_wrapper(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\ndef async_wrapper(f):\n    @functools.wraps(f)\n    async def wrapper(*args, **kwargs):\n        res = f(*args, **kwargs)\n        if inspect.isawaitable(res):\n            await res\n        return res\n    return wrapper\n\n# 5. sync_fn -> Wrapped by sync_wrapper -> Wrapped by async_wrapper\nc5 = async_wrapper(sync_wrapper(sync_fn))\n\n# 6. async_fn -> Wrapped by sync_wrapper -> Wrapped by async_wrapper\nc6 = async_wrapper(sync_wrapper(async_fn))\n\n# 7. sync_fn -> Wrapped by async_wrapper -> Wrapped by sync_wrapper\nc7 = sync_wrapper(async_wrapper(sync_fn))\n\n# 8. async_fn -> Wrapped by async_wrapper -> Wrapped by sync_wrapper\nc8 = sync_wrapper(async_wrapper(async_fn))\n\ncases = [\n    (\"Sync-SyncWrap-AsyncWrap\", c5),\n    (\"Async-SyncWrap-AsyncWrap\", c6),\n    (\"Sync-AsyncWrap-SyncWrap\", c7),\n    (\"Async-AsyncWrap-SyncWrap\", c8),\n]\n\nfor name, fn in cases:\n    dep = Dependant(call=fn)\n    print(f\"{name}: is_async={dep.is_coroutine_callable}\")\nPY\npython3 /tmp/repro_complex_2.py\n"
}

{
 "command": "# The issue is that if the wrapper is async, but the original function is sync,\n# it is NOT being detected as async.\n# This is because _unwrapped_call uses inspect.unwrap(), which goes straight to the original function.\n# Then is_coroutine_callable checks _unwrapped_call.\n\n# Let's check the current implementation of is_coroutine_callable:\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# It ONLY checks the unwrapped call. It does NOT check the wrapper.\n# But if the wrapper is async, the whole thing should be treated as async.\n\n# So we need to check if EITHER the original call or any of the wrappers are async.\n# However, inspect.unwrap() only gives the final unwrapped function.\n\n# We should probably check the original `self.call` as well.\n\n# Let's try this:\n# 1. Start with self.call.\n# 2. Check if it is async.\n# 3. Unwrap it and check if the unwrapped is async.\n# 4. Also handle partials.\n\n# Wait, if we have a chain: WrapperAsync -> WrapperSync -> OriginalSync\n# self.call is WrapperAsync. WrapperAsync is async. Result should be async.\n# current: _unwrapped_call is OriginalSync. OriginalSync is sync. Result: sync. (WRONG)\n\n# If we have: WrapperSync -> WrapperAsync -> OriginalSync\n# self.call is WrapperSync. WrapperSync is sync.\n# _unwrapped_call is OriginalSync. OriginalSync is sync. Result: sync. (WRONG)\n\n# So we need to iterate through all wrappers.\n\n# Let's see how to iterate through wrappers.\n# `inspect.unwrap` just goes to the end.\n# But we can use `__wrapped__` if it's set by `functools.wraps`.\n\n# Let's refine _unwrapped_call or add a helper to check if any in the chain is async.\n"
}

{
 "command": "# Let's check how to properly detect if any wrapper is async.\ncat > /tmp/check_wrappers.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\n\ndef sync_fn():\n    return \"sync\"\n\ndef sync_wrapper(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\ndef async_wrapper(f):\n    @functools.wraps(f)\n    async def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\n# WrapperSync -> WrapperAsync -> OriginalSync\nc = sync_wrapper(async_wrapper(sync_fn))\n\ndef is_any_async(f):\n    curr = f\n    while True:\n        if asyncio.iscoroutinefunction(curr):\n            return True\n        if isinstance(curr, functools.partial):\n            # For partial, we must check the underlying func, \n            # but partial itself is not a coroutine function.\n            # However, a partial can wrap an async function.\n            # This is tricky. \n            # If we have partial(async_fn), asyncio.iscoroutinefunction(partial(async_fn)) is False.\n            # So we need to handle partial separately.\n            pass\n        if hasattr(curr, \"__wrapped__\"):\n            curr = curr.__wrapped__\n        else:\n            break\n    return False\n\nprint(f\"c: is_any_async={is_any_async(c)}\")\nPY\npython3 /tmp/check_wrappers.py\n"
}

{
 "command": "cat > /tmp/check_wrappers_partial.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\n\nasync def async_fn():\n    return \"async\"\n\np = functools.partial(async_fn)\nprint(f\"asyncio.iscoroutinefunction(p): {asyncio.iscoroutinefunction(p)}\")\n\ndef is_any_async(f):\n    curr = f\n    while True:\n        # Handle partials first: if it's a partial, we want to check its func\n        if isinstance(curr, functools.partial):\n            if asyncio.iscoroutinefunction(curr.func):\n                return True\n            curr = curr.func\n            continue\n        \n        if asyncio.iscoroutinefunction(curr):\n            return True\n        \n        if hasattr(curr, \"__wrapped__\"):\n            curr = curr.__wrapped__\n        else:\n            break\n    return False\n\nprint(f\"is_any_async(p): {is_any_async(p)}\")\nPY\npython3 /tmp/check_wrappers_partial.py\n"
}

{
 "command": "# Wait, asyncio.iscoroutinefunction(functools.partial(async_fn)) is True?\n# Let me re-check.\ncat > /tmp/check_partial.py <<'PY'\nimport asyncio\nimport functools\n\nasync def async_fn():\n    return \"async\"\n\np = functools.partial(async_fn)\nprint(f\"asyncio.iscoroutinefunction(p): {asyncio.iscoroutinefunction(p)}\")\nPY\npython3 /tmp/check_partial.py\n"
}

{
 "command": "# If asyncio.iscoroutinefunction handles partials, then we just need to iterate through __wrapped__.\n# Let's test a combined case: Wrapped(Partial(Async)) and Partial(Wrapped(Async))\n\ncat > /tmp/check_combined.py <<'PY'\nimport asyncio\nimport functools\nimport inspect\n\nasync def async_fn():\n    return \"async\"\n\ndef sync_fn():\n    return \"sync\"\n\ndef sync_wrapper(f):\n    @functools.wraps(f)\n    def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\ndef async_wrapper(f):\n    @functools.wraps(f)\n    async def wrapper(*args, **kwargs):\n        return f(*args, **kwargs)\n    return wrapper\n\n# Case A: Partial(Async) -> Wrapped by sync_wrapper\ncase_a = sync_wrapper(functools.partial(async_fn))\n\n# Case B: Wrapped(Async) -> Partial\ncase_b = functools.partial(async_wrapper(async_fn))\n\n# Case C: Partial(Sync) -> Wrapped by async_wrapper\ncase_c = async_wrapper(functools.partial(sync_fn))\n\n# Case D: Wrapped(Sync) -> Partial\ncase_d = functools.partial(sync_wrapper(sync_fn))\n\ndef is_any_async(f):\n    curr = f\n    while True:\n        if asyncio.iscoroutinefunction(curr):\n            return True\n        if hasattr(curr, \"__wrapped__\"):\n            curr = curr.__wrapped__\n        elif isinstance(curr, functools.partial):\n            curr = curr.func\n        else:\n            break\n    return False\n\nprint(f\"Case A (SyncWrap(Partial(Async))): {is_any_async(case_a)}\")\nprint(f\"Case B (Partial(AsyncWrap(Async))): {is_any_async(case_b)}\")\nprint(f\"Case C (AsyncWrap(Partial(Sync))): {is_any_async(case_c)}\")\nprint(f\"Case D (Partial(SyncWrap(Sync))): {is_any_async(case_d)}\")\nPY\npython3 /tmp/check_combined.py\n"
}

{
 "command": "# Now let's see how to integrate this into fastapi/dependencies/models.py.\n# We need to update is_coroutine_callable, is_gen_callable, and is_async_gen_callable.\n\n# Currently they all depend on _unwrapped_call.\n# _unwrapped_call is:\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# If we change the logic to iterate through all levels, we can ensure that if ANY level is async, it returns True.\n\n# Let's check the original code again.\nsed -n '80,120p' fastapi/dependencies/models.py"
}

{
 "command": "# I will implement a helper method to check if any level in the wrapping chain matches a predicate.\n# Or just rewrite the properties to iterate.\n\n# Wait, is_coroutinefunction, isgeneratorfunction, isasyncgenfunction are the predicates.\n\n# Let's try to define a helper in Dependant.\n\n# But first, I should check if there is any other place that uses _unwrapped_call.\ngrep -rn \"_unwrapped_call\" fastapi/ | head -20 || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "# Okay, _unwrapped_call is only used by these 3 properties in Dependant.\n# So I can change them.\n\n# Let's define a helper to check any wrapper.\n\n# Wait, if I change _unwrapped_call to return the whole chain, that might break other things if they expect only one function.\n# But they don't seem to expect that, they just use it to check properties.\n\n# Actually, the properties check if the call is async/gen etc.\n# If ANY level is async, it should be True.\n\n# Let's modify the properties in fastapi/dependencies/models.py.\n# I will use a loop to check all wrappers.\n\n# I'll start by adding the necessary import for partial if it's not there.\n# It is already there (it's used in _unwrapped_call).\n# Let's check imports.\nsed -n '1,30p' fastapi/dependencies/models.py"
}

{
 "command": "# Now I will apply the changes.\n# I will replace the property implementations.\n\npython3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/dependencies/models.py\")\ns = p.read_text()\n\n# Define new implementations for the properties\n# We need to check the call itself and all its unwrapped versions.\n\nnew_is_gen = \"\"\"    @cached_property\n    def is_gen_callable(self) -> bool:\n        curr = self.call\n        while True:\n            if inspect.isgeneratorfunction(curr):\n                return True\n            dunder_call = getattr(curr, \"__call__\", None)  # noqa: B004\n            if inspect.isgeneratorfunction(dunder_call):\n                return True\n            if hasattr(curr, \"__wrapped__\"):\n                curr = curr.__wrapped__\n            elif isinstance(curr, partial):\n                curr = curr.func\n            else:\n                break\n        return False\"\"\"\n\nnew_is_async_gen = \"\"\"    @cached_property\n    def is_async_gen_callable(self) -> bool:\n        curr = self.call\n        while True:\n            if inspect.isasyncgenfunction(curr):\n                return True\n            dunder_call = getattr(curr, \"__call__\", None)  # noqa: B004\n            if inspect.isasyncgenfunction(dunder_call):\n                return True\n            if hasattr(curr, \"__wrapped__\"):\n                curr = curr.__wrapped__\n            elif isinstance(curr, partial):\n                curr = curr.func\n            else:\n                break\n        return False\"\"\"\n\nnew_is_coroutine = \"\"\"    @cached_property\n    def is_coroutine_callable(self) -> bool:\n        curr = self.call\n        while True:\n            if inspect.isroutine(curr):\n                if iscoroutinefunction(curr):\n                    return True\n            elif not inspect.isclass(curr):\n                dunder_call = getattr(curr, \"__call__\", None)  # noqa: B004\n                if iscoroutinefunction(dunder_call):\n                    return True\n            \n            if hasattr(curr, \"__wrapped__\"):\n                curr = curr.__wrapped__\n            elif isinstance(curr, partial):\n                curr = curr.func\n            else:\n                break\n        return False\"\"\"\n\n# Let's find the old ones and replace them.\n# We should replace the old properties.\n\nold_is_gen = \"\"\"    @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\nold_is_async_gen = \"\"\"    @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\nold_is_coroutine = \"\"\"    @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\ns = s.replace(old_is_gen, new_is_gen)\ns = s.replace(old_is_async_gen, new_is_async_gen)\ns = s.replace(old_is_coroutine, new_is_coroutine)\n\np.write_text(s)\nPY\n"
}