Use multimethod to integrate asynchronous methods with the same arguments

[rroblf01]

I just discovered this project and my sincerest congratulations; I find it very interesting.

I was working on a Python project and we were migrating code from WSGI to ASGI, and this could help us a lot if we could do something like this:

from multimethod import multimethod
import asyncio


class Foo:
    @multimethod
    def bar(cls, arg: str):
        return f"Sync method called with: {arg}"

    @bar.register
    async def _(cls, arg: str):
        return f"Async method called with: {arg}"

    bar = classmethod(bar)

c = Foo()
print(c.bar("hello"))  # Calls the sinc version
print(asyncio.run(c.bar("42")))  # Calls the async version

I don't know if this is very complicated or simply impossible haha, but I think it would be very useful for this library.

[coady]

#137 (comment)

Assuming

• _called_from_async works as designed - inspect.currentframe().f_back may also be worth looking at
• the sync function is distinct from the async version - no asyncio.run
  then a solution could be

def synced(func, afunc):
    def run(*args, **kwargs):
        f = afunc if _called_from_async() else func
        return f(*args, **kwargs)
    return run

Further assuming

• decorator usage
• dynamically determining the async version - note a def function can still return a coroutine but wouldn't pass inspect.iscoroutinefunction
  then the above could be expanded into a class

class synced:
    def __init__(self, func):
        if inspect.iscoroutinefunction(func):
            self.afunc = func
        else:
            self.func = func

    register = __init__

    def __get__(self, instance, owner):
        return self if instance is None else types.MethodType(self, instance)

    def __call__(self, *args, **kwargs):
        f = self.afunc if _called_from_async() else self.func
        return f(*args, **kwargs)

That's sufficient to implement the Calculator.add example.

The part I'm struggling with is how this relates to argument-based dispatch. It's analogous to property, in that there's a fixed set of functions to wrap, and use the caller's context.