63b9944382
This commit adds a completely new implementation of the uasyncio module. The aim of this version (compared to the original one in micropython-lib) is to be more compatible with CPython's asyncio module, so that one can more easily write code that runs under both MicroPython and CPython (and reuse CPython asyncio libraries, follow CPython asyncio tutorials, etc). Async code is not easy to write and any knowledge users already have from CPython asyncio should transfer to uasyncio without effort, and vice versa. The implementation here attempts to provide good compatibility with CPython's asyncio while still being "micro" enough to run where MicroPython runs. This follows the general philosophy of MicroPython itself, to make it feel like Python. The main change is to use a Task object for each coroutine. This allows more flexibility to queue tasks in various places, eg the main run loop, tasks waiting on events, locks or other tasks. It no longer requires pre-allocating a fixed queue size for the main run loop. A pairing heap is used to queue Tasks. It's currently implemented in pure Python, separated into components with lazy importing for optional components. In the future parts of this implementation can be moved to C to improve speed and reduce memory usage. But the aim is to maintain a pure-Python version as a reference version.
32 lines
1.0 KiB
Python
32 lines
1.0 KiB
Python
# MicroPython uasyncio module
|
|
# MIT license; Copyright (c) 2019-2020 Damien P. George
|
|
|
|
from . import core
|
|
|
|
# Event class for primitive events that can be waited on, set, and cleared
|
|
class Event:
|
|
def __init__(self):
|
|
self.state = False # False=unset; True=set
|
|
self.waiting = core.TaskQueue() # Queue of Tasks waiting on completion of this event
|
|
|
|
def is_set(self):
|
|
return self.state
|
|
|
|
def set(self):
|
|
# Event becomes set, schedule any tasks waiting on it
|
|
while self.waiting.peek():
|
|
core._task_queue.push_head(self.waiting.pop_head())
|
|
self.state = True
|
|
|
|
def clear(self):
|
|
self.state = False
|
|
|
|
async def wait(self):
|
|
if not self.state:
|
|
# Event not set, put the calling task on the event's waiting queue
|
|
self.waiting.push_head(core.cur_task)
|
|
# Set calling task's data to the event's queue so it can be removed if needed
|
|
core.cur_task.data = self.waiting
|
|
yield
|
|
return True
|