Async Coroutine was never awaited. (Missing __await__ method)

[TheMasteredPanda]

Describe the issue briefly here, including:

Testing out RpyC for the groundwork of a project. I've setup a custom service that runs Discord.py on a seperate thread while RpyC runs on the main thread. I expected, from studying the documentation on RpyC, that the async_ wrapper is used for remote execution of asynchronous functions, and that executing a function wrapped in async_ would produce, in my case, a text message sent on on a text channel in a Discord Server.

The actual result is an error that is thrown service side stating that the "coroutine 'Messable.send' was never awaited".

Steps to reproduce:
Copy the server code into a script and run, obviously you'll need to fetch a key from the Discord Developer Console.
Run the client code in a script, you'll need to create a Discord guild/server you to add the bot to as well as supply the correct guild id and channel id. the result should produce the same error I have.

/home/johndoe/.local/lib/python3.10/site-packages/rpyc/core/protocol.py:362: RuntimeWarning: coroutine 'Messageable.send' was never awaited
  self._dispatch_request(seq, args)

Environment

• rpyc version: 5.2.3
• python version: 3.10
• operating system: Kali Linux

Minimal example

Server:

from threading import Thread
import rpyc
from rpyc.utils.server import ThreadedServer
import discord
from discord.ext.commands import Bot, when_mentioned_or
import asyncio

client = discord.Client(intents=discord.Intents.all())

class DiscordService(rpyc.Service):
    def __init__(self):
        super().__init__()
        loop = asyncio.get_event_loop()
        loop.create_task(client.start('key'))
        Thread(target=loop.run_forever).start()
        print('Started Client.')

    exposed_client = client

    @client.event
    async def on_ready():
        await client.get_channel(836607364832296990).send('This is from the service')


t = ThreadedServer(DiscordService(), port=18861, protocol_config={'allow_public_attrs': True})
print('Starting service.')
t

Client:

import rpyc
from rpyc.utils.helpers import _Async
import discord
import asyncio

conn = rpyc.connect('localhost', port=18861)
d_client: discord.Client = conn.root.exposed_client
channel: discord.TextChannel = d_client.get_guild(412361411159785493).get_channel(836607364832296990)
channel_send = rpyc.async_(channel.send)
c_result = channel_send('testing')
c_result.wait()

For benefit of ease, the function I am attempting to execute clientside (the send function): https://discordpy.readthedocs.io/en/stable/api.html?highlight=textchannel#discord.TextChannel.send

[notEvil]

The error you get is not related to rpyc. You try to call an async function outside of an event loop.

I expected, from studying the documentation on RpyC, that the async_ wrapper is used for remote execution of asynchronous functions,

rpyc is not async in asyncio terminology. rpyc.async_ gives you the opportunity to do things while the remote is busy, but its still synchronous

[comrumino]

@notEvil is correct. There is room for improvement in the current design. Since that functionality was released in 2015 and tracing the source for async_.py goes all the way back to 2009, I think AsyncResult is in need of an update.

It seems that the current design is older than awaitable objects and coroutine functions. I think the starting point here is seeing if what functionality is needed:

• the __await__ method on the AsyncResult object.
• considering making __await__ a safe attribute, in rpyc/core/protocol.py
• determine if we can enhance AsyncResult in a backwards compatible way.

[eliiik]

Any update on it? want this feature, too

[glyh]

If there's nobody working on this I may take a look on it.

[comrumino]

I'm always open to taking PRs. I haven't spent as much time as I used to maintaining RPyC since my current employer does not use it.