Ultra fast asyncio event loop.

Overview
https://travis-ci.org/MagicStack/uvloop.svg?branch=master PyPI - Downloads

uvloop is a fast, drop-in replacement of the built-in asyncio event loop. uvloop is implemented in Cython and uses libuv under the hood.

The project documentation can be found here. Please also check out the wiki.

Performance

uvloop makes asyncio 2-4x faster.

https://raw.githubusercontent.com/MagicStack/uvloop/master/performance.png

The above chart shows the performance of an echo server with different message sizes. The sockets benchmark uses loop.sock_recv() and loop.sock_sendall() methods; the streams benchmark uses asyncio high-level streams, created by the asyncio.start_server() function; and the protocol benchmark uses loop.create_server() with a simple echo protocol. Read more about uvloop in a blog post about it.

Installation

uvloop requires Python 3.7 or greater and is available on PyPI. Use pip to install it:

$ pip install uvloop

Note that it is highly recommended to upgrade pip before installing uvloop with:

$ pip install -U pip

Using uvloop

Call uvloop.install() before calling asyncio.run() or manually creating an asyncio event loop:

import asyncio
import uvloop

async def main():
    # Main entry-point.
    ...

uvloop.install()
asyncio.run(main())

Building From Source

To build uvloop, you'll need Python 3.7 or greater:

  1. Clone the repository:

    $ git clone --recursive [email protected]:MagicStack/uvloop.git
    $ cd uvloop
    
  2. Create a virtual environment and activate it:

    $ python3.7 -m venv uvloop-dev
    $ source uvloop-dev/bin/activate
    
  3. Install development dependencies:

    $ pip install -e .[dev]
    
  4. Build and run tests:

    $ make
    $ make test
    

License

uvloop is dual-licensed under MIT and Apache 2.0 licenses.

