Yeah, the simplest approach is to create a trio.BlockingTrioPortal, which will let you call whatever Trio functions and methods you want from your thread -- in particular, but not restricted to, trio.Queue.put and trio.Queue.get.

Trio doesn't have Curio's feature of magically introspecting the calling context to automatically decide which functions should be wrapped in a call to BlockingTrioPortal.run -- I think it's too magical and fragile to belong in a foundational library like this. (If you look at Curio's code for this, it involves things like doing string comparisons on the names of stack frames.) If you find calling portal.run all the time too tedious, though, you can make a little helper class like:

class BlockingQueueWrapper:
    def __init__(self, queue, portal):
        self.queue = queue
        self.portal = portal

    def put(self, value):
        self.portal.run(self.queue.put, value)

    def get(self):
        return self.portal.run(self.queue.get, value)

    def put_nowait(self, value):
        self.portal.run_sync(self.queue.put_nowait, value)

    def get_nowait(self):
        return self.portal.run_sync(self.queue.get_nowait)

Then you can do something like:

queue = trio.Queue()
portal = trio.BlockingTrioPortal()
blocking_queue = BlockingQueueWrapper(queue, portal)
await run_sync_in_worker_thread(my_func, blocking_queue)

and my_func can freely use blocking_queue.get, .put, .get_nowait, .put_nowait.

Or maybe it's possible to automatically generate class wrappers like this, so we could have blocking_queue = portal.autowrap(queue)? I dunno, if you come up with something cool then let us know, maybe it should go into trio or into a utility library or something :-). We're still feeling out the best way to expose all this functionality.

Uh oh!

UniversalQueue ala curio #449

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions