(api-break) renew APIs

Author: gottadiveintopython

src/asyncgui_ext/synctools/all.py

@@ -1,4 +1,6 @@
 __all__ = (
-    'Event',
+    'Event', 'Box',
 )
 from .event import Event
+from .box import Box
+

src/asyncgui_ext/synctools/box.py

@@ -0,0 +1,74 @@
+__all__ = ('Box', )
+import types
+
+
+class Box:
+    '''
+    Similar to :class:`asyncgui.AsyncBox`, but this one can handle multiple tasks simultaneously.
+    This is the closest thing to :class:`asyncio.Event` in this library.
+
+    .. code-block::
+
+        async def async_fn(b1, b2):
+            args, kwargs = await b1.get()
+            assert args == (1, )
+            assert kwargs == {'crow': 'raven', }
+
+            args, kwargs = await b2.get()
+            assert args == (2, )
+            assert kwargs == {'frog': 'toad', }
+
+            args, kwargs = await b1.get()
+            assert args == (1, )
+            assert kwargs == {'crow': 'raven', }
+
+        b1 = Box()
+        b2 = Box()
+        b1.put(1, crow='raven')
+        start(async_fn(b1, b2))
+        b2.put(2, frog='toad')
+    '''
+
+    __slots__ = ('_item', '_waiting_tasks', )
+
+    def __init__(self):
+        self._item = None
+        self._waiting_tasks = []
+
+    @property
+    def is_empty(self) -> bool:
+        return self._item is None
+
+    def put(self, *args, **kwargs):
+        '''Put an item into the box if it's empty.'''
+        if self._item is None:
+            self.put_or_update(*args, **kwargs)
+
+    def update(self, *args, **kwargs):
+        '''Replace the item in the box if there is one already.'''
+        if self._item is not None:
+            self.put_or_update(*args, **kwargs)
+
+    def put_or_update(self, *args, **kwargs):
+        self._item = (args, kwargs, )
+        tasks = self._waiting_tasks
+        self._waiting_tasks = []
+        for t in tasks:
+            if t is not None:
+                t._step(*args, **kwargs)
+
+    def clear(self):
+        '''Remove the item from the box if there is one.'''
+        self._item = None
+
+    @types.coroutine
+    def get(self):
+        '''Get the item from the box if there is one. Otherwise, wait until it's put.'''
+        if self._item is not None:
+            return self._item
+        tasks = self._waiting_tasks
+        idx = len(tasks)
+        try:
+            return (yield tasks.append)
+        finally:
+            tasks[idx] = None

src/asyncgui_ext/synctools/event.py

@@ -1,64 +1,46 @@
-__all__ = (
-    'Event',
-)
+__all__ = ('Event', )
 import types
-import typing as T
 
 
 class Event:
     '''
-    Similar to :class:`asyncio.Event`.
-    The differences are:
-
-    * :meth:`set` accepts any number of arguments but doesn't use them at all so it can be used as a callback function
-      in any library.
-    * :attr:`is_set` is a property not a function.
+    Similar to :class:`asyncgui.AsyncEvent`, but this one can handle multiple tasks simultaneously.
 
     .. code-block::
 
+        async def async_fn(e):
+            args, kwargs = await e.wait()
+            assert args == (2, )
+            assert kwargs == {'crow': 'raven', }
+
+            args, kwargs = await e.wait()
+            assert args == (3, )
+            assert kwargs == {'toad': 'frog', }
+
         e = Event()
-        any_library.register_callback(e.set)
+        e.fire(1, crocodile='alligator')
+        start(async_fn(e))
+        e.fire(2, crow='raven')
+        e.fire(3, toad='frog')
     '''
 
-    __slots__ = ('_flag', '_waiting_tasks', )
+    __slots__ = ('_waiting_tasks', )
 
     def __init__(self):
-        self._flag = False
         self._waiting_tasks = []
 
-    @property
-    def is_set(self) -> bool:
-        return self._flag
-
-    def set(self, *args, **kwargs):
-        '''
-        Set the event.
-        Unlike asyncio's, all tasks waiting for this event to be set will be resumed *immediately*.
-        '''
-        if self._flag:
-            return
-        self._flag = True
+    def fire(self, *args, **kwargs):
         tasks = self._waiting_tasks
         self._waiting_tasks = []
         for t in tasks:
             if t is not None:
