Use ParamSpec in .asyncio()

[dkang-quora]

import asyncio

from asynq import asynq


@asynq()
def f(arg1: int, arg2: str):
    pass


async def main():
    await f.asyncio(1, "2")
    await f.asyncio(1, arg2="2")
    await f.asyncio(arg1=1, arg2="2")
    await f.asyncio(arg1="1", arg2=2)


asyncio.run(main())

pyright test.py reports

asynq/test.py
  asynq/test.py:15:26 - error: Argument of type "Literal['1']" cannot be assigned to parameter "arg1" of type "int" in function "asyncio"
    "Literal['1']" is incompatible with "int" (reportArgumentType)
  asynq/test.py:15:36 - error: Argument of type "Literal[2]" cannot be assigned to parameter "arg2" of type "str" in function "asyncio"
    "Literal[2]" is incompatible with "str" (reportArgumentType)
2 errors, 0 warnings, 0 informations

[JelleZijlstra]

This loses the return type, use Coroutine[Any, Any, _T]

[dkang-quora]

type checkers think _T is Generator because there is yield

ret1: int = await f.asyncio(1, "2")

  asynq/test.py:18:17 - error: Expression of type "Generator[AsyncTask[int], Unknown, Unknown]" is incompatible with declared type "int"
    "Generator[AsyncTask[int], Unknown, Unknown]" is incompatible with "int" (reportAssignmentType)

[JelleZijlstra]

I see. This is perhaps fixable with overloads: if the decorator is passed something returning a Generator[Any, Any, T], then this returns T, else it returns the return type directly.

[JelleZijlstra]

This seems important to fix because otherwise we lose type checking for the object returned from the asynq function.

[dkang-quora]

I need to think more about edge cases. Can we merge this PR and make the return type a separate discussion?

@asynq()
def f1() -> Generator[Any, Any, int]:
    yield op1
    yield op2
    return 100

@asynq()
def f2() -> Generator[Any, Any, int]:
    return normal_generator_that_returns_int

(await f1.asyncio()) -> int
(await f2.asyncio()) -> Generator[Any, Any, int]

[dkang-quora]

• Case: the function body has yield (inspect.isgeneratorfunction = True)
  fn: Callable[..., Generator[?, ?, T]] -> return: T
• Case: the function body no yield (inspect.isgeneratorfunction = False)
  fn: Callable[..., T] -> return: T

inspect.isgeneratorfunction cannot be expressed in type annotations.
Not sure if this kind of dynamic type checking would work:

return_type = TypeVar('T')

if TYPE_CHECKING:
    if inspect.isgeneratorfunction(fn):
        orig_fn: Callable[..., Generator[Any, Any, T]] = fn
        new_fn: Callable[... T] =...
        return new_fn 
    else:
        orig_fn: Callable[..., T] = fn
        new_fn: Callable[... T] =...
        return new_fn

[JelleZijlstra]

Yeah, we can leave this for another PR. What you're suggesting won't work in a stub; I think we need to somehow overload __init__.