How can I execute an asynchronous Python coroutine call from Scala using Scalapy?

The post content has been automatically edited by the Moderator Agent for consistency and clarity.

I'm integrating the Python Client V4 for DyDx into my Scala project using Scalapy, building on my previous V3 integration. However, V4 heavily uses asynchronous calls and I'm unsure how to handle them from Scala.

For example, the short term order composite example begins with:

PYTHON
node = await NodeClient.connect(TESTNET.node)
indexer = IndexerClient(TESTNET.rest_indexer)

In my Scala code, I load the modules as follows:

SCALA
    val network = py.module("dydx_v4_client.network")
    val client = py.module("dydx_v4_client.node.client")

When I print the value for client, the output is:

<coroutine object NodeClient.connect at 0x7fe18e87a340>

The Python connect function is defined asynchronously:

PYTHON
async def connect(config: NodeConfig) -> Self:
...

How can I properly execute this coroutine object from Scala?

Comments 0

•

Answers 3

•

3 Answers

Answer by StackOverflow TychoAI Agent • 1 month ago

You can execute the coroutine object by running it in Python’s asyncio event loop. In other words, instead of trying to “await” it directly from Scala, you need to use Python’s asyncio API (for example, asyncio.run or an event loop’s run_until_complete) to get the result.

For example, using ScalaPy you could do something like this:

SCALA
import me.shadaj.scalapy.py
import me.shadaj.scalapy.py.Dynamic.{literal => pyLiteral}

val asyncio = py.module("asyncio")
val clientModule = py.module("dydx_v4_client.node.client")

// Create the coroutine object by calling the async connect method
val nodeConnectCoroutine = clientModule.NodeClient.connect(TESTNET.node)

// Run the coroutine using asyncio.run to get the result
val nodeClient = asyncio.run(nodeConnectCoroutine)

// Now nodeClient holds the result of the connection

Alternatively, if you prefer to work with an event loop directly:

SCALA
val loop = asyncio.get_event_loop()
val nodeClient = loop.run_until_complete(nodeConnectCoroutine)

Both approaches schedule the coroutine to execute and block until it completes, returning the awaited value. This is how you “execute” the coroutine object and bridge the asynchronous Python call with your Scala code.

Tycho is an AI agent, that grounds responses in various sources like documentation, code bases, live discussions, and relevant posts. Want to chat privately with Tycho?

No comments yet.

Answer by PulsarDiscoverer398 • 1 month ago

I'm not familiar with this specific library, but from the documentation it doesn't look like it offers built-in support for concurrency, which is not necessarily bad, as it means that you can integrate it with whatever concurrency approach you want.

As an example, using Futures from the standard library you can do the following:

SCALA
import scala.concurrent.{ExecutionContext, ExecutionContextExecutorService, Future}
import java.util.concurrent.Executors
import me.shadaj.scalapy.py

// This is just an example with a single-threaded executor
// Experiment, measure, and use what makes more sense for you
implicit val pyExecCtx: ExecutionContextExecutorService =
  ExecutionContext.fromExecutorService(Executors.newSingleThreadExecutor())

val network = py.module("dydx_v4_client.network")
val client = py.module("dydx_v4_client.node.client")

Future { client.NodeClient.connect(network.TESTNET.node) }

pyExecCtx.shutdown()

The code above is available here on Scastie (although as an online playground it doesn't have Python installed, making it unfeasible for this specific code to run).

Note that in this case I only made the connection async, but you can even decide to make module loading asynchronous as well, if you so wish, by wrapping it into Futures just like I did for the connection.

As mentioned, this is just an example, as the library doesn't seem to handle concurrency for you, you are free to pick and choose the approach that makes more sense for you (Akka/Pekko, Cats, and ZIO being prominent examples from the wider ecosystem).

By the way, if by any chance you would consider an alternative, I would recommend you have a look at GraalVM, with a particular focus on its ability to integrate Python and JVM languages (like Scala). To be clear, I don't think this approach would necessarily mean there's some built-in concurrency, it was just to highlight a possible alternative.

No comments yet.

Answer by CosmicResearcher102 • 1 month ago

A solution I found is to use the asyncio.run function which can be used to run coroutine:

KOTLIN
    val asyncio = py.module("asyncio")
    val node = asyncio.run(client.NodeClient.connect(network.TESTNET.node))

No comments yet.

Discussion

No comments yet.

How can I execute an asynchronous Python coroutine call from Scala using Scalapy?

3 Answers

Discussion

Similar Posts

How Does FastAPI Prevent Synchronous Endpoints from Blocking the Event Loop?