Relationship to upstream RPyC

The upstream commit history is preserved in this repository, so authorship and provenance of the original RPyC code remain visible in git log. See LICENSE and CONTRIBUTORS for attribution.

Installation

pip install rpyc-async

Requires Python 3.10+. The fork’s import name is rpyc_async, while upstream RPyC still uses rpyc — the two distributions can be installed side by side in the same environment. If you only need the classic synchronous API, install upstream RPyC (pip install rpyc); if you need the asyncio-native API, install this fork (pip install rpyc-async).

Existing code written for upstream can keep the shorter rpyc. spelling by aliasing the import at the top of each module:

import rpyc_async as rpyc

All examples in this README use that alias.

Platform Support

Quick Examples

ThreadedServer (for simple sync/unidirectional async):

from rpyc_async import ThreadedServer, Service

class MyService(Service):
    def exposed_sync_method(self, x):
        return x * 2

server = ThreadedServer(MyService, port=18861)
server.start()

AsyncioServer (for bidirectional async with callbacks):

from rpyc_async import AsyncioServer, Service
import asyncio

class MyService(Service):
    async def exposed_async_with_callback(self, callback, value):
        # Server can call client's async callback
        result = await callback(value * 2)
        return f"Got: {result}"

async def main():
    server = AsyncioServer(MyService, port=18861)
    await server.start()
    # Server runs in background, handle other tasks
    await asyncio.sleep(3600)  # or other async work

asyncio.run(main())

Client for AsyncioServer — use await rpyc.async_connect(...), NOT rpyc.connect():

import rpyc_async as rpyc
import asyncio

async def main():
    conn = await rpyc.async_connect("localhost", 18861)
    try:
        # Native async method — just await.
        result = await conn.root.some_async_method(42)
        # Sync remote method? Wrap with rpyc.async_() to stay event-driven.
        # Keep the wrapper in a variable: it is cached behind a weak ref.
        a_sync = rpyc.async_(conn.root.some_sync_method)
        sync_result = await a_sync(42)
    finally:
        await conn.aclose()   # not conn.close() — that blocks the loop

asyncio.run(main())

rpyc.connect() is synchronous — it blocks socket.connect and every later sync_request on the calling thread. From inside an asyncio event loop it now raises RuntimeError pointing at rpyc.async_connect. See docs/DESIGN_ASYNC_CONNECT_POLICY.md.

For more details on async support, see docs/LIMITATIONS.md.

Documentation

• Migration Guide — moving to the asyncio-native API

• API Reference

• Examples

• Limitations

Documentation for classic synchronous RPyC lives at https://rpyc.readthedocs.io