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.Uvloopinherits all methods fromPyjo.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!