Issues
  • UVTimer leaks

    UVTimer leaks

    • uvloop version: 0.4.29
    • python version: 3.5.1
    • platform: FreeBSD

    We are seeing a serious memory leak that only shows up when using UVLoop on Gunicorn. Examining the GC state does not show anything useful, which indicates to me that it is likely inside native code, so I report this here. Under moderate load, we see each Gunicorn worker taking 2GB ram within 18-24 hours.

    We are presently retesting under 0.4.32 and will update if we still see it. If you have any suggestions for debugging it that may be helpful, that would be useful too. We only see this leak under UVLoop and not the default asyncio loop, so it has to be related to UVLoop.

    resolved 
    opened by kaniini 32
  • Rewrite asyncio/sslproto.py

    Rewrite asyncio/sslproto.py

    Problems with sslproto.py

    • The code is very complex and hard to reason about. At this point it's pretty much unmaintainable, many bugs on bugs.python.org linger unresolved just because we don't have capacity to debug them or review PRs.

    • It's very slow. SSL connections are 3-4x slower than regular connections.

    • It has many yet unresolved problems associated with SSL connection shutdown and cleanup:

      • https://bugs.python.org/issue30698
      • https://bugs.python.org/issue29406
      • https://bugs.python.org/issue25292
    • We don't have enough functional tests for SSL in asyncio. Especially ones that test cancellation & timeouts thoroughly enough.

    Requirements for the new implementation

    • Easy to understand code. Ideally, the state machine should be implemented right in the SSLProtocol (so no SSLPipe abstraction). A good example of a protocol state machine is asyncpg's CoreProtocol <-> Protocol <-> Connection mechanism.

    • Performance. Ideally, SSL connections shouldn't be more than 10% slower.

    • Tests. Nathaniel once mentioned that Trio's SSL tests are very robust and that he found bugs in CPython's ssl module with them. We maybe want to backport them to asyncio.

    • SSL tunneled through SSL should be naturally supported.

    Suggested steps towards the new implementation

    1. Try to benchmark the current asyncio/sslproto.py. Maybe we'll be able to pinpoint the exact bottleneck that makes it so slow; what if there's a bug in ssl module? Most likely there's no single bottleneck, and the reason for poor performance is just its inefficient code.

    2. Implement a new SSL state machine/protocol in pure Python (I suggest to use new asyncio.BufferedProtocol from the beginning, though.) Get it to the point that it passes asyncio's existing SSL tests. Add more tests.

    3. Once we have a working pure Python implementation, we can (a) contribute it to Python 3.8, (b) start optimizing it in Cython for uvloop.

    cc @fantix

    enhancement 
    opened by 1st1 30
  • Hang waiting for create_server

    Hang waiting for create_server

    • uvloop 0.4.33:
    • python 3.5.1, 3.5.2:
    • platform Mac OS X, Ubuntu 16.04/4.4.12-boot2docker:

    I need some suggestions for debugging server startup hangs.

    Startup code looks like:

     cr = loop.create_server(self.factory, addr[0], addr[1],
                                    reuse_address=True, ssl=ssl)
    f = asyncio.async(cr, loop=loop)
    server = loop.run_until_complete(f)
    

    What's sometimes happening, in the context of the ZEO tests, is that the run_loop_until_complete call above never returns.

    This is in a port of ZEO, github.com/zopefoundation/ZEO, to asyncio. The ZEO tests are exhaustive, and I suspect in uvloop's case, exhausting. :) The tests start and stop servers 10s, maybe 100s of times in a test runs that typically lasts a few minutes. If I run a smaller subset of the tests I don't get a hang.

    Most tests run the server as a subprocess using multiprocessing. Some tests run the server using threading. It appears that the server isn't exiting, but merely hanging.

    Do you have any suggestions for how to debug this? I've tried setting PYTHONASYNCIODEBUG=1 and enabling debug logging, but that isn't yielding any additional information..

    libuv 
    opened by jimfulton 26
  • Rewrite sslproto.py

    Rewrite sslproto.py

    State transition:

    State transition

    Recv/send calling chain:

    Recv/send calling chain

    Reworked flow control:

    Reworked flow control

    SSLProtocol internals (shutdown detail):

    SSLProtocol

    SSLObject methods internals:

    SSLObject

    Refs #158, ~this is a WIP yet, please kindly wait until ready for review.~

    TODOs:

    • [x] Pass cpython tests
    • [x] Pass uvloop tests
    • [x] Test SSL over SSL
    • [x] Correct shutdown (graceful close) data flush and cover with test
    • [x] Test renegotiation (with pyOpenSSL)
    • [x] Port Trio tests
    • [x] Maybe extract a cdef class for both performance and readibility
    • [x] Add test for https://bugs.python.org/issue30698
    • [x] https://bugs.python.org/issue29406
    • [x] https://bugs.python.org/issue25292
    • [x] Fix eof_received() implementation
    • [x] Backport to cpython and pass tests
    • [x] Cythonize transport
    • [x] Extract high/low water mark
    • [x] Make sure memory management is good
    • [x] ~Check sendfile support~
    opened by fantix 24
  • Unable to install uvloop

    Unable to install uvloop

    pip install uvloop throws this error

        Traceback (most recent call last):
          File "<string>", line 1, in <module>
          File "/tmp/pip-build-3p6l9uj5/uvloop/setup.py", line 81, in <module>
            include_package_data=True
          File "/usr/lib/python3.5/distutils/core.py", line 148, in setup
            dist.run_commands()
          File "/usr/lib/python3.5/distutils/dist.py", line 955, in run_commands
            self.run_command(cmd)
          File "/usr/lib/python3.5/distutils/dist.py", line 974, in run_command
            cmd_obj.run()
          File "/home/anand/.virtualenvs/35/lib/python3.5/site-packages/setuptools/command/install.py", line 61, in run
            return orig.install.run(self)
          File "/usr/lib/python3.5/distutils/command/install.py", line 583, in run
            self.run_command('build')
          File "/usr/lib/python3.5/distutils/cmd.py", line 313, in run_command
            self.distribution.run_command(command)
          File "/usr/lib/python3.5/distutils/dist.py", line 974, in run_command
            cmd_obj.run()
          File "/usr/lib/python3.5/distutils/command/build.py", line 135, in run
            self.run_command(cmd_name)
          File "/usr/lib/python3.5/distutils/cmd.py", line 313, in run_command
            self.distribution.run_command(command)
          File "/usr/lib/python3.5/distutils/dist.py", line 974, in run_command
            cmd_obj.run()
          File "/home/anand/.virtualenvs/35/lib/python3.5/site-packages/setuptools/command/build_ext.py", line 49, in run
            _build_ext.run(self)
          File "/usr/lib/python3.5/distutils/command/build_ext.py", line 338, in run
            self.build_extensions()
          File "/tmp/pip-build-3p6l9uj5/uvloop/setup.py", line 40, in build_extensions
            self.build_libuv()
          File "/tmp/pip-build-3p6l9uj5/uvloop/setup.py", line 35, in build_libuv
            subprocess.run(['make', j_flag], cwd=LIBUV_DIR, env=env, check=True)
          File "/usr/lib/python3.5/subprocess.py", line 711, in run
            output=stdout, stderr=stderr)
        subprocess.CalledProcessError: Command '['make', '-j4']' returned non-zero exit status 2
    
        ----------------------------------------
    
    resolved 
    opened by ChillarAnand 21
  • 'coroutine' object is not iterable

    'coroutine' object is not iterable

    • uvloop version: 0.9.1
    • Python version: 3.6
    • Platform: Ubuntu Xenial

    Version 0.9.1: I got an error

     File "/app/app/<***>/utils.py", line 35, in <***>
        async with app['client_session'].get(url) as response:
      File "/usr/local/lib/python3.6/dist-packages/aiohttp/client.py", line 690, in __aenter__
        self._resp = yield from self._coro
      File "/usr/local/lib/python3.6/dist-packages/aiohttp/client.py", line 267, in _request
        conn = yield from self._connector.connect(req)
      File "/usr/local/lib/python3.6/dist-packages/aiohttp/connector.py", line 402, in connect
        proto = yield from self._create_connection(req)
      File "/usr/local/lib/python3.6/dist-packages/aiohttp/connector.py", line 748, in _create_connection
        _, proto = yield from self._create_direct_connection(req)
      File "/usr/local/lib/python3.6/dist-packages/aiohttp/connector.py", line 831, in _create_direct_connection
        req=req, client_error=client_error)
      File "/usr/local/lib/python3.6/dist-packages/aiohttp/connector.py", line 796, in _wrap_create_connection
        return (yield from self._loop.create_connection(*args, **kwargs))
    TypeError: 'coroutine' object is not iterable
    

    Version 0.8.1: Not reproduced

    The error does not depend on other libraries.

    opened by oleksandr-kuzmenko 20
  • uvloop alpha release

    uvloop alpha release

    Some ToDo items we need completed before we make an alpha release:

    • [x] Implement loop.create_connection
    • [x] Add few more tests for loop.create_server to increase the coverage
    • [x] Add a few high-level tests involving aiohttp or another real codebase
    • [x] Implement loop.create_unix_server
    • [x] Implement loop.create_unix_connection
    • [x] Implement loop.subprocess_shell and loop.subprocess_exec
    • [x] Implement loop.getnameinfo
    • [x] Implement loop.add_signal_handler and loop.remove_signal_handler
    • [x] Implement loop.connect_read_pipe and loop.connect_write_pipe
    • [x] Implement SSL
    • [x] Implement loop.create_datagram_endpoint
    opened by 1st1 19
  • Support for PY37 without contextvars

    Support for PY37 without contextvars

    This MR aligns the uvloop code to become compatible, not production ready, with PY37 adding the following changes:

    • Support for the new API used behind the set_debug function.
    • Adds the context=None KW to those functions that will receive it when uvloop runs with PY37.
    • Former asyncio.test_utils moved as an uvloop test resource.

    New MR on top of that to enable contextvars should be expected.

    opened by pfreixes 18
  • uvloop build failed on Python 3.8

    uvloop build failed on Python 3.8

    • uvloop version: 0.13.0
    • Python version: 3.8
    • Platform: Linux (Ubuntu Xenial, Fedora 30)
    • Can you reproduce the bug with PYTHONASYNCIODEBUG in env?: No, can't even build uvloop

    Hello,

    Two days ago new stable Python version 3.8.0 has been released. Today I updated test matrix for one of my projects and noticed uvloop fails to install: https://travis-ci.org/Snawoot/postfix-mta-sts-resolver/jobs/598694743

    Steps to reproduce:

    pip3.8 install uvloop
    
    fixed in master 
    opened by Snawoot 17
  • memory leak with 0.12.0

    memory leak with 0.12.0

    • uvloop version: 0.12.0
    • Python version: 3.7.2
    • Platform: Mac os and Docker
    • Can you reproduce the bug with PYTHONASYNCIODEBUG in env?: Have not tried yet

    Recently I upgraded from 0.11.3 to 0.12.0. I use uvloop to constantly pull data from an API and insert into a database. After running for a couple of minutes, I found that my memory usage jumped from ~100MB to ~450mb. Has anybody else run into this issue? I have a lot going on so reproducing it with a smaller gist would be hard right now. But reverting back to 0.11.3 immediately fixed the issue. So I am guessing something is related to the upgrade.

    bug 
    opened by amir20 17
  • uvloop install fail in docker w/ pip install

    uvloop install fail in docker w/ pip install

    Hello! Trying to install uvloop in a python app within a docker image. I am currently getting the following errors (below).

    • uvloop version: latest
    • Python version: 3.7
    • Platform: Docker (python:alpine3.7)
    • Can you reproduce the bug with PYTHONASYNCIODEBUG in env?: haven't tried

    unable to install uvloop in docker, the same configuration works outside of the container. requirements.txt: asyncio uvloop asyncpg Dockerfile: RUN python3 -m pip install -r requirements.txt

    Error:

    Collecting uvloop (from -r requirements.txt (line 3)) Downloading https://files.pythonhosted.org/packages/d4/50/385f5dfd008508750a255ae742aaea6cc7f58877d9444b2d759543b0ee72/uvloop-0.10.1.tar.gz (1.9MB) Collecting asyncpg==0.16.0 (from -r requirements.txt (line 4)) Downloading https://files.pythonhosted.org/packages/89/62/6d218bc7d1412b837ed6f006a42a660fc970c3135c22c55f2370a93e11d4/asyncpg-0.16.0.tar.gz (615kB) Complete output from command python setup.py egg_info: error in asyncpg setup command: 'extras_require' requirements cannot include environment markers, in 'test': 'uvloop>=0.8.0; platform_system != "Windows"'

    again, the same requirements file work outside of docker (mac os + python 3.6)

    opened by pepie 17
  • expose libuv uv_fs_event functionality

    expose libuv uv_fs_event functionality

    It's quite natural for filesystem monitoring to be part of the event loop, and libuv has done a cross-platform implementation. Actually asyncio should probably expose this as well--maybe they will draw from this example implementation to inform their own api?

    I wasn't sure what the best way to expose the FS_EVENT_* constants was--I preferred to have them refer directly to the constants defined in libuv but I'm a cython newb and I couldn't get the right incantation. In the merge below they are hardcoded in uvloop.const. Maybe you can suggest a better way.

    opened by jensbjorgensen 3
  • `_SSLProtocolTransport.close()` cannot close the connection until timeout or EOF

    `_SSLProtocolTransport.close()` cannot close the connection until timeout or EOF

    • uvloop version: 0.16.0
    • Python version: CPython 3.9.12
    • Platform: Debian GNU/Linux bookworm/sid x86_64
    • Can you reproduce the bug with PYTHONASYNCIODEBUG in env?: yes
    • Does uvloop behave differently from vanilla asyncio? How?: yes, the bug is only reproducible with uvloop

    Desciption

    If uvloop is enabled, as long as EOF is not reached, even if the response, connection, and session are all closed, the server from which aiohttp requested resources, will still keep sending packets to the aiohttp-client for some time. However, the bug is only reproducible with uvloop enabled.

    To reproduce

    aiohttp[speedups]==3.8.1
    uvloop==0.16.0
    
    import asyncio
    import aiohttp
    import uvloop
    import logging
    
    logging.basicConfig(level=logging.DEBUG)
    
    
    async def fetch(url):
        async with aiohttp.ClientSession() as session:
            async with session.get(url) as response:
                logging.debug(response)
                logging.debug(response.content)
    
    
    async def reproduce(wait):
        await fetch('https://sgp-ping.vultr.com/vultr.com.1000MB.bin')
        await asyncio.sleep(wait)  # now you will see that the file is still being downloaded
    
    
    def main(enable_uvloop):
        if enable_uvloop:
            logging.info('********** Using uvloop **********')
            uvloop.install()  # the bug is only reproducible with uvloop
        else:
            logging.info('********** Using asyncio **********')
        loop = asyncio.new_event_loop()
        loop.set_debug(True)  # or set env PYTHONASYNCIODEBUG=1, not necessary to reproduce the bug
        asyncio.set_event_loop(loop)
        loop.run_until_complete(reproduce(15 if enable_uvloop else 5))
        loop.close()
    
    
    if __name__ == '__main__':
        main(enable_uvloop=False)
        main(enable_uvloop=True)
        input('Press Enter to exit')
    

    Log and screenshot

    INFO:root:********** Using asyncio **********
    DEBUG:asyncio:Using selector: EpollSelector
    DEBUG:asyncio:Get address info sgp-ping.vultr.com:443, type=<SocketKind.SOCK_STREAM: 1>, flags=<AddressInfo.AI_ADDRCONFIG: 32>
    INFO:asyncio:Getting address info sgp-ping.vultr.com:443, type=<SocketKind.SOCK_STREAM: 1>, flags=<AddressInfo.AI_ADDRCONFIG: 32> took 209.423ms: [(<AddressFamily.AF_INET: 2>, <SocketKind.SOCK_STREAM: 1>, 6, '', ('45.32.100.168', 443))]
    DEBUG:asyncio:<asyncio.sslproto.SSLProtocol object at 0x7fc80064dfa0> starts SSL handshake
    DEBUG:asyncio:<asyncio.sslproto.SSLProtocol object at 0x7fc80064dfa0>: SSL handshake took 225.2 ms
    DEBUG:asyncio:<asyncio.TransportSocket fd=6, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=6, laddr=('192.168.1.101', 51708), raddr=('45.32.100.168', 443)> connected to 45.32.100.168:443: (<asyncio.sslproto._SSLProtocolTransport object at 0x7fc7ff9b5a00>, <aiohttp.client_proto.ResponseHandler object at 0x7fc800205b20>)
    DEBUG:root:<ClientResponse(https://sgp-ping.vultr.com/vultr.com.1000MB.bin) [200 OK]>
    <CIMultiDictProxy('Server': 'nginx', 'Date': 'Sat, 21 May 2022 00:29:55 GMT', 'Content-Type': 'application/octet-stream', 'Content-Length': '1048576000', 'Last-Modified': 'Mon, 20 Sep 2021 19:54:01 GMT', 'Connection': 'keep-alive', 'Etag': '"6148e6d9-3e800000"', 'Expires': 'Sun, 22 May 2022 00:29:55 GMT', 'Cache-Control': 'max-age=86400', 'X-Frame-Options': 'DENY', 'X-Content-Type-Options': 'nosniff', 'Access-Control-Allow-Origin': '*', 'Accept-Ranges': 'bytes')>
    
    DEBUG:root:<StreamReader 15968 bytes>
    DEBUG:asyncio:<asyncio.sslproto.SSLProtocol object at 0x7fc80064dfa0>: SSL error in data received
    Traceback (most recent call last):
      File "/usr/lib/python3.9/asyncio/sslproto.py", line 534, in data_received
        ssldata, appdata = self._sslpipe.feed_ssldata(data)
      File "/usr/lib/python3.9/asyncio/sslproto.py", line 206, in feed_ssldata
        self._sslobj.unwrap()
      File "/usr/lib/python3.9/ssl.py", line 948, in unwrap
        return self._sslobj.shutdown()
    ssl.SSLError: [SSL: APPLICATION_DATA_AFTER_CLOSE_NOTIFY] application data after close notify (_ssl.c:2756)
    DEBUG:asyncio:Close <_UnixSelectorEventLoop running=False closed=False debug=True>
    INFO:root:********** Using uvloop **********
    DEBUG:asyncio:<uvloop.loop.SSLProtocol object at 0x7fc8040f8b40> starts SSL handshake
    DEBUG:asyncio:<uvloop.loop.SSLProtocol object at 0x7fc8040f8b40>: SSL handshake took 227.0 ms
    DEBUG:root:<ClientResponse(https://sgp-ping.vultr.com/vultr.com.1000MB.bin) [200 OK]>
    <CIMultiDictProxy('Server': 'nginx', 'Date': 'Sat, 21 May 2022 00:30:01 GMT', 'Content-Type': 'application/octet-stream', 'Content-Length': '1048576000', 'Last-Modified': 'Mon, 20 Sep 2021 19:54:01 GMT', 'Connection': 'keep-alive', 'Etag': '"6148e6d9-3e800000"', 'Expires': 'Sun, 22 May 2022 00:30:01 GMT', 'Cache-Control': 'max-age=86400', 'X-Frame-Options': 'DENY', 'X-Content-Type-Options': 'nosniff', 'Access-Control-Allow-Origin': '*', 'Accept-Ranges': 'bytes')>
    
    DEBUG:root:<StreamReader 15968 bytes>
    Press Enter to exit	
    

    The bug has also been reported to aiohttp: https://github.com/aio-libs/aiohttp/issues/6762

    opened by Rongronggg9 8
  • TimerHandle.when() segfault fix

    TimerHandle.when() segfault fix

    Calling TimerHandle.when() after the timer has fired will cause a segmentation fault because when the timer completes self._clear() is called which will set timer to None.

    opened by j0x539 1
  • TimerHandle.when() segfaults if called after callback

    TimerHandle.when() segfaults if called after callback

    • uvloop version: uvloop==0.16.0
    • Python version: 3.10.4
    • Platform: Linux-5.17.5-200.fc35.x86_64-x86_64-with-glibc2.34
    • Can you reproduce the bug with PYTHONASYNCIODEBUG in env?: Yes
    • Does uvloop behave differently from vanilla asyncio? How?: It segfaults.

    Calling when() on a TimerHandle object after callback has been executed causes a core dump.

    import uvloop
    import asyncio
    
    
    async def main():
        loop = asyncio.get_running_loop()
        timer = loop.call_later(0.1, lambda: None) # call any function
        await asyncio.sleep(0.2)
        timer.when() # segfault happens here
        
    uvloop.install()
    asyncio.run(main())
    
    opened by j0x539 0
Releases(v0.16.0)
  • v0.16.0(Aug 10, 2021)

    This release adds Python 3.10 support, updates bundled libuv to 1.42.0 and fixes a handful of issues.

    Changes

    • Python 3.10 support (#432) (by @elprans in 2519e2df for #432)

    • Bump vendored libuv to 1.42.0 (#433) (by @elprans in a62f7818 for #433)

    • Use cibuildwheel to build wheels (#435) (by @elprans in 20febe0b for #435)

    • Add support for <timer handle>.when() (by Jens Jorgensen in 62b2af9c)

    Fixes

    • Fix ref issue when protocol is in Cython (by @fantix in 70cafc82 for #2222)

    • Set python_requires in setup.py (by @graingert in c808a663)

    • SSL: schedule first data after waiter wakeup (by @fantix in 2081db89)

    • Fix a possible race condition in sslproto test (by @fantix in b0526cd5 for #412)

    • Fix call_soon_threadsafe thread safety (by @fantix in 4b803b15)

    Source code(tar.gz)
    Source code(zip)
  • v0.15.3(Jul 13, 2021)

    Bug Fixes

    • SSL: schedule first data after waiter wakeup (by @fantix in 0df12282)

    • Fix a possible race condition in sslproto test (by @fantix in 2e71c4c2 for #412)

    • Fix call_soon_threadsafe thread safety (by @fantix and @hehaha in 6387a4e4 for #408)

    Source code(tar.gz)
    Source code(zip)
  • v0.15.2(Feb 19, 2021)

  • v0.15.1(Feb 15, 2021)

  • v0.15.0(Feb 10, 2021)

    New Features

    • Add name keyword argument to loop.create_task() (by @fantix in d51ce367 for #309)

    • Add typing support (by @bryanforbes in 9426e2b1, for #358)

    Bug Fixes

    • SSL: many improvements (by @fantix in 6476aad6, 8beacd26, 98e113ee, ae44ec2d, @asvetlov in 9bc4a204)

    • Fix KeyboardInterrupt handling logic (by @1st1 in c32c7039 for #295, @jack1142 in 8c471f82 for #337)

    • Python 3.8/3.9 compatibility fixes, drop support for 3.5/3.6 (by @jack1142 in 28702195 for #314, @achimnol in 0d14ec64 for #328, @aeros in 6ef69a79 for #349, @shadchin in 1fd90665, @fantix in 465717fd, 200e1404, afc3ee8f, cdd2218f, b7048b94)

    • UDP: multiple bug fixes (by @fantix in 1d9267af for #319, 9e017e6e for #304, 506a2aa1)

    • Pipe: a critical crash fix that affects subprocess, pipe and socketpair (by @fantix in 5d41af80 and @tardyp in c3929720 for #311 #312 #317)

    • Restore context on protocol callbacks (by @versusvoid in 7b202ccf for #305, @fantix in f691212b)

    • Subprocess: stdio bug fixes (by @fantix in 8cdb3002 for #136, @lovasoa in 68db1a23 for #363)

    • Sock: fix issue in sock_connect() for large concurrency (by @fantix in fe3d0281 for #378)

    • Misc fixes about docs URL, test typo, and CI compatibility (by @asfaltboy in 38105305, @felixonmars in fcb37350, @fantix in 6596685a)

    Build

    • Check Cython version semantically (by @YoSTEALTH in 5dc299b7)

    • Add .flake8 to distribution tarball (by @jlaine in e8eb5026 for #330)

    • Switch to Github actions (by @elprans in 3be8967e, e21ceea0, @fantix in 311997ed)

    • Bump libuv to v1.40.0 (by @fantix in 998c19ec)

    Source code(tar.gz)
    Source code(zip)
  • v0.14.0(Nov 5, 2019)

    New Features

    • Add support for Python 3.8. (by @1st1 in 5f48dab8, 51636f7b)

    Bug Fixes

    • Multiple fixes in the SSL/TLS layer. (by @fantix in 82104fb6 for #263, 7fcbfed1 for #255, e6fd6377)

    • Restore signal.wakeup_fd after the event loop is closed. (by @vladima in 48d376d3, @1st1 in d76d9827)

    • Handle large timeouts in loop.call_later(). (by @1st1 in 1a0d6578 for #259)

    • Fix possible feezing of uvloop on os.fork. (by @grungy-ado in fde5d14f)

    • Better handle Unix sockets for datagram transports. (by @mosquito and @1st1 in dd4cb7ac for #269)

    • Avoid double connecting to remote_addr for datagram transports. (by @1st1 in bed926c5 for #276)

    Build

    • Bump Cython to 0.29.13. (by @1st1 in 65c1a045)

    • Bump libuv to v1.33.1. (by @1st1 in 34fd827e)

    Source code(tar.gz)
    Source code(zip)
  • v0.14.0rc2(Oct 29, 2019)

  • v0.14.0rc1(Oct 25, 2019)

    New Features

    • Add support for Python 3.8. (by @1st1 in 5f48dab8, 51636f7b)

    Bug Fixes

    • Multiple fixes in the SSL/TLS layer. (by @fantix in 82104fb6 for #263, 7fcbfed1 for #255)

    • Restore signal.wakeup_fd after the event loop is closed. (by @vladima in 48d376d3)

    • Handle large timeouts in loop.call_later(). (by @1st1 in 1a0d6578 for #259)

    • Fix possible feezing of uvloop on os.fork. (by @grungy-ado in fde5d14f)

    • Better handle Unix sockets for datagram transports. (by @mosquito and @1st1 in dd4cb7ac for #269)

    • Avoid double connecting to remote_addr for datagram transports. (by @1st1 in bed926c5 for #276)

    Build

    • Bump Cython to 0.29.13. (by @1st1 in 65c1a045)

    • Bump libuv to v1.33.1. (by @1st1 in 34fd827e)

    Source code(tar.gz)
    Source code(zip)
  • v0.13.0(Aug 14, 2019)

    New Features

    • Implement Server.start_serving() and related APIs. (by @jlaine in 7a4f00a3)

    • Make Server an asynchronous context manager. (by @jlaine in d6c67e7a for #221)

    Performance

    • Start using high-performance uv_udp_t handle. This should result in a significantly faster UDP support. (by @1st1 in c2b65bc8)

    • Make address validation faster in udp.sendto(). (by @1st1 in 46c5e9eb)

    Misc

    • OSError is no longer logged by Transports. This matches asyncio behaviour in 3.8. (by @Tobotimus in ef29dab2)

    Build

    • Upgrade to libuv v1.31.0. (by @1st1 in c2b65bc8 and 1fad621f)

    • Use manylinux-2010. This means we no longer provide 32bit builds for Linux. (by @1st1 in 3174b7d3)

    Source code(tar.gz)
    Source code(zip)
  • v0.13.0rc1(Apr 25, 2019)

    New Features

    • Implement Server.start_serving() and related APIs. (by @jlaine in 7a4f00a3)

    • Make Server an asynchronous context manager. (by @jlaine in d6c67e7a for #221)

    Performance

    • Start using high-performance uv_udp_t handle. This should result in a significantly faster UDP support. (by @1st1 in c2b65bc8)

    • Make address validation faster in udp.sendto(). (by @1st1 in 46c5e9eb)

    Build

    • Upgrade to libuv v1.28.0.
      This is a minimum requirement now. (by @1st1 in c2b65bc8)

    • Use manylinux-2010. This means we no longer provide 32bit builds for Linux. (by @1st1 in 3174b7d3)

    Source code(tar.gz)
    Source code(zip)
  • v0.12.2(Mar 20, 2019)

    Bug Fixes

    • Fix circular references in SSL implementation to reduce the need for GC. (by @fantix in 3070ec85)

    • Fix a memory leak in call_later() and call_at(). The leak occurred when a callback argument had a reference to the event loop. (by @1st1 in 1a5dbc28 for #239)

    • Fix compilation warnings. (by @JelleZijlstra in d9a111be)

    • Round (instead of flooring) delay in call_later(). This ensures that the callback is never called slightly before the specified time. (by @fantix in 8f037a68 for #233)

    Source code(tar.gz)
    Source code(zip)
  • v0.12.1(Feb 12, 2019)

    Bug Fixes

    • Fix a circular references case in SSL implementation. (by @fantix in a2e0dd8e for #220)

    • Cleanup references to callbacks in canceled callback handles.

      This removes potential reference cycles between bound methods and cancelled Handle / TimerHandle objects.

      (by @1st1 in f0a945df)

    Source code(tar.gz)
    Source code(zip)
  • v0.12.0(Jan 21, 2019)

    New Features

    • New SSL implementation. The new implementation is faster and and more complete, and might become the default SSL implementation in asyncio 3.9.

      See the linked issue for more details.

      (by @fantix in 9cba7493 for #158, #176)

    • New uvloop.install() helper function.

      Instead of

      import asyncio
      import uvloop
      asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
      

      it is now possible to simply write

      import uvloop
      uvloop.install()
      

      (by @1st1 in a3d8d401)

    Bug Fixes

    • All bug fixes from 0.11.00.11.3 are included in this release.

    • ssl.CertificateError is no longer logged as it's delivered to the Protocol.connection_lost() anyways. (by @fantix in 848e4785 for #195, #199)

    • Don't use non-existent UDPTransport._address attribute. (by @jlaine in f24c2c56 for #207)

    Performance

    • Improve UDPTransport.sendto() performance. (by @jlaine in d5ad2b86 for #214)

    Build

    • Upgrade Cython 0.28.x -> 0.29.0.

    • Upgrade libuv v1.22.0 -> v1.23.0.

    Source code(tar.gz)
    Source code(zip)
  • v0.12.0rc1(Nov 1, 2018)

    New Features

    • New SSL implementation. The new implementation is faster and and more complete, and will become the default SSL implementation in asyncio 3.8. This is a significant change that warrants a release candidate to make sure it is tested properly.

      See the linked issue for more details.

      (by @fantix in 9cba7493 for #158, #176)

    • New uvloop.install() helper function.

      Instead of

      import asyncio
      import uvloop
      asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
      

      it is now possible to simply write

      import uvloop
      uvloop.install()
      

      (by @1st1 in a3d8d401)

    Bug Fixes

    • All bug fixes from 0.11.00.11.3 are included in this release.

    • ssl.CertificateError is no longer logged as it's delivered to the Protocol.connection_lost() anyways. (by @fantix in 848e4785 for #195, #199)

    Build

    • Upgrade Cython 0.28.x -> 0.29.0.

    • Upgrade libuv v1.22.0 -> v1.23.0.

    Source code(tar.gz)
    Source code(zip)
  • v0.11.3(Oct 31, 2018)

    Bug Fixes

    • Use new PyOS_BeforeFork and PyOS_AfterFork_* 3.7 APIs when available (by @1st1 in 75e7c32a)

    • Fix async generators finalization to function correctly in debug mode (by @1st1 in dcbb1f4f for #200)

    • Pass backlog to loop.create_unix_server() when a server is created via loop.create_server(sock=unix_sock, backlog=backlog). (by @hikoz in 40ad257b)

    • Don't raise "requires a DNS lookup" error on Unix Domain Socket (#204) (by @pax0r in 9fc3ca2a for #204)

    • Fix use of PyContext* APIs in 3.7.1 (by @1st1 in 74748005)

    Build

    • Bump Cython to 0.28.5 (by @1st1 in 1bbd6a82)
    Source code(tar.gz)
    Source code(zip)
  • v0.11.2(Aug 7, 2018)

  • v0.10.3(Aug 7, 2018)

    Note: this is a bugfix release for 0.10.x branch. It's recommended to upgrade to 0.11.x.

    Bug Fixes

    • Fix a memory leak in contextvars support. (https://github.com/MagicStack/uvloop/pull/192 for more details)
    Source code(tar.gz)
    Source code(zip)
  • v0.11.1(Aug 2, 2018)

    Bug Fixes

    • Fix server to shutdown when alive connections exist (by @ciscorn in 5f71e29f for #180 in PR #181)

    • Fix a few bugs and crashes in UDP layer (by @1st1 in e0b5ea03, 5eef2d5f for #190)

    • Fix FD leakage if spawning a subprocess fails (by @1st1 in 4f6621eb for #185, #186)

    • Fix libuv process handles leak when uv_spawn() fails (by @1st1 in 92ea5179 for #187)

    Source code(tar.gz)
    Source code(zip)
  • v0.11.0(Jul 5, 2018)

    New Features

    • Implement support for BufferedProtocol. (by @1st1 in a959f274, 76b34bef, f9c43937)

    • Implement loop.start_tls(). (by @1st1 in 622ed9c5)

    • Add Server.get_loop(). (by @1st1 in 6a42f841)

    Bug Fixes

    • Fix Server to wait in wait_closed() until all transports are done. (by @1st1 in 124e981b)

    • SSLTransport.abort() should mark the transport as closed. (by @1st1 in 4d6621f7)

    • Fix 3.7 32bit builds. (by @1st1 in a68f3c9a, b5b4abb1 for #172)

    Build

    • setup.py: Detect if the libuv submodule has not been checked out. (by @1st1 in a190cddb)

    • Fix race between futures cancellation and loop.remove_reader() / loop.remove_writer(). (by @andr-04 and @1st1 in cb0a65ae for #169)

    • Enable 3.7 CI on Travis and build wheels for 3.7. (by @1st1 in 37f964b7 for #179)

    Source code(tar.gz)
    Source code(zip)
  • v0.10.2(Jun 25, 2018)

    Bug Fixes

    • Use a proper type for the thread indent (fixes 32-bit build for 3.7.) (by @1st1 in 700582a9 for #172)

    • Fix cancellation race in loop.sock_recv() and loop.sock_recv_into() methods. (by @andr-04 and @1st1 in 298851bf for #169)

    • Sync SSL error messages with CPython's SSL implementation. (by @1st1 in c3aeff2a)

    • Fix SSLTransport.abort() to mark the transport as closed. (by @1st1 in ba25d8be)

    • Detect if libuv submodule has not been checked out in setup.py. (by @1st1 in dd8060d2)

    Source code(tar.gz)
    Source code(zip)
  • v0.10.1(Jun 1, 2018)

    Bug Fixes

    • Bump Cython from 0.28.2 to 0.28.3. (by @1st1 in 5044d240)

    • Increase default SSL handshake timeout to 60 seconds. (by @1st1 in 70c332cf, fixes #161)

    • Add ssl_handshake_timeout parameter to loop.create_connection(), loop.create_server(), loop.create_unix_connection(), loop.create_unix_server(), loop.connect_accepted_socket(). (by @1st1 in 68dd7337, addresses #161)

    • Consistently close transports if create_server/create_connection/etc timeout or cancelled. (by @1st1 in ac90d8bd and 77ee4f96)

    Source code(tar.gz)
    Source code(zip)
  • v0.10.0(May 30, 2018)

    New Features

    • Initial support for Python 3.7. (by @pfreixes in c3a5ec8e for #138)

    • Implement PEP 567 support (contextvars module) for Python 3.7. (by @1st1 in 2a4fab44, 878e4163, and b2bdaae3 for #155)

    • Add uvloop's own version of asyncio/sslproto.py. SSL is now ~50% faster. (by @1st1 in 4d912643)

    • Convert Future-returning loop methods to coroutines to match asyncio 3.7. (by @1st1 in 7384b22f)

    • Allow file objects to be passed to loop.subprocess*() functions. (by @1st1 in f0830901 for #136)

    • Make signals processing more reliable. (by @1st1 in 6e03e513)

    • Prohibit adding a signal handler for SIGCHLD. (by @1st1 in cd53b7f5 for #156)

    • Add uvloop.__version__. (by @1st1 in 740cb7f3 for #137)

    Bug Fixes

    • Upgrade to Cython 0.28.2. (by @1st1 in 98bdb553 for #122)

    • Update libuv from v1.17.0 to v1.20.3. (by @1st1 in 572524a6)

    • Make sure UDP handles are cleaned-up properly. (by @1st1 in 13f63e00)

    • Fix subprocess.close() to let its processes die gracefully. (by @1st1 in a78e4d27 and a455af3d for #128)

    • Fix sock_connect() to resolve addresses for correct socket family. (by @1st1 in ce2bd4fb for #139)

    • Fix a race condition in SSL handshake. (by @1st1 in 447e124f)

    Source code(tar.gz)
    Source code(zip)
  • v0.9.1(Nov 29, 2017)

    • Stop using malloc for uv_request* handlers.

    • Fix loop.add_reader(), loop.add_writer(), loop.remove_reader(), and loop.remove_writer() to better track socket objects.

    • Fix loop.sock_recv(), loop.sock_sendall(), loop.sock_recv_into(), and loop.sock_connect() to correctly handle Task.cancel().

    • Better handle immediate cancellation of loop.create_connection().

    • Make unit tests stricter: ensure loop.call_exception_handler() does not get called, unless it's expected.

    Source code(tar.gz)
    Source code(zip)
  • v0.9.0(Nov 27, 2017)

    TCP & UDP Transports

    • transport.get_extra_info('socket') now returns a socket-like object. It supports socket methods like setsockopts(), but prohibits send(), recv(), close() and any other calls that can interfere with the transport that ultimately owns this file descriptor.

    • TCP_NODELAY is used by default for all TCP connections.

    • Make Transport.resume_reading() and pause_reading() idempotent. This will match asyncio in Python 3.7. Issue #93.

    • loop.create_server() keeps a strong reference to the Server object it returns until its closed. Fixes #81.

    • Fix loop.connect_accepted_socket() to return correct SSL transport.

    • The UDP transport layer was rewritten from scratch. Now it uses uv_poll_* libuv APIs, instead of high-level uv_udp_* ones. This could mean a slight performance regression, and will be reverted when we port uvloop to Windows. For now this is the only viable option to make uvloop fully compatible with asyncio. When libuv gets an API to connect UDP sockets, uv_udp_connect(), we'll be able to switch to a better UDP implementation. Issue #109.

    • UDPTransport.sendto(data, addr) will raise an exception if addr requires a name resolution. Issue #91.

    Low-level sockets

    • loop.add_reader() and loop.add_writer() accept file-like objects. Issue #97.

    • loop.sock_connect() supports 4 element address tuples for IPv6 sockets. Issue #99.

    • Protect sockets from closing while they are in use by loop.sock_*() methods. Close all reader/writer sockets the loop owns when it closes. Issue #100.

    Other event loop APIs

    • loop.run_until_complete() cleans up done callbacks in all situations. By @jimmylai. See also Python issue: https://bugs.python.org/issue30423.

    • New uv_loop_fork() libuv API is used in loop.subprocess_shell() and loop.subprocess_exec() making them more stable. Issue #39.

    • loop.call_later() accepts infinite time float('inf'). Issue #102.

    • loop.subprocess_exec() accepts pathlib.Path objects for its cwd parameter. Issue #90.

    • Support pathlib.Path objects in loop.create_unix_connection() and loop.create_unix_server().

    • Try removing existing stale Unix socket paths in loop.create_unix_server().

    • ascii encoding is tried before encoding with idna. Issue #95.

    • Fix slow_callback_duration repr in warnings for callback handles and Tasks. Issue #103.

    Python 3.7

    Some APIs that will be available in Python 3.7 in vanilla asyncio, but can be used with uvloop today.

    • Implement .cancelled() method for callback and timer handles.

    • Add Transport.is_reading().

    • Implement loop.sock_recv_into().

    • Python 3.7.0a1 is now supported. Issue #110.

    Miscellaneous

    • Drop custom uvloop Future and Task implementations. This means that there will be a tiny performance regression for Python 3.5 deploys.

    • Limit stack traces in debug mode to make it faster.

    • signal.siginterrupt is now used by signals machinery to let system calls to be repeated by default, instead of raising an EINTR.

    Build

    • libuv in uvloop has been upgraded from v1.11.0 to v1.17.0. Aside from bug fixes and performance improvements, libuv survives fork.

    • LIBUV_CONFIGURE_HOST environment variable can be used to cross-compile uvloop/libuv. By @cmcqueen, for issue #104.

    • Cyhton was upgraded from 0.25.2 to 0.27.3.

    • uvloop binary is linked with pthread. By @frederikaalund, for issue #87.

    Source code(tar.gz)
    Source code(zip)
Owner
magicstack
Any sufficiently advanced software is indistinguishable from magic.
magicstack
Ultra fast JSON decoder and encoder written in C with Python bindings

UltraJSON UltraJSON is an ultra fast JSON encoder and decoder written in pure C with bindings for Python 3.6+. Install with pip: $ python -m pip insta

null 3.7k Jun 20, 2022
Ultra fast JSON decoder and encoder written in C with Python bindings

UltraJSON UltraJSON is an ultra fast JSON encoder and decoder written in pure C with bindings for Python 3.6+. Install with pip: $ python -m pip insta

null 3.7k Jun 20, 2022
An ultra fast cross-platform multiple screenshots module in pure Python using ctypes.

Python MSS from mss import mss # The simplest use, save a screen shot of the 1st monitor with mss() as sct: sct.shot() An ultra fast cross-platfo

Mickaël Schoentgen 731 Jun 20, 2022
An ultra fast tiny model for lane detection, using onnx_parser, TensorRTAPI, torch2trt to accelerate. our model support for int8, dynamic input and profiling. (Nvidia-Alibaba-TensoRT-hackathon2021)

Ultra_Fast_Lane_Detection_TensorRT An ultra fast tiny model for lane detection, using onnx_parser, TensorRTAPI to accelerate. our model support for in

steven.yan 115 Jun 14, 2022
Example scripts for the detection of lanes using the ultra fast lane detection model in ONNX.

Example scripts for the detection of lanes using the ultra fast lane detection model in ONNX.

Ibai Gorordo 33 Apr 29, 2022
Example scripts for the detection of lanes using the ultra fast lane detection model in Tensorflow Lite.

TFlite Ultra Fast Lane Detection Inference Example scripts for the detection of lanes using the ultra fast lane detection model in Tensorflow Lite. So

Ibai Gorordo 10 May 18, 2022
Lane assist for ETS2, built with the ultra-fast-lane-detection model.

Euro-Truck-Simulator-2-Lane-Assist Lane assist for ETS2, built with the ultra-fast-lane-detection model. This project was made possible by the amazing

null 11 Jun 16, 2022
Generic Event Boundary Detection: A Benchmark for Event Segmentation

Generic Event Boundary Detection: A Benchmark for Event Segmentation We release our data annotation & baseline codes for detecting generic event bound

null 41 Jun 15, 2022
42-event-notifier - 42 Event notifier using 42API and Github Actions

42 Event Notifier 42서울 Agenda에 새로운 이벤트가 등록되면 알려드립니다! 현재는 Github Issue로 등록되므로 상단

null 6 May 16, 2022
Scikit-event-correlation - Event Correlation and Forecasting over High Dimensional Streaming Sensor Data algorithms

scikit-event-correlation Event Correlation and Changing Detection Algorithm Theo

Intellia ICT 3 Feb 4, 2022
Event-forecasting - Event Forecasting Algorithms With Python

event-forecasting Event Forecasting Algorithms Theory Correlating events in comp

Intellia ICT 4 Feb 15, 2022
Event sourced bank - A wide-and-shallow example using the Python event sourcing library

Event Sourced Bank A "wide but shallow" example of using the Python event sourci

null 3 Mar 9, 2022
A fast PostgreSQL Database Client Library for Python/asyncio.

asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio asyncpg is a database interface library designed specifically for PostgreSQL a

magicstack 5.5k Jun 25, 2022
Piccolo - A fast, user friendly ORM and query builder which supports asyncio.

A fast, user friendly ORM and query builder which supports asyncio.

null 778 Jun 24, 2022
BitPack is a practical tool to efficiently save ultra-low precision/mixed-precision quantized models.

BitPack is a practical tool that can efficiently save quantized neural network models with mixed bitwidth.

Zhen Dong 32 Apr 6, 2022
Ultra-Data-Efficient GAN Training: Drawing A Lottery Ticket First, Then Training It Toughly

Ultra-Data-Efficient GAN Training: Drawing A Lottery Ticket First, Then Training It Toughly Code for this paper Ultra-Data-Efficient GAN Tra

VITA 73 Jun 3, 2022
Awesome multilingual OCR toolkits based on PaddlePaddle (practical ultra lightweight OCR system, provide data annotation and synthesis tools, support training and deployment among server, mobile, embedded and IoT devices)

English | 简体中文 Introduction PaddleOCR aims to create multilingual, awesome, leading, and practical OCR tools that help users train better models and a

null 22.9k Jun 21, 2022
Towards Ultra-Resolution Neural Style Transfer via Thumbnail Instance Normalization

Towards Ultra-Resolution Neural Style Transfer via Thumbnail Instance Normalization Official PyTorch implementation for our URST (Ultra-Resolution Sty

czczup 122 May 19, 2022
Based on Yolo's low-power, ultra-lightweight universal target detection algorithm, the parameter is only 250k, and the speed of the smart phone mobile terminal can reach ~300fps+

Based on Yolo's low-power, ultra-lightweight universal target detection algorithm, the parameter is only 250k, and the speed of the smart phone mobile terminal can reach ~300fps+

null 462 Jun 21, 2022
A ultra-lightweight 3D renderer of the Tensorflow/Keras neural network architectures

A ultra-lightweight 3D renderer of the Tensorflow/Keras neural network architectures

Souvik Pratiher 16 Nov 17, 2021
Ultra-lightweight human body posture key point CNN model. ModelSize:2.3MB HUAWEI P40 NCNN benchmark: 6ms/img,

Ultralight-SimplePose Support NCNN mobile terminal deployment Based on MXNET(>=1.5.1) GLUON(>=0.7.0) framework Top-down strategy: The input image is t

null 195 Jun 17, 2022
pytest plugin for distributed testing and loop-on-failures testing modes.

xdist: pytest distributed testing plugin The pytest-xdist plugin extends pytest with some unique test execution modes: test run parallelization: if yo

pytest-dev 911 Jun 21, 2022
Code for "3D Human Pose and Shape Regression with Pyramidal Mesh Alignment Feedback Loop"

PyMAF This repository contains the code for the following paper: 3D Human Pose and Shape Regression with Pyramidal Mesh Alignment Feedback Loop Hongwe

Hongwen Zhang 295 Jun 15, 2022
Source code for the GPT-2 story generation models in the EMNLP 2020 paper "STORIUM: A Dataset and Evaluation Platform for Human-in-the-Loop Story Generation"

Storium GPT-2 Models This is the official repository for the GPT-2 models described in the EMNLP 2020 paper [STORIUM: A Dataset and Evaluation Platfor

Nader Akoury 25 Jun 22, 2022
To check my COVID-19 vaccine appointment, I wrote an infinite loop that sends me a Whatsapp message hourly using Twilio and Selenium. It works on my Raspberry Pi computer.

COVID-19_vaccine_appointment To check my COVID-19 vaccine appointment, I wrote an infinite loop that sends me a Whatsapp message hourly using Twilio a

Ayyuce Demirbas 25 Dec 25, 2021
A list of papers about point cloud based place recognition, also known as loop closure detection in SLAM (processing)

A list of papers about point cloud based place recognition, also known as loop closure detection in SLAM (processing)

Xin Kong 17 May 16, 2021
FluxTraining.jl gives you an endlessly extensible training loop for deep learning

A flexible neural net training library inspired by fast.ai

null 69 Jun 9, 2022
FLVIS: Feedback Loop Based Visual Initial SLAM

FLVIS Feedback Loop Based Visual Inertial SLAM 1-Video EuRoC DataSet MH_05 Handheld Test in Lab FlVIS on UAV Platform 2-Relevent Publication: Under Re

UAV Lab - HKPolyU 167 Jun 18, 2022
Codebase for the Summary Loop paper at ACL2020

Summary Loop This repository contains the code for ACL2020 paper: The Summary Loop: Learning to Write Abstractive Summaries Without Examples. Training

Canny Lab @ The University of California, Berkeley 41 Jun 8, 2022