-                t._step()
-
-    def clear(self):
-        '''Unset the event.'''
-        self._flag = False
+                t._step(*args, **kwargs)
 
     @types.coroutine
-    def wait(self) -> T.Awaitable:
-        '''
-        Wait for the event to be set.
-        Return *immediately* if it's already set.
-        '''
-        if self._flag:
-            return
+    def wait(self):
+        tasks = self._waiting_tasks
+        idx = len(tasks)
         try:
-            tasks = self._waiting_tasks
-            idx = len(tasks)
-            yield tasks.append
+            return (yield tasks.append)
         finally:
             tasks[idx] = None

tests/test_box.py

@@ -0,0 +1,102 @@
+import pytest
+
+
+def test_get_then_put():
+    import asyncgui as ag
+    from asyncgui_ext.synctools.box import Box
+    TS = ag.TaskState
+    b = Box()
+    t1 = ag.start(b.get())
+    t2 = ag.start(b.get())
+    assert t1.state is TS.STARTED
+    assert t2.state is TS.STARTED
+    b.put(7, crow='raven')
+    assert t1.result == ((7, ), {'crow': 'raven', })
+    assert t2.result == ((7, ), {'crow': 'raven', })
+
+
+def test_put_then_get():
+    import asyncgui as ag
+    from asyncgui_ext.synctools.box import Box
+    TS = ag.TaskState
+    b = Box()
+    b.put(7, crow='raven')
+    t1 = ag.start(b.get())
+    t2 = ag.start(b.get())
+    assert t1.state is TS.FINISHED
+    assert t2.state is TS.FINISHED
+    assert t1.result == ((7, ), {'crow': 'raven', })
+    assert t2.result == ((7, ), {'crow': 'raven', })
+
+
+def test_clear():
+    import asyncgui as ag
+    from asyncgui_ext.synctools.box import Box
+    b1 = Box()
+    b2 = Box()
+
+    async def async_fn():
+        assert (await b1.get()) == ((7, ), {'crow': 'raven', })
+        assert (await b2.get()) == ((6, ), {'crocodile': 'alligator', })
+        assert (await b1.get()) == ((5, ), {'toad': 'frog', })
+
+    task = ag.start(async_fn())
+    b1.put(7, crow='raven')
+    b1.clear()
+    b2.put(6, crocodile='alligator')
+    b1.put(5, toad='frog')
+    assert task.finished
+
+
+def test_cancel():
+    import asyncgui as ag
+    from asyncgui_ext.synctools.box import Box
+    TS = ag.TaskState
+
+    async def async_fn(ctx, b):
+        async with ag.open_cancel_scope() as scope:
+            ctx['scope'] = scope
+            await b.get()
+            pytest.fail()
+        await ag.sleep_forever()
+
+    ctx = {}
+    b = Box()
+    task = ag.start(async_fn(ctx, b))
+    assert task.state is TS.STARTED
+    ctx['scope'].cancel()
+    assert task.state is TS.STARTED
+    b.put()
+    assert task.state is TS.STARTED
+    task._step()
+    assert task.state is TS.FINISHED
+
+
+def test_complicated_cancel():
+    import asyncgui as ag
+    from asyncgui_ext.synctools.box import Box
+    TS = ag.TaskState
+
+    async def async_fn_1(ctx, b):
+        await b.get()
+        ctx['scope'].cancel()
+
+    async def async_fn_2(ctx, b):
+        async with ag.open_cancel_scope() as scope:
+            ctx['scope'] = scope
+            await b.get()
+            pytest.fail()
+        await ag.sleep_forever()
+
+    ctx = {}
+    b = Box()
+    t1 = ag.start(async_fn_1(ctx, b))
+    t2 = ag.start(async_fn_2(ctx, b))
+    assert b._waiting_tasks == [t1, t2, ]
+    assert t2.state is TS.STARTED
+    b.put()
+    assert t1.state is TS.FINISHED
+    assert t2.state is TS.STARTED
+    assert b._waiting_tasks == []
+    t2._step()
+    assert t2.state is TS.FINISHED

