WIP uasyncio.core: Trying to implement wait_for function.

Contains history of previous attempts. Only pend_throw() works as expected.

Author: Paul Sokolovsky

uasyncio.core/uasyncio/core.py

@@ -15,10 +15,15 @@ def set_debug(val):
         log = logging.getLogger("uasyncio.core")
 
 
+class TimeoutError(Exception):
+    pass
+
+
 class EventLoop:
 
     def __init__(self, len=42):
         self.q = utimeq.utimeq(len)
+        self.timed_out = {}
 
     def time(self):
         return time.ticks_ms()
@@ -80,12 +85,18 @@ def run_forever(self):
             if callable(cb):
                 cb(*args)
             else:
+                if cb in self.timed_out:
+                    print("%r timed out" % cb)
+                    1/0
                 delay = 0
                 try:
                     if __debug__ and DEBUG:
                         log.debug("Coroutine %s send args: %s", cb, args)
                     if args == ():
                         ret = next(cb)
+                    elif isinstance(args[0], Exception):
+                        print("Throwing %r into %r" % (args, cb))
+                        cb.throw(*args)
                     else:
                         ret = cb.send(*args)
                     if __debug__ and DEBUG:
@@ -211,6 +222,56 @@ def __next__(self):
 _stop_iter = StopIteration()
 sleep_ms = SleepMs()
 
+def _wait_for(coro, timeout):
+    def timeout_func():
+        print("timeout")
+#        raise TimeoutError
+        coro.throw(TimeoutError)
+
+    _event_loop.call_later(timeout, timeout_func)
+    #_event_loop.call_soon(coro)
+    #_event_loop.run_forever()
+    res = yield from coro
+    return res
+
+    if 0:
+        yield
+
+
+class TimeoutObj:
+    def __init__(self, coro):
+        self.coro = coro
+        self.active = True
+    def cancel(self):
+        self.core = None
+        self.active = False
+
+def wait_for(coro, timeout):
+
+    def waiter(coro, to):
+        res = yield from coro
+        to.cancel()
+        return res
+
+    def timeout_func(to):
+        if to.active:
+            print("timeout_func: cancelling", coro)
+#            raise TimeoutError
+#            coro.throw(TimeoutError)
+#            _event_loop.call_soon(coro, TimeoutError())
+#            _event_loop.call_soon(w, TimeoutError())
+#            _event_loop.timed_out[coro] = True
+            to.coro.pend_throw(TimeoutError())
+#            w.pend_throw(TimeoutError())
+        else:
+            print("timeout_func: timeout was cancelled")
+
+    timeout_obj = TimeoutObj(coro)
+    _event_loop.call_later(timeout, timeout_func, timeout_obj)
+    w = waiter(coro, timeout_obj)
+    res = yield from w
+    return res
+
 
 def coroutine(f):
     return f