Pyjo.Reactor.Uvloop - Low-level event reactor on uvloop

from Pyjo.Reactor.Uvloop import Uvloop

# Watch if handle becomes readable or writable
reactor = Uvloop()
reactor.io(first, lambda reactor, writable: print(
    'First handle is writable' if writable else 'First handle is readable'
))

# Or import the module, as in Google Python Style Guide

import Pyjo.Reactor.Uvloop

# Watch if handle becomes readable or writable
reactor = Pyjo.Reactor.Uvloop.new()
reactor.io(first, lambda reactor, writable: print(
    'First handle is writable' if writable else 'First handle is readable'
))

# Change to watching only if handle becomes writable
reactor.watch(first, False, True)

# Watch a file descriptor if it becomes readable
reactor.io(fd, lambda reactor, writable: print(
    'Second handle is writable' if writable else 'Second handle is readable'
)).watch(fd, True, False)

# Add a timer
def timeout(reactor):
    reactor.remove(first)
    reactor.remove(fd)
    print('Timeout!')

reactor.timer(15, timeout)

# Start reactor if necessary
if not reactor.is_running:
    reactor.start()

Pyjo.Reactor.Uvloop is a low-level event reactor based on uvloop, the implementation of the event loop of asyncio on libuv. It is Pyjo.Reactor.Asyncio with an event loop of its own of uvloop, in the place of the one of asyncio, so that the servers of Pyjoyment, as Pyjo.Server.Daemon, Pyjo.Server.Prefork and Pyjo.Server.Prethread, and the blocking requests of its user agent run on uvloop. PYJO_REACTOR selects it for Pyjo.IOLoop:

PYJO_REACTOR=Pyjo.Reactor.Uvloop python myapp.py daemon

The loop of uvloop is a loop of asyncio, so coroutines, tasks and the libraries of asyncio run along with the reactor, as with Pyjo.Reactor.Asyncio. A reactor uses the event loop it is given, or else the loop that is running, as inside asyncio.run(), of asyncio or of uvloop, and only a loop of its own is one of uvloop. An ASGI server on uvloop, as uvicorn and Hypercorn, runs the loop itself, which Pyjo.Reactor.Asyncio takes already, so it needs no reactor of uvloop. In the child of a fork, as a worker of Pyjo.Server.Prefork, the reactor moves to a new loop of its own of uvloop. The wakeup fd of the signals that a program sets with signal.set_wakeup_fd(), as the workers of Pyjo.Server.Prefork do, is written to on a signal while a loop of its own runs, as with the loop of asyncio, although uvloop sets one of its own. A timer of a loop of its own, as asyncio.sleep(), is never due before its time, as with the loop of asyncio, although libuv counts it in whole milliseconds, so it may be up to two milliseconds late.

uvloop runs on Linux and macOS, not on Windows, and on CPython, not on PyPy. The PYJO_ASYNCIO_SLOW_CALLBACK environment variable sets the slow_callback_duration of a loop of its own in seconds, as for Pyjo.Reactor.Asyncio.

Events

Pyjo.Reactor.Uvloop inherits all events from Pyjo.Reactor.Asyncio.

See also

Pyjo.Reactor.Asyncio, Pyjoyment, https://github.com/pyjoyment/Pyjoyment.

Classes

class Pyjo.Reactor.Uvloop.Pyjo_Reactor_Uvloop(loop: AbstractEventLoop | None = None)[source]

Pyjo.Reactor.Uvloop inherits all methods from Pyjo.Reactor.Asyncio.

Examples

examples/hello_world_uvloop.py runs Pyjo.HelloWorld on the server of Pyjoyment on uvloop until the signal INT or TERM, in a with block, which closes the listen sockets of the server at its end:

import os


# The reactor of Pyjoyment on uvloop, selected before Pyjo.IOLoop is loaded
os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Uvloop'

import Pyjo.HelloWorld  # noqa: E402
import Pyjo.Server.Daemon  # noqa: E402


# The server of Pyjoyment on uvloop, until the signal INT or TERM, which closes its listen sockets at the end of the block
with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://*:3000']) as daemon:
    daemon.run()
$ python examples/hello_world_uvloop.py
Web application available at http://127.0.0.1:3000
$ curl http://127.0.0.1:3000/
Your Pyjo is working!

examples/asyncio_uvloop.py is a coroutine on the loop of uvloop, which requests the server of Pyjoyment in the same loop with the streams of asyncio and with the user agent of Pyjoyment, as the libraries of asyncio run along with the reactor:

import os


# The reactor of Pyjoyment on uvloop, selected before Pyjo.IOLoop is loaded
os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Uvloop'

import Pyjo.HelloWorld  # noqa: E402
import Pyjo.IOLoop  # noqa: E402
import Pyjo.Server.Daemon  # noqa: E402
import Pyjo.UserAgent  # noqa: E402

import asyncio  # noqa: E402

import uvloop  # noqa: E402


# A coroutine on the loop of uvloop, with the streams of asyncio and the user agent of Pyjoyment, both requesting the
# server of Pyjoyment in the same loop
async def main(port):
    reader, writer = await asyncio.open_connection('127.0.0.1', port)
    writer.write(b'GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n')
    print(f'asyncio: {(await reader.readline()).decode().strip()}')
    writer.close()
    await writer.wait_closed()

    with Pyjo.UserAgent.new() as ua:
        tx = await ua.get_p(f'http://127.0.0.1:{port}/')
        print(f'Pyjo.UserAgent: {tx.res.code} {tx.res.text}')

    return 'uvloop' if isinstance(asyncio.get_running_loop(), uvloop.Loop) else 'asyncio'


# The server, on a port that the system picks, which closes its listen sockets at the end of the block
with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://127.0.0.1'], silent=True) as daemon:
    port = daemon.start().ports()[0]
    Pyjo.IOLoop.singleton.reactor.run_coroutine(
        main(port),
        lambda loop: (print(f'loop: {loop}'), Pyjo.IOLoop.stop()),
        lambda err: (print(f'error: {err}'), Pyjo.IOLoop.stop()),
    )
    Pyjo.IOLoop.start()
$ python examples/asyncio_uvloop.py
asyncio: HTTP/1.1 200 OK
Pyjo.UserAgent: 200 Your Pyjo is working!
loop: uvloop

examples/loopback_uvloop.py is a server of Pyjoyment and its user agent on the loop of uvloop, a blocking request, which runs the event loop until the response, and the class of the reactor and whether its loop is one of uvloop:

import os


# The reactor of Pyjoyment on uvloop, selected before Pyjo.IOLoop is loaded
os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Uvloop'

import Pyjo.HelloWorld  # noqa: E402
import Pyjo.IOLoop  # noqa: E402
import Pyjo.Server.Daemon  # noqa: E402
import Pyjo.UserAgent  # noqa: E402

import uvloop  # noqa: E402


# The server, on a port that the system picks, and the user agent, in the same event loop, which close their sockets at
# the end of the block
with (
    Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://127.0.0.1'], silent=True) as daemon,
    Pyjo.UserAgent.new(ioloop=Pyjo.IOLoop.singleton) as ua,
):
    # A blocking request, which runs the event loop of the server on uvloop until the response
    tx = ua.get(f'http://127.0.0.1:{daemon.start().ports()[0]}/')
    reactor = Pyjo.IOLoop.singleton.reactor
    print(type(reactor).__name__, 'uvloop' if isinstance(reactor.loop, uvloop.Loop) else 'asyncio')
    print(tx.result.code, tx.result.text)
$ python examples/loopback_uvloop.py
Pyjo_Reactor_Uvloop uvloop
200 Your Pyjo is working!