Release v0.4.0

Add method specific route decorators
Update microypthon binary to 1.15
2021-06-04 17:16:18 +01:00 · 2021-06-04 17:14:38 +01:00 · 2021-06-04 16:57:51 +01:00 · 2021-06-04 16:01:07 +01:00
26 changed files with 1123 additions and 641 deletions
--- a/bin/micropython
+++ b/bin/micropython
--- a/examples/hello.py
+++ b/examples/hello.py
@@ -2,7 +2,7 @@ from microdot import Microdot, Response

 app = Microdot()

-htmldoc = """<!DOCTYPE html>
+htmldoc = '''<!DOCTYPE html>
 <html>
    <head>
        <title>Microdot Example Page</title>
@@ -11,16 +11,22 @@ htmldoc = """<!DOCTYPE html>
        <div>
            <h1>Microdot Example Page</h1>
            <p>Hello from Microdot!</p>
+            <p><a href="/shutdown">Click to shutdown the server</a></p>
        </div>
    </body>
 </html>
-"""
+'''


-@app.route("", methods=["GET", "POST"])
-def serial_number(request):
-    print(request.headers)
-    return Response(body=htmldoc, headers={"Content-Type": "text/html"})
+@app.route('/')
+def hello(request):
+    return Response(body=htmldoc, headers={'Content-Type': 'text/html'})
+
+
+@app.route('/shutdown')
+def shutdown(request):
+    request.app.shutdown()
+    return 'The server is shutting down...'


 app.run(debug=True)
--- a/examples/hello_async.py
+++ b/examples/hello_async.py
@@ -0,0 +1,40 @@
+try:
+    import uasyncio as asyncio
+except ImportError:
+    import asyncio
+from microdot_asyncio import Microdot, Response
+
+app = Microdot()
+
+htmldoc = '''<!DOCTYPE html>
+<html>
+    <head>
+        <title>Microdot Example Page</title>
+    </head>
+    <body>
+        <div>
+            <h1>Microdot Example Page</h1>
+            <p>Hello from Microdot!</p>
+            <p><a href="/shutdown">Click to shutdown the server</a></p>
+        </div>
+    </body>
+</html>
+'''
+
+
+@app.route('/')
+async def hello(request):
+    return Response(body=htmldoc, headers={'Content-Type': 'text/html'})
+
+
+@app.route('/shutdown')
+async def shutdown(request):
+    request.app.shutdown()
+    return 'The server is shutting down...'
+
+
+async def main():
+    await app.start_server(debug=True)
+
+
+asyncio.run(main())
--- a/microdot-asyncio/microdot_asyncio.py
+++ b/microdot-asyncio/microdot_asyncio.py
@@ -14,7 +14,7 @@ def _iscoroutine(coro):

 class Request(BaseRequest):
    @staticmethod
-    async def create(stream, client_addr):
+    async def create(app, stream, client_addr):
        # request line
        line = (await stream.readline()).strip().decode()
        if not line:  # pragma: no cover
@@ -39,7 +39,8 @@ class Request(BaseRequest):
        body = await stream.read(content_length) \
            if content_length else b''

-        return Request(client_addr, method, url, http_version, headers, body)
+        return Request(app, client_addr, method, url, http_version, headers,
+                       body)


 class Response(BaseResponse):
@@ -75,7 +76,7 @@ class Response(BaseResponse):


 class Microdot(BaseMicrodot):
-    def run(self, host='0.0.0.0', port=5000, debug=False):
+    async def start_server(self, host='0.0.0.0', port=5000, debug=False):
        self.debug = debug

        async def serve(reader, writer):
@@ -98,13 +99,19 @@ class Microdot(BaseMicrodot):
        if self.debug:  # pragma: no cover
            print('Starting async server on {host}:{port}...'.format(
                host=host, port=port))
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(asyncio.start_server(serve, host, port))
-        loop.run_forever()
-        loop.close()  # pragma: no cover
+
+        self.server = await asyncio.start_server(serve, host, port)
+        await self.server.wait_closed()
+
+    def run(self, host='0.0.0.0', port=5000, debug=False):
+        asyncio.run(self.start_server(host=host, port=port, debug=debug))
+
+    def shutdown(self):
+        self.server.close()

    async def dispatch_request(self, reader, writer):
-        req = await Request.create(reader, writer.get_extra_info('peername'))
+        req = await Request.create(self, reader,
+                                   writer.get_extra_info('peername'))
        if req:
            f = self.find_route(req)
            try:
--- a/microdot-asyncio/setup.py
+++ b/microdot-asyncio/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup

 setup(
    name='microdot-asyncio',
-    version="0.3.1",
+    version="0.4.0",
    url='http://github.com/miguelgrinberg/microdot/',
    license='MIT',
    author='Miguel Grinberg',
--- a/microdot/microdot.py
+++ b/microdot/microdot.py
@@ -5,6 +5,10 @@ except ImportError:  # pragma: no cover

    def print_exception(exc):
        traceback.print_exc()
+try:
+    import uerrno as errno
+except ImportError:
+    import errno

 concurrency_mode = 'threaded'

@@ -69,7 +73,9 @@ class Request():
    class G:
        pass

-    def __init__(self, client_addr, method, url, http_version, headers, body):
+    def __init__(self, app, client_addr, method, url, http_version, headers,
+                 body):
+        self.app = app
        self.client_addr = client_addr
        self.method = method
        self.path = url
@@ -99,7 +105,7 @@ class Request():
        self.g = Request.G()

    @staticmethod
-    def create(client_stream, client_addr):
+    def create(app, client_stream, client_addr):
        # request line
        line = client_stream.readline().strip().decode()
        if not line:  # pragma: no cover
@@ -123,7 +129,8 @@ class Request():
        # body
        body = client_stream.read(content_length) if content_length else b''

-        return Request(client_addr, method, url, http_version, headers, body)
+        return Request(app, client_addr, method, url, http_version, headers,
+                       body)

    def _parse_urlencoded(self, urlencoded):
        return {
@@ -226,7 +233,7 @@ class Response():
                        stream.write(buf)
                    if len(buf) < self.send_file_buffer_size:
                        break
-                if hasattr(self.body, 'close'):
+                if hasattr(self.body, 'close'):  # pragma: no close
                    self.body.close()
            else:
                stream.write(self.body)
@@ -306,7 +313,9 @@ class Microdot():
        self.before_request_handlers = []
        self.after_request_handlers = []
        self.error_handlers = {}
+        self.shutdown_requested = False
        self.debug = False
+        self.server = None

    def route(self, url_pattern, methods=None):
        def decorated(f):
@@ -315,6 +324,21 @@ class Microdot():
            return f
        return decorated

+    def get(self, url_pattern):
+        return self.route(url_pattern, methods=['GET'])
+
+    def post(self, url_pattern):
+        return self.route(url_pattern, methods=['POST'])
+
+    def put(self, url_pattern):
+        return self.route(url_pattern, methods=['PUT'])
+
+    def patch(self, url_pattern):
+        return self.route(url_pattern, methods=['PATCH'])
+
+    def delete(self, url_pattern):
+        return self.route(url_pattern, methods=['DELETE'])
+
    def before_request(self, f):
        self.before_request_handlers.append(f)
        return f
@@ -331,22 +355,32 @@ class Microdot():

    def run(self, host='0.0.0.0', port=5000, debug=False):
        self.debug = debug
+        self.shutdown_requested = False

-        s = socket.socket()
+        self.server = socket.socket()
        ai = socket.getaddrinfo(host, port)
        addr = ai[0][-1]

        if self.debug:  # pragma: no cover
            print('Starting {mode} server on {host}:{port}...'.format(
                mode=concurrency_mode, host=host, port=port))
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        s.bind(addr)
-        s.listen(5)
+        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.server.bind(addr)
+        self.server.listen(5)

-        while True:
-            sock, addr = s.accept()
+        while not self.shutdown_requested:
+            try:
+                sock, addr = self.server.accept()
+            except OSError as exc:
+                if exc.args[0] == errno.ECONNABORTED:
+                    break
+                else:
+                    raise
            create_thread(self.dispatch_request, sock, addr)

+    def shutdown(self):
+        self.shutdown_requested = True
+
    def find_route(self, req):
        f = None
        for route_methods, route_pattern, route_handler in self.url_map:
@@ -363,7 +397,7 @@ class Microdot():
        else:
            stream = sock

-        req = Request.create(stream, addr)
+        req = Request.create(self, stream, addr)
        if req:
            f = self.find_route(req)
            try:
@@ -406,6 +440,8 @@ class Microdot():
        stream.close()
        if stream != sock:  # pragma: no cover
            sock.close()
+        if self.shutdown_requested:  # pragma: no cover
+            self.server.close()
        if self.debug and req:  # pragma: no cover
            print('{method} {path} {status_code}'.format(
                method=req.method, path=req.path,
--- a/microdot/setup.py
+++ b/microdot/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup

 setup(
    name='microdot',
-    version="0.3.1",
+    version="0.4.0",
    url='http://github.com/miguelgrinberg/microdot/',
    license='MIT',
    author='Miguel Grinberg',
--- a/tests/libs/uasyncio/init.py
+++ b/tests/libs/uasyncio/init.py
@@ -1,258 +1,30 @@
-import uerrno
-import uselect as select
-import usocket as _socket
-from uasyncio.core import *
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George

+from .core import *

-DEBUG = 0
-log = None
+__version__ = (3, 0, 0)

-def set_debug(val):
-    global DEBUG, log
-    DEBUG = val
-    if val:
-        import logging
-        log = logging.getLogger("uasyncio")
+_attrs = {
+    "wait_for": "funcs",
+    "wait_for_ms": "funcs",
+    "gather": "funcs",
+    "Event": "event",
+    "ThreadSafeFlag": "event",
+    "Lock": "lock",
+    "open_connection": "stream",
+    "start_server": "stream",
+    "StreamReader": "stream",
+    "StreamWriter": "stream",
+}

-
-class PollEventLoop(EventLoop):
-
-    def __init__(self, runq_len=16, waitq_len=16):
-        EventLoop.__init__(self, runq_len, waitq_len)
-        self.poller = select.poll()
-        self.objmap = {}
-
-    def add_reader(self, sock, cb, *args):
-        if DEBUG and __debug__:
-            log.debug("add_reader%s", (sock, cb, args))
-        if args:
-            self.poller.register(sock, select.POLLIN)
-            self.objmap[id(sock)] = (cb, args)
-        else:
-            self.poller.register(sock, select.POLLIN)
-            self.objmap[id(sock)] = cb
-
-    def remove_reader(self, sock):
-        if DEBUG and __debug__:
-            log.debug("remove_reader(%s)", sock)
-        self.poller.unregister(sock)
-        del self.objmap[id(sock)]
-
-    def add_writer(self, sock, cb, *args):
-        if DEBUG and __debug__:
-            log.debug("add_writer%s", (sock, cb, args))
-        if args:
-            self.poller.register(sock, select.POLLOUT)
-            self.objmap[id(sock)] = (cb, args)
-        else:
-            self.poller.register(sock, select.POLLOUT)
-            self.objmap[id(sock)] = cb
-
-    def remove_writer(self, sock):
-        if DEBUG and __debug__:
-            log.debug("remove_writer(%s)", sock)
-        try:
-            self.poller.unregister(sock)
-            self.objmap.pop(id(sock), None)
-        except OSError as e:
-            # StreamWriter.awrite() first tries to write to a socket,
-            # and if that succeeds, yield IOWrite may never be called
-            # for that socket, and it will never be added to poller. So,
-            # ignore such error.
-            if e.args[0] != uerrno.ENOENT:
-                raise
-
-    def wait(self, delay):
-        if DEBUG and __debug__:
-            log.debug("poll.wait(%d)", delay)
-        # We need one-shot behavior (second arg of 1 to .poll())
-        res = self.poller.ipoll(delay, 1)
-        #log.debug("poll result: %s", res)
-        # Remove "if res" workaround after
-        # https://github.com/micropython/micropython/issues/2716 fixed.
-        if res:
-            for sock, ev in res:
-                cb = self.objmap[id(sock)]
-                if ev & (select.POLLHUP | select.POLLERR):
-                    # These events are returned even if not requested, and
-                    # are sticky, i.e. will be returned again and again.
-                    # If the caller doesn't do proper error handling and
-                    # unregister this sock, we'll busy-loop on it, so we
-                    # as well can unregister it now "just in case".
-                    self.remove_reader(sock)
-                if DEBUG and __debug__:
-                    log.debug("Calling IO callback: %r", cb)
-                if isinstance(cb, tuple):
-                    cb[0](*cb[1])
-                else:
-                    cb.pend_throw(None)
-                    self.call_soon(cb)
-
-
-class StreamReader:
-
-    def __init__(self, polls, ios=None):
-        if ios is None:
-            ios = polls
-        self.polls = polls
-        self.ios = ios
-
-    def read(self, n=-1):
-        while True:
-            yield IORead(self.polls)
-            res = self.ios.read(n)
-            if res is not None:
-                break
-            # This should not happen for real sockets, but can easily
-            # happen for stream wrappers (ssl, websockets, etc.)
-            #log.warn("Empty read")
-        if not res:
-            yield IOReadDone(self.polls)
-        return res
-
-    def readexactly(self, n):
-        buf = b""
-        while n:
-            yield IORead(self.polls)
-            res = self.ios.read(n)
-            assert res is not None
-            if not res:
-                yield IOReadDone(self.polls)
-                break
-            buf += res
-            n -= len(res)
-        return buf
-
-    def readline(self):
-        if DEBUG and __debug__:
-            log.debug("StreamReader.readline()")
-        buf = b""
-        while True:
-            yield IORead(self.polls)
-            res = self.ios.readline()
-            assert res is not None
-            if not res:
-                yield IOReadDone(self.polls)
-                break
-            buf += res
-            if buf[-1] == 0x0a:
-                break
-        if DEBUG and __debug__:
-            log.debug("StreamReader.readline(): %s", buf)
-        return buf
-
-    def aclose(self):
-        yield IOReadDone(self.polls)
-        self.ios.close()
-
-    def __repr__(self):
-        return "<StreamReader %r %r>" % (self.polls, self.ios)
-
-
-class StreamWriter:
-
-    def __init__(self, s, extra):
-        self.s = s
-        self.extra = extra
-
-    def awrite(self, buf, off=0, sz=-1):
-        # This method is called awrite (async write) to not proliferate
-        # incompatibility with original asyncio. Unlike original asyncio
-        # whose .write() method is both not a coroutine and guaranteed
-        # to return immediately (which means it has to buffer all the
-        # data), this method is a coroutine.
-        if sz == -1:
-            sz = len(buf) - off
-        if DEBUG and __debug__:
-            log.debug("StreamWriter.awrite(): spooling %d bytes", sz)
-        while True:
-            res = self.s.write(buf, off, sz)
-            # If we spooled everything, return immediately
-            if res == sz:
-                if DEBUG and __debug__:
-                    log.debug("StreamWriter.awrite(): completed spooling %d bytes", res)
-                return
-            if res is None:
-                res = 0
-            if DEBUG and __debug__:
-                log.debug("StreamWriter.awrite(): spooled partial %d bytes", res)
-            assert res < sz
-            off += res
-            sz -= res
-            yield IOWrite(self.s)
-            #assert s2.fileno() == self.s.fileno()
-            if DEBUG and __debug__:
-                log.debug("StreamWriter.awrite(): can write more")
-
-    # Write piecewise content from iterable (usually, a generator)
-    def awriteiter(self, iterable):
-        for buf in iterable:
-            yield from self.awrite(buf)
-
-    def aclose(self):
-        yield IOWriteDone(self.s)
-        self.s.close()
-
-    def get_extra_info(self, name, default=None):
-        return self.extra.get(name, default)
-
-    def __repr__(self):
-        return "<StreamWriter %r>" % self.s
-
-
-def open_connection(host, port, ssl=False):
-    if DEBUG and __debug__:
-        log.debug("open_connection(%s, %s)", host, port)
-    ai = _socket.getaddrinfo(host, port, 0, _socket.SOCK_STREAM)
-    ai = ai[0]
-    s = _socket.socket(ai[0], ai[1], ai[2])
-    s.setblocking(False)
-    try:
-        s.connect(ai[-1])
-    except OSError as e:
-        if e.args[0] != uerrno.EINPROGRESS:
-            raise
-    if DEBUG and __debug__:
-        log.debug("open_connection: After connect")
-    yield IOWrite(s)
-#    if __debug__:
-#        assert s2.fileno() == s.fileno()
-    if DEBUG and __debug__:
-        log.debug("open_connection: After iowait: %s", s)
-    if ssl:
-        print("Warning: uasyncio SSL support is alpha")
-        import ussl
-        s.setblocking(True)
-        s2 = ussl.wrap_socket(s)
-        s.setblocking(False)
-        return StreamReader(s, s2), StreamWriter(s2, {})
-    return StreamReader(s), StreamWriter(s, {})
-
-
-def start_server(client_coro, host, port, backlog=10):
-    if DEBUG and __debug__:
-        log.debug("start_server(%s, %s)", host, port)
-    ai = _socket.getaddrinfo(host, port, 0, _socket.SOCK_STREAM)
-    ai = ai[0]
-    s = _socket.socket(ai[0], ai[1], ai[2])
-    s.setblocking(False)
-
-    s.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1)
-    s.bind(ai[-1])
-    s.listen(backlog)
-    while True:
-        if DEBUG and __debug__:
-            log.debug("start_server: Before accept")
-        yield IORead(s)
-        if DEBUG and __debug__:
-            log.debug("start_server: After iowait")
-        s2, client_addr = s.accept()
-        s2.setblocking(False)
-        if DEBUG and __debug__:
-            log.debug("start_server: After accept: %s", s2)
-        extra = {"peername": client_addr}
-        yield client_coro(StreamReader(s2), StreamWriter(s2, extra))
-
-
-import uasyncio.core
-uasyncio.core._event_loop_class = PollEventLoop
+# Lazy loader, effectively does:
+#   global attr
+#   from .mod import attr
+def __getattr__(attr):
+    mod = _attrs.get(attr, None)
+    if mod is None:
+        raise AttributeError(attr)
+    value = getattr(__import__(mod, None, None, True, 1), attr)
+    globals()[attr] = value
+    return value
--- a/tests/libs/uasyncio/core.py
+++ b/tests/libs/uasyncio/core.py
@@ -1,318 +1,281 @@
-import utime as time
-import utimeq
-import ucollections
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+
+from time import ticks_ms as ticks, ticks_diff, ticks_add
+import sys, select
+
+# Import TaskQueue and Task, preferring built-in C code over Python code
+try:
+    from _uasyncio import TaskQueue, Task
+except:
+    from .task import TaskQueue, Task


-type_gen = type((lambda: (yield))())
-
-DEBUG = 0
-log = None
-
-def set_debug(val):
-    global DEBUG, log
-    DEBUG = val
-    if val:
-        import logging
-        log = logging.getLogger("uasyncio.core")
+################################################################################
+# Exceptions


-class CancelledError(Exception):
+class CancelledError(BaseException):
    pass


-class TimeoutError(CancelledError):
+class TimeoutError(Exception):
    pass


-class EventLoop:
-
-    def __init__(self, runq_len=16, waitq_len=16):
-        self.runq = ucollections.deque((), runq_len, True)
-        self.waitq = utimeq.utimeq(waitq_len)
-        # Current task being run. Task is a top-level coroutine scheduled
-        # in the event loop (sub-coroutines executed transparently by
-        # yield from/await, event loop "doesn't see" them).
-        self.cur_task = None
-
-    def time(self):
-        return time.ticks_ms()
-
-    def create_task(self, coro):
-        # CPython 3.4.2
-        self.call_later_ms(0, coro)
-        # CPython asyncio incompatibility: we don't return Task object
-
-    def call_soon(self, callback, *args):
-        if __debug__ and DEBUG:
-            log.debug("Scheduling in runq: %s", (callback, args))
-        self.runq.append(callback)
-        if not isinstance(callback, type_gen):
-            self.runq.append(args)
-
-    def call_later(self, delay, callback, *args):
-        self.call_at_(time.ticks_add(self.time(), int(delay * 1000)), callback, args)
-
-    def call_later_ms(self, delay, callback, *args):
-        if not delay:
-            return self.call_soon(callback, *args)
-        self.call_at_(time.ticks_add(self.time(), delay), callback, args)
-
-    def call_at_(self, time, callback, args=()):
-        if __debug__ and DEBUG:
-            log.debug("Scheduling in waitq: %s", (time, callback, args))
-        self.waitq.push(time, callback, args)
-
-    def wait(self, delay):
-        # Default wait implementation, to be overriden in subclasses
-        # with IO scheduling
-        if __debug__ and DEBUG:
-            log.debug("Sleeping for: %s", delay)
-        time.sleep_ms(delay)
-
-    def run_forever(self):
-        cur_task = [0, 0, 0]
-        while True:
-            # Expire entries in waitq and move them to runq
-            tnow = self.time()
-            while self.waitq:
-                t = self.waitq.peektime()
-                delay = time.ticks_diff(t, tnow)
-                if delay > 0:
-                    break
-                self.waitq.pop(cur_task)
-                if __debug__ and DEBUG:
-                    log.debug("Moving from waitq to runq: %s", cur_task[1])
-                self.call_soon(cur_task[1], *cur_task[2])
-
-            # Process runq
-            l = len(self.runq)
-            if __debug__ and DEBUG:
-                log.debug("Entries in runq: %d", l)
-            while l:
-                cb = self.runq.popleft()
-                l -= 1
-                args = ()
-                if not isinstance(cb, type_gen):
-                    args = self.runq.popleft()
-                    l -= 1
-                    if __debug__ and DEBUG:
-                        log.info("Next callback to run: %s", (cb, args))
-                    cb(*args)
-                    continue
-
-                if __debug__ and DEBUG:
-                    log.info("Next coroutine to run: %s", (cb, args))
-                self.cur_task = cb
-                delay = 0
-                try:
-                    if args is ():
-                        ret = next(cb)
-                    else:
-                        ret = cb.send(*args)
-                    if __debug__ and DEBUG:
-                        log.info("Coroutine %s yield result: %s", cb, ret)
-                    if isinstance(ret, SysCall1):
-                        arg = ret.arg
-                        if isinstance(ret, SleepMs):
-                            delay = arg
-                        elif isinstance(ret, IORead):
-                            cb.pend_throw(False)
-                            self.add_reader(arg, cb)
-                            continue
-                        elif isinstance(ret, IOWrite):
-                            cb.pend_throw(False)
-                            self.add_writer(arg, cb)
-                            continue
-                        elif isinstance(ret, IOReadDone):
-                            self.remove_reader(arg)
-                        elif isinstance(ret, IOWriteDone):
-                            self.remove_writer(arg)
-                        elif isinstance(ret, StopLoop):
-                            return arg
-                        else:
-                            assert False, "Unknown syscall yielded: %r (of type %r)" % (ret, type(ret))
-                    elif isinstance(ret, type_gen):
-                        self.call_soon(ret)
-                    elif isinstance(ret, int):
-                        # Delay
-                        delay = ret
-                    elif ret is None:
-                        # Just reschedule
-                        pass
-                    elif ret is False:
-                        # Don't reschedule
-                        continue
-                    else:
-                        assert False, "Unsupported coroutine yield value: %r (of type %r)" % (ret, type(ret))
-                except StopIteration as e:
-                    if __debug__ and DEBUG:
-                        log.debug("Coroutine finished: %s", cb)
-                    continue
-                except CancelledError as e:
-                    if __debug__ and DEBUG:
-                        log.debug("Coroutine cancelled: %s", cb)
-                    continue
-                # Currently all syscalls don't return anything, so we don't
-                # need to feed anything to the next invocation of coroutine.
-                # If that changes, need to pass that value below.
-                if delay:
-                    self.call_later_ms(delay, cb)
-                else:
-                    self.call_soon(cb)
-
-            # Wait until next waitq task or I/O availability
-            delay = 0
-            if not self.runq:
-                delay = -1
-                if self.waitq:
-                    tnow = self.time()
-                    t = self.waitq.peektime()
-                    delay = time.ticks_diff(t, tnow)
-                    if delay < 0:
-                        delay = 0
-            self.wait(delay)
-
-    def run_until_complete(self, coro):
-        ret = None
-        def _run_and_stop():
-            nonlocal ret
-            ret = yield from coro
-            yield StopLoop(0)
-        self.call_soon(_run_and_stop())
-        self.run_forever()
-        return ret
-
-    def stop(self):
-        self.call_soon((lambda: (yield StopLoop(0)))())
-
-    def close(self):
-        pass
+# Used when calling Loop.call_exception_handler
+_exc_context = {"message": "Task exception wasn't retrieved", "exception": None, "future": None}


-class SysCall:
-
-    def __init__(self, *args):
-        self.args = args
-
-    def handle(self):
-        raise NotImplementedError
-
-# Optimized syscall with 1 arg
-class SysCall1(SysCall):
-
-    def __init__(self, arg):
-        self.arg = arg
-
-class StopLoop(SysCall1):
-    pass
-
-class IORead(SysCall1):
-    pass
-
-class IOWrite(SysCall1):
-    pass
-
-class IOReadDone(SysCall1):
-    pass
-
-class IOWriteDone(SysCall1):
-    pass
-
-
-_event_loop = None
-_event_loop_class = EventLoop
-def get_event_loop(runq_len=16, waitq_len=16):
-    global _event_loop
-    if _event_loop is None:
-        _event_loop = _event_loop_class(runq_len, waitq_len)
-    return _event_loop
-
-def sleep(secs):
-    yield int(secs * 1000)
-
-# Implementation of sleep_ms awaitable with zero heap memory usage
-class SleepMs(SysCall1):
+################################################################################
+# Sleep functions

+# "Yield" once, then raise StopIteration
+class SingletonGenerator:
    def __init__(self):
-        self.v = None
-        self.arg = None
-
-    def __call__(self, arg):
-        self.v = arg
-        #print("__call__")
-        return self
+        self.state = None
+        self.exc = StopIteration()

    def __iter__(self):
-        #print("__iter__")
        return self

    def __next__(self):
-        if self.v is not None:
-            #print("__next__ syscall enter")
-            self.arg = self.v
-            self.v = None
-            return self
-        #print("__next__ syscall exit")
-        _stop_iter.__traceback__ = None
-        raise _stop_iter
-
-_stop_iter = StopIteration()
-sleep_ms = SleepMs()
+        if self.state is not None:
+            _task_queue.push_sorted(cur_task, self.state)
+            self.state = None
+            return None
+        else:
+            self.exc.__traceback__ = None
+            raise self.exc


-def cancel(coro):
-    prev = coro.pend_throw(CancelledError())
-    if prev is False:
-        _event_loop.call_soon(coro)
+# Pause task execution for the given time (integer in milliseconds, uPy extension)
+# Use a SingletonGenerator to do it without allocating on the heap
+def sleep_ms(t, sgen=SingletonGenerator()):
+    assert sgen.state is None
+    sgen.state = ticks_add(ticks(), max(0, t))
+    return sgen


-class TimeoutObj:
-    def __init__(self, coro):
-        self.coro = coro
+# Pause task execution for the given time (in seconds)
+def sleep(t):
+    return sleep_ms(int(t * 1000))


-def wait_for_ms(coro, timeout):
-
-    def waiter(coro, timeout_obj):
-        res = yield from coro
-        if __debug__ and DEBUG:
-            log.debug("waiter: cancelling %s", timeout_obj)
-        timeout_obj.coro = None
-        return res
-
-    def timeout_func(timeout_obj):
-        if timeout_obj.coro:
-            if __debug__ and DEBUG:
-                log.debug("timeout_func: cancelling %s", timeout_obj.coro)
-            prev = timeout_obj.coro.pend_throw(TimeoutError())
-            #print("prev pend", prev)
-            if prev is False:
-                _event_loop.call_soon(timeout_obj.coro)
-
-    timeout_obj = TimeoutObj(_event_loop.cur_task)
-    _event_loop.call_later_ms(timeout, timeout_func, timeout_obj)
-    return (yield from waiter(coro, timeout_obj))
+################################################################################
+# Queue and poller for stream IO


-def wait_for(coro, timeout):
-    return wait_for_ms(coro, int(timeout * 1000))
+class IOQueue:
+    def __init__(self):
+        self.poller = select.poll()
+        self.map = {}  # maps id(stream) to [task_waiting_read, task_waiting_write, stream]
+
+    def _enqueue(self, s, idx):
+        if id(s) not in self.map:
+            entry = [None, None, s]
+            entry[idx] = cur_task
+            self.map[id(s)] = entry
+            self.poller.register(s, select.POLLIN if idx == 0 else select.POLLOUT)
+        else:
+            sm = self.map[id(s)]
+            assert sm[idx] is None
+            assert sm[1 - idx] is not None
+            sm[idx] = cur_task
+            self.poller.modify(s, select.POLLIN | select.POLLOUT)
+        # Link task to this IOQueue so it can be removed if needed
+        cur_task.data = self
+
+    def _dequeue(self, s):
+        del self.map[id(s)]
+        self.poller.unregister(s)
+
+    def queue_read(self, s):
+        self._enqueue(s, 0)
+
+    def queue_write(self, s):
+        self._enqueue(s, 1)
+
+    def remove(self, task):
+        while True:
+            del_s = None
+            for k in self.map:  # Iterate without allocating on the heap
+                q0, q1, s = self.map[k]
+                if q0 is task or q1 is task:
+                    del_s = s
+                    break
+            if del_s is not None:
+                self._dequeue(s)
+            else:
+                break
+
+    def wait_io_event(self, dt):
+        for s, ev in self.poller.ipoll(dt):
+            sm = self.map[id(s)]
+            # print('poll', s, sm, ev)
+            if ev & ~select.POLLOUT and sm[0] is not None:
+                # POLLIN or error
+                _task_queue.push_head(sm[0])
+                sm[0] = None
+            if ev & ~select.POLLIN and sm[1] is not None:
+                # POLLOUT or error
+                _task_queue.push_head(sm[1])
+                sm[1] = None
+            if sm[0] is None and sm[1] is None:
+                self._dequeue(s)
+            elif sm[0] is None:
+                self.poller.modify(s, select.POLLOUT)
+            else:
+                self.poller.modify(s, select.POLLIN)


-def coroutine(f):
-    return f
+################################################################################
+# Main run loop

-#
-# The functions below are deprecated in uasyncio, and provided only
-# for compatibility with CPython asyncio
-#
-
-def ensure_future(coro, loop=_event_loop):
-    _event_loop.call_soon(coro)
-    # CPython asyncio incompatibility: we don't return Task object
-    return coro
+# Ensure the awaitable is a task
+def _promote_to_task(aw):
+    return aw if isinstance(aw, Task) else create_task(aw)


-# CPython asyncio incompatibility: Task is a function, not a class (for efficiency)
-def Task(coro, loop=_event_loop):
-    # Same as async()
-    _event_loop.call_soon(coro)
+# Create and schedule a new task from a coroutine
+def create_task(coro):
+    if not hasattr(coro, "send"):
+        raise TypeError("coroutine expected")
+    t = Task(coro, globals())
+    _task_queue.push_head(t)
+    return t
+
+
+# Keep scheduling tasks until there are none left to schedule
+def run_until_complete(main_task=None):
+    global cur_task
+    excs_all = (CancelledError, Exception)  # To prevent heap allocation in loop
+    excs_stop = (CancelledError, StopIteration)  # To prevent heap allocation in loop
+    while True:
+        # Wait until the head of _task_queue is ready to run
+        dt = 1
+        while dt > 0:
+            dt = -1
+            t = _task_queue.peek()
+            if t:
+                # A task waiting on _task_queue; "ph_key" is time to schedule task at
+                dt = max(0, ticks_diff(t.ph_key, ticks()))
+            elif not _io_queue.map:
+                # No tasks can be woken so finished running
+                return
+            # print('(poll {})'.format(dt), len(_io_queue.map))
+            _io_queue.wait_io_event(dt)
+
+        # Get next task to run and continue it
+        t = _task_queue.pop_head()
+        cur_task = t
+        try:
+            # Continue running the coroutine, it's responsible for rescheduling itself
+            exc = t.data
+            if not exc:
+                t.coro.send(None)
+            else:
+                t.data = None
+                t.coro.throw(exc)
+        except excs_all as er:
+            # Check the task is not on any event queue
+            assert t.data is None
+            # This task is done, check if it's the main task and then loop should stop
+            if t is main_task:
+                if isinstance(er, StopIteration):
+                    return er.value
+                raise er
+            # Schedule any other tasks waiting on the completion of this task
+            waiting = False
+            if hasattr(t, "waiting"):
+                while t.waiting.peek():
+                    _task_queue.push_head(t.waiting.pop_head())
+                    waiting = True
+                t.waiting = None  # Free waiting queue head
+            if not waiting and not isinstance(er, excs_stop):
+                # An exception ended this detached task, so queue it for later
+                # execution to handle the uncaught exception if no other task retrieves
+                # the exception in the meantime (this is handled by Task.throw).
+                _task_queue.push_head(t)
+            # Indicate task is done by setting coro to the task object itself
+            t.coro = t
+            # Save return value of coro to pass up to caller
+            t.data = er
+
+
+# Create a new task from a coroutine and run it until it finishes
+def run(coro):
+    return run_until_complete(create_task(coro))
+
+
+################################################################################
+# Event loop wrapper
+
+
+async def _stopper():
+    pass
+
+
+_stop_task = None
+
+
+class Loop:
+    _exc_handler = None
+
+    def create_task(coro):
+        return create_task(coro)
+
+    def run_forever():
+        global _stop_task
+        _stop_task = Task(_stopper(), globals())
+        run_until_complete(_stop_task)
+        # TODO should keep running until .stop() is called, even if there're no tasks left
+
+    def run_until_complete(aw):
+        return run_until_complete(_promote_to_task(aw))
+
+    def stop():
+        global _stop_task
+        if _stop_task is not None:
+            _task_queue.push_head(_stop_task)
+            # If stop() is called again, do nothing
+            _stop_task = None
+
+    def close():
+        pass
+
+    def set_exception_handler(handler):
+        Loop._exc_handler = handler
+
+    def get_exception_handler():
+        return Loop._exc_handler
+
+    def default_exception_handler(loop, context):
+        print(context["message"])
+        print("future:", context["future"], "coro=", context["future"].coro)
+        sys.print_exception(context["exception"])
+
+    def call_exception_handler(context):
+        (Loop._exc_handler or Loop.default_exception_handler)(Loop, context)
+
+
+# The runq_len and waitq_len arguments are for legacy uasyncio compatibility
+def get_event_loop(runq_len=0, waitq_len=0):
+    return Loop
+
+
+def current_task():
+    return cur_task
+
+
+def new_event_loop():
+    global _task_queue, _io_queue
+    # TaskQueue of Task instances
+    _task_queue = TaskQueue()
+    # Task queue and poller for stream IO
+    _io_queue = IOQueue()
+    return Loop
+
+
+# Initialise default event loop
+new_event_loop()
--- a/tests/libs/uasyncio/event.py
+++ b/tests/libs/uasyncio/event.py
@@ -0,0 +1,62 @@
+# 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
+        # Note: This must not be called from anything except the thread running
+        # the asyncio loop (i.e. neither hard or soft IRQ, or a different thread).
+        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
+
+
+# MicroPython-extension: This can be set from outside the asyncio event loop,
+# such as other threads, IRQs or scheduler context. Implementation is a stream
+# that asyncio will poll until a flag is set.
+# Note: Unlike Event, this is self-clearing.
+try:
+    import uio
+
+    class ThreadSafeFlag(uio.IOBase):
+        def __init__(self):
+            self._flag = 0
+
+        def ioctl(self, req, flags):
+            if req == 3:  # MP_STREAM_POLL
+                return self._flag * flags
+            return None
+
+        def set(self):
+            self._flag = 1
+
+        async def wait(self):
+            if not self._flag:
+                yield core._io_queue.queue_read(self)
+            self._flag = 0
+
+
+except ImportError:
+    pass
--- a/tests/libs/uasyncio/funcs.py
+++ b/tests/libs/uasyncio/funcs.py
@@ -0,0 +1,74 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+from . import core
+
+
+async def wait_for(aw, timeout, sleep=core.sleep):
+    aw = core._promote_to_task(aw)
+    if timeout is None:
+        return await aw
+
+    def runner(waiter, aw):
+        nonlocal status, result
+        try:
+            result = await aw
+            s = True
+        except BaseException as er:
+            s = er
+        if status is None:
+            # The waiter is still waiting, set status for it and cancel it.
+            status = s
+            waiter.cancel()
+
+    # Run aw in a separate runner task that manages its exceptions.
+    status = None
+    result = None
+    runner_task = core.create_task(runner(core.cur_task, aw))
+
+    try:
+        # Wait for the timeout to elapse.
+        await sleep(timeout)
+    except core.CancelledError as er:
+        if status is True:
+            # aw completed successfully and cancelled the sleep, so return aw's result.
+            return result
+        elif status is None:
+            # This wait_for was cancelled externally, so cancel aw and re-raise.
+            status = True
+            runner_task.cancel()
+            raise er
+        else:
+            # aw raised an exception, propagate it out to the caller.
+            raise status
+
+    # The sleep finished before aw, so cancel aw and raise TimeoutError.
+    status = True
+    runner_task.cancel()
+    await runner_task
+    raise core.TimeoutError
+
+
+def wait_for_ms(aw, timeout):
+    return wait_for(aw, timeout, core.sleep_ms)
+
+
+async def gather(*aws, return_exceptions=False):
+    ts = [core._promote_to_task(aw) for aw in aws]
+    for i in range(len(ts)):
+        try:
+            # TODO handle cancel of gather itself
+            # if ts[i].coro:
+            #    iter(ts[i]).waiting.push_head(cur_task)
+            #    try:
+            #        yield
+            #    except CancelledError as er:
+            #        # cancel all waiting tasks
+            #        raise er
+            ts[i] = await ts[i]
+        except Exception as er:
+            if return_exceptions:
+                ts[i] = er
+            else:
+                raise er
+    return ts
--- a/tests/libs/uasyncio/lock.py
+++ b/tests/libs/uasyncio/lock.py
@@ -0,0 +1,53 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+from . import core
+
+# Lock class for primitive mutex capability
+class Lock:
+    def __init__(self):
+        # The state can take the following values:
+        # - 0: unlocked
+        # - 1: locked
+        # - <Task>: unlocked but this task has been scheduled to acquire the lock next
+        self.state = 0
+        # Queue of Tasks waiting to acquire this Lock
+        self.waiting = core.TaskQueue()
+
+    def locked(self):
+        return self.state == 1
+
+    def release(self):
+        if self.state != 1:
+            raise RuntimeError("Lock not acquired")
+        if self.waiting.peek():
+            # Task(s) waiting on lock, schedule next Task
+            self.state = self.waiting.pop_head()
+            core._task_queue.push_head(self.state)
+        else:
+            # No Task waiting so unlock
+            self.state = 0
+
+    async def acquire(self):
+        if self.state != 0:
+            # Lock unavailable, put the calling Task on the waiting queue
+            self.waiting.push_head(core.cur_task)
+            # Set calling task's data to the lock's queue so it can be removed if needed
+            core.cur_task.data = self.waiting
+            try:
+                yield
+            except core.CancelledError as er:
+                if self.state == core.cur_task:
+                    # Cancelled while pending on resume, schedule next waiting Task
+                    self.state = 1
+                    self.release()
+                raise er
+        # Lock available, set it as locked
+        self.state = 1
+        return True
+
+    async def __aenter__(self):
+        return await self.acquire()
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return self.release()
--- a/tests/libs/uasyncio/manifest.py
+++ b/tests/libs/uasyncio/manifest.py
@@ -0,0 +1,13 @@
+# This list of frozen files doesn't include task.py because that's provided by the C module.
+freeze(
+    "..",
+    (
+        "uasyncio/__init__.py",
+        "uasyncio/core.py",
+        "uasyncio/event.py",
+        "uasyncio/funcs.py",
+        "uasyncio/lock.py",
+        "uasyncio/stream.py",
+    ),
+    opt=3,
+)
--- a/tests/libs/uasyncio/stream.py
+++ b/tests/libs/uasyncio/stream.py
@@ -0,0 +1,158 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+from . import core
+
+
+class Stream:
+    def __init__(self, s, e={}):
+        self.s = s
+        self.e = e
+        self.out_buf = b""
+
+    def get_extra_info(self, v):
+        return self.e[v]
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
+
+    def close(self):
+        pass
+
+    async def wait_closed(self):
+        # TODO yield?
+        self.s.close()
+
+    async def read(self, n):
+        yield core._io_queue.queue_read(self.s)
+        return self.s.read(n)
+
+    async def readexactly(self, n):
+        r = b""
+        while n:
+            yield core._io_queue.queue_read(self.s)
+            r2 = self.s.read(n)
+            if r2 is not None:
+                if not len(r2):
+                    raise EOFError
+                r += r2
+                n -= len(r2)
+        return r
+
+    async def readline(self):
+        l = b""
+        while True:
+            yield core._io_queue.queue_read(self.s)
+            l2 = self.s.readline()  # may do multiple reads but won't block
+            l += l2
+            if not l2 or l[-1] == 10:  # \n (check l in case l2 is str)
+                return l
+
+    def write(self, buf):
+        self.out_buf += buf
+
+    async def drain(self):
+        mv = memoryview(self.out_buf)
+        off = 0
+        while off < len(mv):
+            yield core._io_queue.queue_write(self.s)
+            ret = self.s.write(mv[off:])
+            if ret is not None:
+                off += ret
+        self.out_buf = b""
+
+
+# Stream can be used for both reading and writing to save code size
+StreamReader = Stream
+StreamWriter = Stream
+
+
+# Create a TCP stream connection to a remote host
+async def open_connection(host, port):
+    from uerrno import EINPROGRESS
+    import usocket as socket
+
+    ai = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
+    s = socket.socket()
+    s.setblocking(False)
+    ss = Stream(s)
+    try:
+        s.connect(ai[-1])
+    except OSError as er:
+        if er.errno != EINPROGRESS:
+            raise er
+    yield core._io_queue.queue_write(s)
+    return ss, ss
+
+
+# Class representing a TCP stream server, can be closed and used in "async with"
+class Server:
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        self.close()
+        await self.wait_closed()
+
+    def close(self):
+        self.task.cancel()
+
+    async def wait_closed(self):
+        await self.task
+
+    async def _serve(self, cb, host, port, backlog):
+        import usocket as socket
+
+        ai = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
+        s = socket.socket()
+        s.setblocking(False)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind(ai[-1])
+        s.listen(backlog)
+        self.task = core.cur_task
+        # Accept incoming connections
+        while True:
+            try:
+                yield core._io_queue.queue_read(s)
+            except core.CancelledError:
+                # Shutdown server
+                s.close()
+                return
+            try:
+                s2, addr = s.accept()
+            except:
+                # Ignore a failed accept
+                continue
+            s2.setblocking(False)
+            s2s = Stream(s2, {"peername": addr})
+            core.create_task(cb(s2s, s2s))
+
+
+# Helper function to start a TCP stream server, running as a new task
+# TODO could use an accept-callback on socket read activity instead of creating a task
+async def start_server(cb, host, port, backlog=5):
+    s = Server()
+    core.create_task(s._serve(cb, host, port, backlog))
+    return s
+
+
+################################################################################
+# Legacy uasyncio compatibility
+
+
+async def stream_awrite(self, buf, off=0, sz=-1):
+    if off != 0 or sz != -1:
+        buf = memoryview(buf)
+        if sz == -1:
+            sz = len(buf)
+        buf = buf[off : off + sz]
+    self.write(buf)
+    await self.drain()
+
+
+Stream.aclose = Stream.wait_closed
+Stream.awrite = stream_awrite
+Stream.awritestr = stream_awrite  # TODO explicitly convert to bytes?
--- a/tests/libs/uasyncio/task.py
+++ b/tests/libs/uasyncio/task.py
@@ -0,0 +1,184 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+# This file contains the core TaskQueue based on a pairing heap, and the core Task class.
+# They can optionally be replaced by C implementations.
+
+from . import core
+
+
+# pairing-heap meld of 2 heaps; O(1)
+def ph_meld(h1, h2):
+    if h1 is None:
+        return h2
+    if h2 is None:
+        return h1
+    lt = core.ticks_diff(h1.ph_key, h2.ph_key) < 0
+    if lt:
+        if h1.ph_child is None:
+            h1.ph_child = h2
+        else:
+            h1.ph_child_last.ph_next = h2
+        h1.ph_child_last = h2
+        h2.ph_next = None
+        h2.ph_rightmost_parent = h1
+        return h1
+    else:
+        h1.ph_next = h2.ph_child
+        h2.ph_child = h1
+        if h1.ph_next is None:
+            h2.ph_child_last = h1
+            h1.ph_rightmost_parent = h2
+        return h2
+
+
+# pairing-heap pairing operation; amortised O(log N)
+def ph_pairing(child):
+    heap = None
+    while child is not None:
+        n1 = child
+        child = child.ph_next
+        n1.ph_next = None
+        if child is not None:
+            n2 = child
+            child = child.ph_next
+            n2.ph_next = None
+            n1 = ph_meld(n1, n2)
+        heap = ph_meld(heap, n1)
+    return heap
+
+
+# pairing-heap delete of a node; stable, amortised O(log N)
+def ph_delete(heap, node):
+    if node is heap:
+        child = heap.ph_child
+        node.ph_child = None
+        return ph_pairing(child)
+    # Find parent of node
+    parent = node
+    while parent.ph_next is not None:
+        parent = parent.ph_next
+    parent = parent.ph_rightmost_parent
+    # Replace node with pairing of its children
+    if node is parent.ph_child and node.ph_child is None:
+        parent.ph_child = node.ph_next
+        node.ph_next = None
+        return heap
+    elif node is parent.ph_child:
+        child = node.ph_child
+        next = node.ph_next
+        node.ph_child = None
+        node.ph_next = None
+        node = ph_pairing(child)
+        parent.ph_child = node
+    else:
+        n = parent.ph_child
+        while node is not n.ph_next:
+            n = n.ph_next
+        child = node.ph_child
+        next = node.ph_next
+        node.ph_child = None
+        node.ph_next = None
+        node = ph_pairing(child)
+        if node is None:
+            node = n
+        else:
+            n.ph_next = node
+    node.ph_next = next
+    if next is None:
+        node.ph_rightmost_parent = parent
+        parent.ph_child_last = node
+    return heap
+
+
+# TaskQueue class based on the above pairing-heap functions.
+class TaskQueue:
+    def __init__(self):
+        self.heap = None
+
+    def peek(self):
+        return self.heap
+
+    def push_sorted(self, v, key):
+        v.data = None
+        v.ph_key = key
+        v.ph_child = None
+        v.ph_next = None
+        self.heap = ph_meld(v, self.heap)
+
+    def push_head(self, v):
+        self.push_sorted(v, core.ticks())
+
+    def pop_head(self):
+        v = self.heap
+        self.heap = ph_pairing(self.heap.ph_child)
+        return v
+
+    def remove(self, v):
+        self.heap = ph_delete(self.heap, v)
+
+
+# Task class representing a coroutine, can be waited on and cancelled.
+class Task:
+    def __init__(self, coro, globals=None):
+        self.coro = coro  # Coroutine of this Task
+        self.data = None  # General data for queue it is waiting on
+        self.ph_key = 0  # Pairing heap
+        self.ph_child = None  # Paring heap
+        self.ph_child_last = None  # Paring heap
+        self.ph_next = None  # Paring heap
+        self.ph_rightmost_parent = None  # Paring heap
+
+    def __iter__(self):
+        if self.coro is self:
+            # Signal that the completed-task has been await'ed on.
+            self.waiting = None
+        elif not hasattr(self, "waiting"):
+            # Lazily allocated head of linked list of Tasks waiting on completion of this task.
+            self.waiting = TaskQueue()
+        return self
+
+    def __next__(self):
+        if self.coro is self:
+            # Task finished, raise return value to caller so it can continue.
+            raise self.data
+        else:
+            # Put calling task on waiting queue.
+            self.waiting.push_head(core.cur_task)
+            # Set calling task's data to this task that it waits on, to double-link it.
+            core.cur_task.data = self
+
+    def done(self):
+        return self.coro is self
+
+    def cancel(self):
+        # Check if task is already finished.
+        if self.coro is self:
+            return False
+        # Can't cancel self (not supported yet).
+        if self is core.cur_task:
+            raise RuntimeError("can't cancel self")
+        # If Task waits on another task then forward the cancel to the one it's waiting on.
+        while isinstance(self.data, Task):
+            self = self.data
+        # Reschedule Task as a cancelled task.
+        if hasattr(self.data, "remove"):
+            # Not on the main running queue, remove the task from the queue it's on.
+            self.data.remove(self)
+            core._task_queue.push_head(self)
+        elif core.ticks_diff(self.ph_key, core.ticks()) > 0:
+            # On the main running queue but scheduled in the future, so bring it forward to now.
+            core._task_queue.remove(self)
+            core._task_queue.push_head(self)
+        self.data = core.CancelledError
+        return True
+
+    def throw(self, value):
+        # This task raised an exception which was uncaught; handle that now.
+        # Set the data because it was cleared by the main scheduling loop.
+        self.data = value
+        if not hasattr(self, "waiting"):
+            # Nothing await'ed on the task so call the exception handler.
+            core._exc_context["exception"] = value
+            core._exc_context["future"] = self
+            core.Loop.call_exception_handler(core._exc_context)
--- a/tests/microdot/test_microdot.py
+++ b/tests/microdot/test_microdot.py
@@ -21,6 +21,14 @@ class TestMicrodot(unittest.TestCase):
        sys.modules['microdot'].socket = self.original_socket
        sys.modules['microdot'].create_thread = self.original_create_thread

+    def _add_shutdown(self, app):
+        @app.route('/shutdown')
+        def shutdown(req):
+            app.shutdown()
+            return ''
+
+        mock_socket.add_request('GET', '/shutdown')
+
    def test_get_request(self):
        app = Microdot()

@@ -30,7 +38,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -49,7 +58,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('POST', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -83,7 +93,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/bar')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 202 N/A\r\n'))
        self.assertIn(b'X-One: 1\r\n', fd.response)
        self.assertIn(b'Set-Cookie: foo=bar\r\n', fd.response)
@@ -93,7 +104,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/baz')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'X-One: 1\r\n', fd.response)
        self.assertIn(b'Set-Cookie: foo=bar\r\n', fd.response)
@@ -110,7 +122,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/foo')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 404 N/A\r\n'))
        self.assertIn(b'Content-Length: 9\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -129,7 +142,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/foo')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -144,7 +158,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 500 N/A\r\n'))
        self.assertIn(b'Content-Length: 21\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -163,7 +178,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 501 N/A\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -182,7 +198,8 @@ class TestMicrodot(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 501 N/A\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
--- a/tests/microdot/test_request.py
+++ b/tests/microdot/test_request.py
@@ -6,7 +6,8 @@ from tests.mock_socket import get_request_fd
 class TestRequest(unittest.TestCase):
    def test_create_request(self):
        fd = get_request_fd('GET', '/foo')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
+        self.assertEqual(req.app, 'app')
        self.assertEqual(req.client_addr, 'addr')
        self.assertEqual(req.method, 'GET')
        self.assertEqual(req.path, '/foo')
@@ -26,7 +27,7 @@ class TestRequest(unittest.TestCase):
            'Content-Type': 'application/json',
            'Cookie': 'foo=bar;abc=def',
            'Content-Length': '3'}, body='aaa')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
        self.assertEqual(req.headers, {
            'Host': 'example.com:1234',
            'Content-Type': 'application/json',
@@ -39,33 +40,33 @@ class TestRequest(unittest.TestCase):

    def test_args(self):
        fd = get_request_fd('GET', '/?foo=bar&abc=def&x=%2f%%')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
        self.assertEqual(req.query_string, 'foo=bar&abc=def&x=%2f%%')
        self.assertEqual(req.args, {'foo': 'bar', 'abc': 'def', 'x': '/%%'})

    def test_json(self):
        fd = get_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/json'}, body='{"foo":"bar"}')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
        json = req.json
        self.assertEqual(json, {'foo': 'bar'})
        self.assertTrue(req.json is json)

        fd = get_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/json'}, body='[1, "2"]')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
        self.assertEqual(req.json, [1, '2'])

        fd = get_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/xml'}, body='[1, "2"]')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
        self.assertIsNone(req.json)

    def test_form(self):
        fd = get_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/x-www-form-urlencoded'},
            body='foo=bar&abc=def&x=%2f%%')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
        form = req.form
        self.assertEqual(form, {'foo': 'bar', 'abc': 'def', 'x': '/%%'})
        self.assertTrue(req.form is form)
@@ -73,5 +74,5 @@ class TestRequest(unittest.TestCase):
        fd = get_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/json'},
            body='foo=bar&abc=def&x=%2f%%')
-        req = Request.create(fd, 'addr')
+        req = Request.create('app', fd, 'addr')
        self.assertIsNone(req.form)
--- a/tests/microdot/test_response.py
+++ b/tests/microdot/test_response.py
@@ -161,9 +161,34 @@ class TestResponse(unittest.TestCase):
            res = Response.send_file('tests/files/' + file)
            self.assertEqual(res.status_code, 200)
            self.assertEqual(res.headers['Content-Type'], content_type)
-            self.assertEqual(res.body.read(), b'foo\n')
+            fd = io.BytesIO()
+            res.write(fd)
+            response = fd.getvalue()
+            self.assertEqual(response, (
+                b'HTTP/1.0 200 OK\r\nContent-Type: ' + content_type.encode()
+                + b'\r\n\r\nfoo\n'))
        res = Response.send_file('tests/files/test.txt',
                                 content_type='text/html')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(res.headers['Content-Type'], 'text/html')
-        self.assertEqual(res.body.read(), b'foo\n')
+        fd = io.BytesIO()
+        res.write(fd)
+        response = fd.getvalue()
+        self.assertEqual(
+            response,
+            b'HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\nfoo\n')
+
+    def test_send_file_small_buffer(self):
+        original_buffer_size = Response.send_file_buffer_size
+        Response.send_file_buffer_size = 2
+        res = Response.send_file('tests/files/test.txt',
+                                 content_type='text/html')
+        self.assertEqual(res.status_code, 200)
+        self.assertEqual(res.headers['Content-Type'], 'text/html')
+        fd = io.BytesIO()
+        res.write(fd)
+        response = fd.getvalue()
+        self.assertEqual(
+            response,
+            b'HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\nfoo\n')
+        Response.send_file_buffer_size = original_buffer_size
--- a/tests/microdot_asyncio/test_microdot_asyncio.py
+++ b/tests/microdot_asyncio/test_microdot_asyncio.py
@@ -14,6 +14,14 @@ class TestMicrodotAsync(unittest.TestCase):
        # restore original socket module
        sys.modules['microdot_asyncio'].asyncio = self.original_asyncio

+    def _add_shutdown(self, app):
+        @app.route('/shutdown')
+        def shutdown(req):
+            app.shutdown()
+            return ''
+
+        mock_socket.add_request('GET', '/shutdown')
+
    def test_get_request(self):
        app = Microdot()

@@ -28,7 +36,8 @@ class TestMicrodotAsync(unittest.TestCase):
        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
        fd2 = mock_socket.add_request('GET', '/async')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -56,7 +65,8 @@ class TestMicrodotAsync(unittest.TestCase):
        mock_socket.clear_requests()
        fd = mock_socket.add_request('POST', '/')
        fd2 = mock_socket.add_request('POST', '/async')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -94,7 +104,8 @@ class TestMicrodotAsync(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/bar')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 202 N/A\r\n'))
        self.assertIn(b'X-One: 1\r\n', fd.response)
        self.assertIn(b'Set-Cookie: foo=bar\r\n', fd.response)
@@ -104,7 +115,8 @@ class TestMicrodotAsync(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/baz')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'X-One: 1\r\n', fd.response)
        self.assertIn(b'Set-Cookie: foo=bar\r\n', fd.response)
@@ -121,7 +133,8 @@ class TestMicrodotAsync(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/foo')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 404 N/A\r\n'))
        self.assertIn(b'Content-Length: 9\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -140,7 +153,8 @@ class TestMicrodotAsync(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/foo')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 200 OK\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -155,7 +169,8 @@ class TestMicrodotAsync(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 500 N/A\r\n'))
        self.assertIn(b'Content-Length: 21\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -174,7 +189,8 @@ class TestMicrodotAsync(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 501 N/A\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
@@ -193,7 +209,8 @@ class TestMicrodotAsync(unittest.TestCase):

        mock_socket.clear_requests()
        fd = mock_socket.add_request('GET', '/')
-        self.assertRaises(IndexError, app.run)
+        self._add_shutdown(app)
+        app.run()
        self.assertTrue(fd.response.startswith(b'HTTP/1.0 501 N/A\r\n'))
        self.assertIn(b'Content-Length: 3\r\n', fd.response)
        self.assertIn(b'Content-Type: text/plain\r\n', fd.response)
--- a/tests/microdot_asyncio/test_request_asyncio.py
+++ b/tests/microdot_asyncio/test_request_asyncio.py
@@ -15,7 +15,8 @@ def _run(coro):
 class TestRequestAsync(unittest.TestCase):
    def test_create_request(self):
        fd = get_async_request_fd('GET', '/foo')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
+        self.assertEqual(req.app, 'app')
        self.assertEqual(req.client_addr, 'addr')
        self.assertEqual(req.method, 'GET')
        self.assertEqual(req.path, '/foo')
@@ -35,7 +36,7 @@ class TestRequestAsync(unittest.TestCase):
            'Content-Type': 'application/json',
            'Cookie': 'foo=bar;abc=def',
            'Content-Length': '3'}, body='aaa')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
        self.assertEqual(req.headers, {
            'Host': 'example.com:1234',
            'Content-Type': 'application/json',
@@ -48,33 +49,33 @@ class TestRequestAsync(unittest.TestCase):

    def test_args(self):
        fd = get_async_request_fd('GET', '/?foo=bar&abc=def&x=%2f%%')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
        self.assertEqual(req.query_string, 'foo=bar&abc=def&x=%2f%%')
        self.assertEqual(req.args, {'foo': 'bar', 'abc': 'def', 'x': '/%%'})

    def test_json(self):
        fd = get_async_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/json'}, body='{"foo":"bar"}')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
        json = req.json
        self.assertEqual(json, {'foo': 'bar'})
        self.assertTrue(req.json is json)

        fd = get_async_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/json'}, body='[1, "2"]')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
        self.assertEqual(req.json, [1, '2'])

        fd = get_async_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/xml'}, body='[1, "2"]')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
        self.assertIsNone(req.json)

    def test_form(self):
        fd = get_async_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/x-www-form-urlencoded'},
            body='foo=bar&abc=def&x=%2f%%')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
        form = req.form
        self.assertEqual(form, {'foo': 'bar', 'abc': 'def', 'x': '/%%'})
        self.assertTrue(req.form is form)
@@ -82,5 +83,5 @@ class TestRequestAsync(unittest.TestCase):
        fd = get_async_request_fd('GET', '/foo', headers={
            'Content-Type': 'application/json'},
            body='foo=bar&abc=def&x=%2f%%')
-        req = _run(Request.create(fd, 'addr'))
+        req = _run(Request.create('app', fd, 'addr'))
        self.assertIsNone(req.form)
--- a/tests/microdot_asyncio/test_response_asyncio.py
+++ b/tests/microdot_asyncio/test_response_asyncio.py
@@ -84,3 +84,28 @@ class TestResponseAsync(unittest.TestCase):
        self.assertIn(b'Content-Length: 8\r\n', fd.response)
        self.assertIn(b'Content-Type: application/json\r\n', fd.response)
        self.assertTrue(fd.response.endswith(b'\r\n\r\n[1, "2"]'))
+
+    def test_send_file(self):
+        res = Response.send_file('tests/files/test.txt',
+                                 content_type='text/html')
+        self.assertEqual(res.status_code, 200)
+        self.assertEqual(res.headers['Content-Type'], 'text/html')
+        fd = FakeStreamAsync()
+        _run(res.write(fd))
+        self.assertEqual(
+            fd.response,
+            b'HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\nfoo\n')
+
+    def test_send_file_small_buffer(self):
+        original_buffer_size = Response.send_file_buffer_size
+        Response.send_file_buffer_size = 2
+        res = Response.send_file('tests/files/test.txt',
+                                 content_type='text/html')
+        self.assertEqual(res.status_code, 200)
+        self.assertEqual(res.headers['Content-Type'], 'text/html')
+        fd = FakeStreamAsync()
+        _run(res.write(fd))
+        self.assertEqual(
+            fd.response,
+            b'HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\nfoo\n')
+        Response.send_file_buffer_size = original_buffer_size
--- a/tests/mock_asyncio.py
+++ b/tests/mock_asyncio.py
@@ -5,38 +5,35 @@ except ImportError:

 from tests import mock_socket

-_calls = []
-
-
-class EventLoop:
-    def run_until_complete(self, coro):
-        _calls.append(('run_until_complete', coro))
-        self.coro = coro
-
-    def run_forever(self):
-        _calls.append(('run_forever',))
-
-        async def rf():
-            s = mock_socket.socket()
-            while True:
-                fd, addr = s.accept()
-                fd = mock_socket.FakeStreamAsync(fd)
-                await self.coro(fd, fd)
-
-        asyncio.get_event_loop().run_until_complete(rf())
-
-    def close(self):
-        pass
-
-
-loop = EventLoop()
-

 def get_event_loop():
-    _calls.append(('get_event_loop',))
-    return loop
+    return asyncio.get_event_loop()


-def start_server(cb, host, port):
-    _calls.append(('start_server', cb, host, port))
-    return cb
+async def start_server(cb, host, port):
+    class MockServer:
+        def __init__(self):
+            self.closed = False
+
+        async def run(self):
+            s = mock_socket.socket()
+            while not self.closed:
+                fd, addr = s.accept()
+                fd = mock_socket.FakeStreamAsync(fd)
+                await cb(fd, fd)
+
+        def close(self):
+            self.closed = True
+
+        async def wait_closed(self):
+            while not self.closed:
+                await asyncio.sleep(0.01)
+
+    server = MockServer()
+    asyncio.get_event_loop().create_task(server.run())
+    return server
+
+
+def run(coro):
+    loop = asyncio.get_event_loop()
+    return loop.run_until_complete(coro)
--- a/tests/mock_socket.py
+++ b/tests/mock_socket.py
@@ -6,12 +6,10 @@ except ImportError:
 SOL_SOCKET = 'SOL_SOCKET'
 SO_REUSEADDR = 'SO_REUSEADDR'

-_calls = []
 _requests = []


 def getaddrinfo(host, port):
-    _calls.append(('getaddrinfo', host, port))
    return (('family', 'addr'), 'socktype', 'proto', 'canonname', 'sockaddr')


@@ -20,19 +18,21 @@ class socket:
        self.request_index = 0

    def setsockopt(self, level, optname, value):
-        _calls.append(('setsockopt', level, optname, value))
+        pass

    def bind(self, addr):
-        _calls.append(('bind', addr))
+        pass

    def listen(self, backlog):
-        _calls.append(('listen', backlog))
+        pass

    def accept(self):
-        _calls.append(('accept',))
        self.request_index += 1
        return _requests[self.request_index - 1], 'addr'

+    def close(self):
+        pass
+

 class FakeStream(io.BytesIO):
    def __init__(self, input_data):
--- a/tools/Dockerfile
+++ b/tools/Dockerfile
@@ -0,0 +1,25 @@
+FROM ubuntu:latest
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt-get install -y build-essential libffi-dev git pkg-config python python3 && \
+    rm -rf /var/lib/apt/lists/* && \
+    git clone https://github.com/micropython/micropython.git && \
+    cd micropython && \
+    git checkout v1.15 && \
+    git submodule update --init && \
+    cd mpy-cross && \
+    make && \
+    cd .. && \
+    cd ports/unix && \
+    make axtls && \
+    make && \
+    make test && \
+    make install && \
+    apt-get purge --auto-remove -y  build-essential libffi-dev git pkg-config python python3 && \
+    cd ../../.. && \
+    rm -rf micropython
+
+CMD ["/usr/local/bin/micropython"]
+
--- a/tools/update-micropython.sh
+++ b/tools/update-micropython.sh
@@ -0,0 +1,6 @@
+# this script updates the micropython binary in the /bin directory that is
+# used to run unit tests under GitHub Actions builds
+docker build -t micropython .
+docker create -it --name dummy-micropython micropython
+docker cp dummy-micropython:/usr/local/bin/micropython ../bin/micropython
+docker rm dummy-micropython
--- a/tox.ini
+++ b/tox.ini
@@ -23,7 +23,7 @@ deps=coverage
 deps=
    flake8
 commands=
-    flake8 --exclude tests/libs microdot microdot-asyncio tests
+    flake8 --ignore=W503 --exclude tests/libs microdot microdot-asyncio tests

 [testenv:upy]
 whitelist_externals=sh
Author	SHA1	Message	Date
Miguel Grinberg	4eea7adb8f	Release v0.4.0	2021-06-04 17:16:18 +01:00
Miguel Grinberg	a3288a63ed	Add method specific route decorators	2021-06-04 17:14:38 +01:00
Miguel Grinberg	3bd7fe8cea	Update microypthon binary to 1.15	2021-06-04 16:57:51 +01:00
Miguel Grinberg	0ad538df91	Server shutdown (Fixes #19 )	2021-06-04 16:01:07 +01:00