tests/test_event.py

@@ -1,59 +1,33 @@
 import pytest
 
 
-def test_wait_then_set():
+def test_wait_then_fire():
     import asyncgui as ag
     from asyncgui_ext.synctools.event import Event
     TS = ag.TaskState
     e = Event()
-    task1 = ag.start(e.wait())
-    task2 = ag.start(e.wait())
-    assert task1.state is TS.STARTED
-    assert task2.state is TS.STARTED
-    e.set()
-    assert task1.state is TS.FINISHED
-    assert task2.state is TS.FINISHED
+    t1 = ag.start(e.wait())
+    t2 = ag.start(e.wait())
+    assert t1.state is TS.STARTED
+    assert t2.state is TS.STARTED
+    e.fire(7, crow='raven')
+    assert t1.result == ((7, ), {'crow': 'raven', })
+    assert t2.result == ((7, ), {'crow': 'raven', })
 
 
-def test_set_then_wait():
+def test_fire_then_wait_then_fire():
     import asyncgui as ag
     from asyncgui_ext.synctools.event import Event
     TS = ag.TaskState
     e = Event()
-    e.set()
-    task1 = ag.start(e.wait())
-    task2 = ag.start(e.wait())
-    assert task1.state is TS.FINISHED
-    assert task2.state is TS.FINISHED
-
-
-def test_clear():
-    import asyncgui as ag
-    from asyncgui_ext.synctools.event import Event
-    e1 = Event()
-    e2 = Event()
-
-    async def main():
-        nonlocal task_state
-        task_state = 'A'
-        await e1.wait()
-        task_state = 'B'
-        await e2.wait()
-        task_state = 'C'
-        await e1.wait()
-        task_state = 'D'
-
-    task_state = None
-    ag.start(main())
-    assert task_state == 'A'
-    e1.set()
-    assert task_state == 'B'
-    e1.clear()
-    assert task_state == 'B'
-    e2.set()
-    assert task_state == 'C'
-    e1.set()
-    assert task_state == 'D'
+    e.fire(8, crocodile='alligator')
+    t1 = ag.start(e.wait())
+    t2 = ag.start(e.wait())
+    assert t1.state is TS.STARTED
+    assert t2.state is TS.STARTED
+    e.fire(7, crow='raven')
+    assert t1.result == ((7, ), {'crow': 'raven', })
+    assert t2.result == ((7, ), {'crow': 'raven', })
 
 
 def test_cancel():
@@ -74,7 +48,7 @@ async def async_fn(ctx, e):
     assert task.state is TS.STARTED
     ctx['scope'].cancel()
     assert task.state is TS.STARTED
-    e.set()
+    e.fire()
     assert task.state is TS.STARTED
     task._step()
     assert task.state is TS.FINISHED
@@ -86,7 +60,7 @@ def test_complicated_cancel():
     TS = ag.TaskState
 
     async def async_fn_1(ctx, e):
-        await e.wait()
+        assert (await e.wait()) == ((7, ), {'crow': 'raven', })
         ctx['scope'].cancel()
 
     async def async_fn_2(ctx, e):
@@ -98,13 +72,13 @@ async def async_fn_2(ctx, e):
 
     ctx = {}
     e = Event()
-    task1 = ag.start(async_fn_1(ctx, e))
-    task2 = ag.start(async_fn_2(ctx, e))
-    assert e._waiting_tasks == [task1, task2, ]
-    assert task2.state is TS.STARTED
-    e.set()
-    assert task1.state is TS.FINISHED
-    assert task2.state is TS.STARTED
+    t1 = ag.start(async_fn_1(ctx, e))
+    t2 = ag.start(async_fn_2(ctx, e))
+    assert e._waiting_tasks == [t1, t2, ]
+    assert t2.state is TS.STARTED
+    e.fire(7, crow='raven')
+    assert t1.state is TS.FINISHED
+    assert t2.state is TS.STARTED
     assert e._waiting_tasks == []
-    task2._step()
-    assert task2.state is TS.FINISHED
+    t2._step()
+    assert t2.result is None