* Python >= 3.9

* [trio_async](trio_async) - Use asyncio Temporal in Trio-based environments.

python = "^3.9"

[tool.poetry.group.trio_async]

optional = true

dependencies = { trio = "^0.28.0", trio-asyncio = "^0.15.0" }

import uuid

import trio_asyncio

from temporalio.client import Client

from temporalio.worker import Worker

from trio_async import activities, workflows

async def test_workflow_with_trio(client: Client):

@trio_asyncio.aio_as_trio

async def inside_trio(client: Client) -> list[str]:

# Create Trio thread executor

with trio_asyncio.TrioExecutor(max_workers=200) as thread_executor:

task_queue = f"tq-{uuid.uuid4()}"

# Run worker

async with Worker(

client,

task_queue=task_queue,

activities=[

activities.say_hello_activity_async,

activities.say_hello_activity_sync,

],

workflows=[workflows.SayHelloWorkflow],

activity_executor=thread_executor,

workflow_task_executor=thread_executor,

):

# Run workflow and return result

return await client.execute_workflow(

workflows.SayHelloWorkflow.run,

"some-user",

id=f"wf-{uuid.uuid4()}",

task_queue=task_queue,

)

result = trio_asyncio.run(inside_trio, client)

assert result == [

"Hello, some-user! (from asyncio)",

"Hello, some-user! (from thread)",

]

This sample shows how to use Temporal asyncio with [Trio](https://trio.readthedocs.io) using

[Trio asyncio](https://trio-asyncio.readthedocs.io). Specifically it demonstrates using a traditional Temporal client

and worker in a Trio setting, and how Trio-based code can run in both asyncio async activities and threaded sync

activities.

For this sample, the optional `trio_async` dependency group must be included. To include, run:

poetry install --with trio_async

To run, first see [README.md](../README.md) for prerequisites. Then, run the following from this directory to start the

worker:

poetry run python worker.py

This will start the worker. Then, in another terminal, run the following to execute the workflow:

poetry run python starter.py

The starter should complete with:

INFO:root:Workflow result: ['Hello, Temporal! (from asyncio)', 'Hello, Temporal! (from thread)']

import asyncio

import time

import trio

import trio_asyncio

from temporalio import activity

async def say_hello_activity_async(name: str) -> str:

# Demonstrate a sleep in both asyncio and Trio, showing that both asyncio

# and Trio primitives can be used

# First asyncio

activity.logger.info("Sleeping in asyncio")

await asyncio.sleep(0.1)

# Now Trio. We have to invoke the function separately decorated.

# We cannot use the @trio_as_aio decorator on the activity itself because

# it doesn't use functools wrap or similar so it doesn't respond to things

# like __name__ that @activity.defn needs.

return await say_hello_in_trio_from_asyncio(name)

async def say_hello_in_trio_from_asyncio(name: str) -> str:

activity.logger.info("Sleeping in Trio (from asyncio)")

await trio.sleep(0.1)

return f"Hello, {name}! (from asyncio)"

def say_hello_activity_sync(name: str) -> str:

# Demonstrate a sleep in both threaded and Trio, showing that both

# primitives can be used

# First, thread-blocking

activity.logger.info("Sleeping normally")

time.sleep(0.1)

# Now Trio. We have to use Trio's thread sync tools to run trio calls from

# a different thread.

return trio.from_thread.run(say_hello_in_trio_from_sync, name)

async def say_hello_in_trio_from_sync(name: str) -> str:

activity.logger.info("Sleeping in Trio (from thread)")

await trio.sleep(0.1)

return f"Hello, {name}! (from thread)"

import logging

import trio_asyncio

from temporalio.client import Client

from trio_async import workflows

async def main():

logging.basicConfig(level=logging.INFO)

# Connect client

client = await Client.connect("localhost:7233")

# Execute the workflow

result = await client.execute_workflow(

workflows.SayHelloWorkflow.run,

"Temporal",

id=f"trio-async-workflow-id",

task_queue="trio-async-task-queue",

)

logging.info(f"Workflow result: {result}")

if __name__ == "__main__":

# Note how we're using Trio event loop, not asyncio

trio_asyncio.run(main)