Pyjo-Reactor-Twisted 0.2.0__py3-none-any.whl

Pyjo/Reactor/Twisted.py

@@ -0,0 +1,475 @@
+"""
+Pyjo.Reactor.Twisted - Low-level event reactor with Twisted support
+===================================================================
+::
+
+    from Pyjo.Reactor.Twisted import Twisted
+
+    # Watch if handle becomes readable or writable
+    reactor = Twisted()
+    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.Twisted
+
+    # Watch if handle becomes readable or writable
+    reactor = Pyjo.Reactor.Twisted.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()
+
+:mod:`Pyjo.Reactor.Twisted` is a low-level event reactor based on the reactor
+of `Twisted <https://twisted.org>`_, the one that the application installed
+before, or else the reactor of poll of Twisted, or of select where there is no
+poll or it does not work well, as on macOS. Its default on Linux, the reactor
+of epoll, is not installed, as epoll keeps its state in the kernel: a socket
+that is closed before it is removed leaves it, which Pyjoyment does, and the
+state is shared with the child of a fork, as a worker of
+:mod:`Pyjo.Server.Prefork`, so an application that installs it has neither.
+An application of Twisted that imports ``twisted.internet.reactor`` itself
+calls :func:`install` before, which installs the one of poll or select.
+``PYJO_REACTOR`` selects it for :mod:`Pyjo.IOLoop`::
+
+    PYJO_REACTOR=Pyjo.Reactor.Twisted
+
+The reactor of Twisted is unique in a process, so only one object of this
+class uses it at a time, and :meth:`~Pyjo_Reactor_Twisted.new` returns a
+:mod:`Pyjo.Reactor.Poll` object while it lives, as the constructor of the
+class does. It runs in the thread that
+made it, so the threads of :mod:`Pyjo.Server.Prethread` get
+:mod:`Pyjo.Reactor.Poll` objects. When the reactor of Twisted is running
+already, as under ``twistd`` or Scrapy, :meth:`~Pyjo_Reactor_Twisted.start`
+and :meth:`~Pyjo_Reactor_Twisted.one_tick` return right away, and the events
+are handled by the reactor of Twisted that runs.
+
+Events
+------
+
+:mod:`Pyjo.Reactor.Twisted` inherits all events from :mod:`Pyjo.Reactor.Poll`.
+
+See also
+--------
+
+:mod:`Pyjo.Reactor.Poll`, :mod:`Pyjoyment`, https://github.com/pyjoyment/Pyjoyment.
+
+Classes
+-------
+"""
+
+import Pyjo.Exception
+import Pyjo.Reactor
+import Pyjo.Reactor.Poll
+
+from Pyjo.Reactor import Handle, IOCallback, TimerCallback
+
+import importlib.metadata
+import os
+import select
+import sys
+import threading
+import weakref
+
+from collections.abc import Callable
+from typing import Any, Self, TypedDict
+
+from twisted.internet.interfaces import IReadDescriptor, IWriteDescriptor
+
+# zope.interface has no stubs, as Twisted uses it
+from zope.interface import implementer  # pyright: ignore[reportMissingTypeStubs]
+
+
+__version__ = importlib.metadata.version('Pyjo-Reactor-Twisted')
+"""The version of the distribution, of its metadata, which the workflow Automated version sets in pyproject.toml."""
+
+# The object that uses the reactor of Twisted, which is unique, as Mojo::Reactor::EV counts the objects of EV
+_active: 'weakref.ref[Pyjo_Reactor_Twisted] | None' = None
+
+
+class _Timer(TypedDict):
+    cb: TimerCallback | None
+    after: float
+    recurring: bool
+    call: Any
+    fire: Callable[[], None]
+
+
+class Pyjo_Reactor_Twisted(Pyjo.Reactor.Poll.object):
+    """
+    :mod:`Pyjo.Reactor.Twisted` inherits all methods from
+    :mod:`Pyjo.Reactor.Poll` and implements the following new ones.
+    """
+
+    _timers: dict[str, _Timer]  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    # We have to fall back to Pyjo.Reactor.Poll, since the reactor of Twisted is unique; in the constructor of the class,
+    # as new and the constructor make the same object, and Python does not call __init__ for an object of another class
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        if _active is not None and _active() is not None:
+            return Pyjo.Reactor.Poll.new(*args, **kwargs)
+        return super().__new__(cls)
+
+    @classmethod
+    def new(cls, *args: Any, **kwargs: Any) -> Any:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """::
+
+            reactor = Pyjo.Reactor.Twisted.new()
+
+        Construct a new :mod:`Pyjo.Reactor.Twisted` object, or a
+        :mod:`Pyjo.Reactor.Poll` object while another one uses the reactor of
+        Twisted.
+        """
+        return cls(*args, **kwargs)
+
+    def __init__(self) -> None:
+        global _active
+        super().__init__()
+        # The reactor that the application installed, or one of poll or select, which keep their state in the process
+        install()
+        from twisted.internet import reactor
+
+        self._twisted: Any = reactor
+        self._descriptors: dict[int, _Descriptor] = {}
+        self._ticks = 0
+        self._timers = {}  # pyright: ignore[reportIncompatibleVariableOverride]
+        _active = weakref.ref(self)
+        weakref.finalize(self, _release, reactor, self._descriptors, self._timers)
+
+    def again(self, id: str, after: float | None = None) -> None:
+        """::
+
+            reactor.again(id)
+            reactor.again(id, 0.5)
+
+        Restart timer and optionally change the invocation time. Note that this
+        method requires an active timer.
+        """
+        if (timer := self._timers.get(id)) is None:
+            Pyjo.Exception.object.throw('Timer not active')
+        if after is not None:
+            timer['after'] = after
+        if (call := timer['call']).active():
+            call.reset(timer['after'])
+        else:
+            timer['call'] = self._twisted.callLater(timer['after'], timer['fire'])
+
+    def io(self, handle: Handle, cb: IOCallback) -> Self:
+        """::
+
+            reactor = reactor.io(handle, cb)
+
+        Watch handle for I/O events, invoking the callback whenever handle
+        becomes readable or writable.
+        """
+        fd = _fileno(handle)
+        self._unwatch(fd)
+        self._io[fd] = {'cb': cb, 'mode': 0}
+        self._descriptors[fd] = _Descriptor(weakref.ref(self), fd)
+        return self.watch(handle, True, True)
+
+    def one_tick(self) -> None:
+        """::
+
+            reactor.one_tick()
+
+        Run reactor until an event occurs or no events are being watched
+        anymore, or return right away while the reactor of Twisted runs.
+        """
+        twisted = self._twisted
+        if twisted.running:
+            return
+
+        running = self._running
+        if not running:
+            self._running = 1
+
+        try:
+            ticks = self._ticks
+            while self._ticks == ticks and self._running:
+                # The cleanups that finalizers deferred, before the reactor waits
+                if Pyjo.Reactor._DEFERRED.get(threading.get_ident()):  # pyright: ignore[reportPrivateUsage]
+                    Pyjo.Reactor._drain()  # pyright: ignore[reportPrivateUsage]
+
+                # Stop automatically if there is nothing to watch
+                if not len(self._timers) and not len(self._io):
+                    return self.stop()
+
+                # I/O, at most until the next timer or for half a second, then the timers that are due, as the reactor of
+                # poll has them
+                timeout = twisted.timeout()
+                twisted.doIteration(0.5 if timeout is None else min(timeout, 0.5))
+                twisted.runUntilCurrent()
+        finally:
+            if not running:
+                self._running = running
+
+    def recurring(self, after: float, cb: TimerCallback) -> str:
+        """::
+
+            id = reactor.recurring(0.25, cb)
+
+        Create a new recurring timer, invoking the callback repeatedly after a
+        given amount of time in seconds.
+        """
+        return self._timer(True, after, cb)
+
+    def remove(self, remove: Handle | str) -> bool:
+        """::
+
+            boolean = reactor.remove(handle)
+            boolean = reactor.remove(id)
+
+        Remove handle or timer.
+        """
+        if isinstance(remove, str):
+            if (timer := self._timers.pop(remove, None)) is None:
+                return False
+            _cancel(timer['call'])
+            return True
+        fd = _fileno(remove)
+        if self._io.pop(fd, None) is None:
+            return False
+        self._unwatch(fd)
+        return True
+
+    def reset(self) -> None:
+        """::
+
+            reactor.reset()
+
+        Remove all handles and timers.
+        """
+        _release(self._twisted, self._descriptors, self._timers)
+        self._events = {}
+        self._io = {}
+        self._next_tick.clear()
+        self._next_timer = None
+        self._running = 0
+
+    def start(self) -> None:
+        """::
+
+            reactor.start()
+
+        Start watching for I/O and timer events, this will block until
+        :meth:`stop` is called or no events are being watched anymore, or
+        return right away while the reactor of Twisted runs.
+        """
+        if self._twisted.running:
+            return
+        super().start()
+
+    def timer(self, after: float, cb: TimerCallback) -> str:
+        """::
+
+            id = reactor.timer(0.5, cb)
+
+        Create a new timer, invoking the callback after a given amount of time
+        in seconds.
+        """
+        return self._timer(False, after, cb)
+
+    def watch(self, handle: Handle, read: bool, write: bool) -> Self:
+        """::
+
+            reactor = reactor.watch(handle, readable, writable)
+
+        Change I/O events to watch handle for with true and false values. Note
+        that this method requires an active I/O watcher.
+        """
+        fd = _fileno(handle)
+        if fd not in self._io or (descriptor := self._descriptors.get(fd)) is None:
+            Pyjo.Exception.object.throw('I/O watcher not active')
+        twisted = self._twisted
+        if read and not descriptor.reading:
+            twisted.addReader(descriptor)
+        elif not read and descriptor.reading:
+            twisted.removeReader(descriptor)
+        if write and not descriptor.writing:
+            twisted.addWriter(descriptor)
+        elif not write and descriptor.writing:
+            twisted.removeWriter(descriptor)
+        descriptor.reading, descriptor.writing = read, write
+        return self
+
+    def _fire(self, fd: int, writable: bool) -> None:
+        if (io := self._io.get(fd)) is None:
+            return
+        self._ticks += 1
+        self._try('I/O watcher', io['cb'], writable)
+
+    def _timer(self, recurring: bool, after: float, cb: TimerCallback) -> str:
+        id = self._id()
+        ref = weakref.ref(self)
+
+        # The call of Twisted refers to the reactor weakly, as the reactor of Twisted lives as long as the process, and a
+        # recurring timer takes the function from the timer, as a reference to itself would make a cycle, which keeps the
+        # callback until the garbage collector runs
+        def fire() -> None:
+            if (reactor := ref()) is None or (timer := reactor._timers.get(id)) is None:
+                return
+            if timer['recurring']:
+                timer['call'] = reactor._twisted.callLater(timer['after'], timer['fire'])
+            else:
+                del reactor._timers[id]
+            reactor._ticks += 1
+            reactor._try('Timer', cb)
+
+        self._timers[id] = {
+            'cb': cb,
+            'after': after,
+            'recurring': recurring,
+            'call': self._twisted.callLater(after, fire),
+            'fire': fire,
+        }
+        return id
+
+    def _unwatch(self, fd: int) -> None:
+        if (descriptor := self._descriptors.pop(fd, None)) is not None:
+            _unwatch(self._twisted, descriptor)
+
+    def _wake(self) -> None:
+        self._twisted.callFromThread(lambda: None)
+
+
+# A handle of the reactor of Twisted, which calls the I/O watcher of its file descriptor; the decorator of zope.interface
+# has no types
+@implementer(IReadDescriptor, IWriteDescriptor)  # pyright: ignore[reportUntypedClassDecorator]
+class _Descriptor:
+    def __init__(self, reactor: 'weakref.ref[Pyjo_Reactor_Twisted]', fd: int) -> None:
+        self.fd = fd
+        self.reactor = reactor
+        self.reading = self.writing = False
+
+    # The reactor of Twisted removes the handle at a hang-up or an error without data, as the refusal of a connection,
+    # where the reactor of poll calls the watcher, which finds the error of the socket, so the watcher is called as the
+    # handle was watched, readable and writable
+    def connectionLost(self, reason: Any) -> None:
+        reading, writing = self.reading, self.writing
+        self.reading = self.writing = False
+        if (reactor := self.reactor()) is None:
+            return
+        if reading:
+            reactor._fire(self.fd, False)  # pyright: ignore[reportPrivateUsage]
+        if writing and reactor._descriptors.get(self.fd) is self:  # pyright: ignore[reportPrivateUsage]
+            reactor._fire(self.fd, True)  # pyright: ignore[reportPrivateUsage]
+
+    def doRead(self) -> None:
+        if (reactor := self.reactor()) is not None:
+            reactor._fire(self.fd, False)  # pyright: ignore[reportPrivateUsage]
+
+    def doWrite(self) -> None:
+        if (reactor := self.reactor()) is not None:
+            reactor._fire(self.fd, True)  # pyright: ignore[reportPrivateUsage]
+
+    def fileno(self) -> int:
+        return self.fd
+
+    def logPrefix(self) -> str:
+        return 'Pyjo.Reactor.Twisted'
+
+
+# The child of a fork has the waker of the parent, the pipe that wakes the reactor of Twisted from other threads, whose
+# wake-ups the parent and the child would read from each other, so the child gets one of its own
+def _after_fork_in_child() -> None:
+    if _active is None or (reactor := _active()) is None:
+        return
+    twisted = reactor._twisted  # pyright: ignore[reportPrivateUsage]
+    if (waker := getattr(twisted, 'waker', None)) is None:
+        return
+    twisted._removeInternalReader(waker)
+    waker.connectionLost(None)
+    twisted.waker = None
+    twisted.installWaker()
+
+
+def _cancel(call: Any) -> None:
+    if call.active():
+        call.cancel()
+
+
+def _fileno(handle: Handle) -> int:
+    fd = handle if isinstance(handle, int) else handle.fileno()
+    if fd < 0:
+        Pyjo.Exception.object.throw('Handle is closed')
+    return fd
+
+
+# The reactor of poll, or of select where there is no poll or it does not work well, as on macOS, which Twisted itself
+# prefers to poll there, in the place of the default of Twisted, which is epoll on Linux
+def install() -> None:
+    """::
+
+        Pyjo.Reactor.Twisted.install()
+
+    Install the reactor of Twisted that :mod:`Pyjo.Reactor.Twisted` prefers,
+    of poll, or of select where there is no poll or it does not work well, as
+    on macOS, in the place of the default of Twisted, epoll on Linux. An
+    application of Twisted calls it before it imports
+    ``twisted.internet.reactor``, which installs the default. It does nothing
+    where a reactor of Twisted is installed already. ::
+
+        import Pyjo.Reactor.Twisted
+
+        Pyjo.Reactor.Twisted.install()
+
+        from twisted.internet import reactor
+    """
+    if 'twisted.internet.reactor' in sys.modules:
+        return
+    if sys.platform != 'darwin' and hasattr(select, 'poll'):
+        from twisted.internet import pollreactor
+
+        pollreactor.install()
+    else:
+        from twisted.internet import selectreactor
+
+        selectreactor.install()
+
+
+# The handles and the calls that an object leaves in the reactor of Twisted, at a reset and when it is freed
+def _release(twisted: Any, descriptors: dict[int, _Descriptor], timers: dict[str, _Timer]) -> None:
+    for descriptor in descriptors.values():
+        _unwatch(twisted, descriptor)
+    descriptors.clear()
+    for timer in timers.values():
+        _cancel(timer['call'])
+    timers.clear()
+
+
+def _unwatch(twisted: Any, descriptor: _Descriptor) -> None:
+    if descriptor.reading:
+        twisted.removeReader(descriptor)
+    if descriptor.writing:
+        twisted.removeWriter(descriptor)
+    descriptor.reading = descriptor.writing = False
+
+
+if hasattr(os, 'register_at_fork'):
+    os.register_at_fork(after_in_child=_after_fork_in_child)
+
+new = Pyjo_Reactor_Twisted.new
+object = Pyjo_Reactor_Twisted
+Twisted = Pyjo_Reactor_Twisted

pyjo_reactor_twisted-0.2.0.dist-info/METADATA

@@ -0,0 +1,227 @@
+Metadata-Version: 2.5
+Name: Pyjo-Reactor-Twisted
+Version: 0.2.0
+Summary: Low level event reactor with Twisted support for Pyjoyment.
+Project-URL: Homepage, https://github.com/pyjoyment/Pyjo-Reactor-Twisted
+Project-URL: Documentation, https://pyjoyment.readthedocs.io/projects/pyjo-reactor-twisted/en/stable/
+Author-email: Piotr Roszatycki <piotr.roszatycki@gmail.com>
+License-Expression: Artistic-2.0
+License-File: LICENSE
+Keywords: pyjoyment,reactor,twisted
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: Twisted
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Requires-Dist: pyjoyment>=0.2.0
+Requires-Dist: twisted>=26.10.0
+Description-Content-Type: text/markdown
+
+[![Home](https://img.shields.io/badge/%F0%9F%8F%A0-Pyjoyment-02a7a0)](https://github.com/pyjoyment/Pyjoyment)
+[![GitHub](https://img.shields.io/github/stars/pyjoyment/Pyjo-Reactor-Twisted?style=flat&label=GitHub%20%E2%AD%90&logo=github)](https://github.com/pyjoyment/Pyjo-Reactor-Twisted)
+[![Documentation](https://img.shields.io/badge/docs-Read_the_Docs-blue?logo=readthedocs&logoColor=white)](https://pyjoyment.readthedocs.io/projects/pyjo-reactor-twisted/en/stable/)
+[![License](https://img.shields.io/github/license/pyjoyment/Pyjo-Reactor-Twisted.svg)](https://github.com/pyjoyment/Pyjo-Reactor-Twisted/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/Pyjo-Reactor-Twisted?logo=pypi&logoColor=white)](https://pypi.org/project/Pyjo-Reactor-Twisted/)
+[![Tests](https://github.com/pyjoyment/Pyjo-Reactor-Twisted/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/pyjoyment/Pyjo-Reactor-Twisted/actions/workflows/tests.yaml)
+
+# Pyjo-Reactor-Twisted
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/pyjoyment/Pyjoyment/main/Pyjoyment/resources/public/pyjo/logo-white-4x.png">
+    <img src="https://raw.githubusercontent.com/pyjoyment/Pyjoyment/main/Pyjoyment/resources/public/pyjo/logo-black-4x.png" alt="Pyjoyment" width="322">
+  </picture>
+</p>
+
+Low level event reactor with [Twisted](https://twisted.org) support for
+[Pyjoyment](https://github.com/pyjoyment/Pyjoyment).
+
+`Pyjo.Reactor.Twisted` runs the I/O and the timers of `Pyjo.IOLoop` in the
+reactor of Twisted, so that a Pyjoyment application and the code of Twisted
+share one event loop.
+
+## Installation
+
+From [PyPI](https://pypi.org/project/Pyjo-Reactor-Twisted/), with
+[Pyjoyment](https://pypi.org/project/Pyjoyment/) and
+[Twisted](https://pypi.org/project/Twisted/), which it depends on:
+
+```sh
+pip install Pyjo-Reactor-Twisted
+```
+
+or, in a project managed with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv add Pyjo-Reactor-Twisted
+```
+
+The development version is installed from the Git repository:
+
+```sh
+pip install git+https://github.com/pyjoyment/Pyjo-Reactor-Twisted
+```
+
+## Usage
+
+Select the reactor with `PYJO_REACTOR` before `Pyjo.IOLoop` is loaded:
+
+```sh
+PYJO_REACTOR=Pyjo.Reactor.Twisted python myapp.py daemon
+```
+
+The reactor of Twisted is unique in a process, so only one `Pyjo.IOLoop` uses
+it at a time; the others get `Pyjo.Reactor.Poll`. When the reactor of Twisted
+is running already, as under `twistd` or Scrapy, `Pyjo.IOLoop.start()` returns
+right away and the events are handled by the reactor that runs.
+
+## Examples
+
+`examples/hello_world_twisted.py` runs `Pyjo.HelloWorld` on the server of
+Pyjoyment in the event loop that Twisted runs, with `reactor.run()`, in a
+`with` block, which closes the listen sockets of the server at its end:
+
+```python
+import os
+
+
+# The reactor of Pyjoyment on the reactor of Twisted, selected before Pyjo.IOLoop is loaded
+os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Twisted'
+
+import Pyjo.Reactor.Twisted  # noqa: E402
+
+
+# The reactor of Twisted of poll or select, before Twisted is imported, which would install its default, epoll on Linux
+Pyjo.Reactor.Twisted.install()
+
+import Pyjo.HelloWorld  # noqa: E402
+import Pyjo.Server.Daemon  # noqa: E402
+
+from twisted.internet import reactor  # noqa: E402
+
+
+# The server of Pyjoyment, 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.start()
+
+    # Twisted runs the event loop, with the server of Pyjoyment in it
+    reactor.run()
+```
+
+```console
+$ python examples/hello_world_twisted.py
+Web application available at http://127.0.0.1:3000
+```
+
+```console
+$ curl http://127.0.0.1:3000/
+Your Pyjo is working!
+```
+
+`examples/user_agent_twisted.py` is an application of Twisted, a server of
+`twisted.web`, whose timer requests it every second with the user agent of
+Pyjoyment, without blocking the reactor of Twisted. The user agent is in a
+`with` block, which closes its connections at its end, so the callback shows
+the error of a request that it interrupts:
+
+```python
+import os
+
+
+# The reactor of Pyjoyment on the reactor of Twisted, selected before Pyjo.IOLoop is loaded
+os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Twisted'
+
+import Pyjo.Reactor.Twisted  # noqa: E402
+
+
+# The reactor of Twisted of poll or select, before Twisted is imported, which would install its default, epoll on Linux
+Pyjo.Reactor.Twisted.install()
+
+import Pyjo.UserAgent  # noqa: E402
+
+from twisted.internet import reactor, task  # noqa: E402
+from twisted.web import resource, server  # noqa: E402
+
+
+# An application of Twisted
+class Hello(resource.Resource):
+    isLeaf = True
+
+    def render_GET(self, request):
+        return b'Hello from Twisted!'
+
+
+reactor.listenTCP(3000, server.Site(Hello()))
+
+# The user agent of Pyjoyment, which closes its connections at the end of the block
+with Pyjo.UserAgent.new() as ua:
+    # A request every second, which does not block the reactor of Twisted; a request that the end of the block
+    # interrupts gets an error
+    def fetch():
+        def done(ua, tx):
+            print(tx.error['message'] if tx.error else f'{tx.res.code} {tx.res.text}')
+
+        ua.get('http://127.0.0.1:3000/', done)
+
+    task.LoopingCall(fetch).start(1)
+    reactor.run()
+```
+
+```console
+$ python examples/user_agent_twisted.py
+200 Hello from Twisted!
+200 Hello from Twisted!
+200 Hello from Twisted!
+```
+
+`examples/loopback_twisted.py` is a server of Pyjoyment and its user agent on
+the reactor of Twisted, a blocking request, which runs the event loop until
+the response, and the class of the reactor, which Build checks with the wheel:
+
+```python
+import os
+
+
+# The reactor of Pyjoyment on the reactor of Twisted, selected before Pyjo.IOLoop is loaded
+os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Twisted'
+
+import Pyjo.HelloWorld  # noqa: E402
+import Pyjo.IOLoop  # noqa: E402
+import Pyjo.Server.Daemon  # noqa: E402
+import Pyjo.UserAgent  # 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 the reactor of Twisted until the response
+    tx = ua.get(f'http://127.0.0.1:{daemon.start().ports()[0]}/')
+    print(type(Pyjo.IOLoop.singleton.reactor).__name__)
+    print(tx.result.code, tx.result.text)
+```
+
+```console
+$ python examples/loopback_twisted.py
+Pyjo_Reactor_Twisted
+200 Your Pyjo is working!
+```
+
+The first two call `Pyjo.Reactor.Twisted.install()` before they import
+Twisted, which would install its default, epoll on Linux, in the place of poll
+or select; the third does not import Twisted, so the reactor installs it.
+
+## Documentation
+
+The API of the module and the examples are on
+[Read the Docs](https://pyjoyment.readthedocs.io/projects/pyjo-reactor-twisted/en/stable/).
+
+## Status
+
+An experiment: the first reactor of Pyjoyment in a distribution of its own.
+
+## License
+
+The Artistic License 2.0, as Pyjoyment.

pyjo_reactor_twisted-0.2.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+Pyjo/Reactor/Twisted.py,sha256=QxvO_T03TG-AxcBxCbYSVHkFKjzNsBh4ZMjtYBVZ3mM,16879
+pyjo_reactor_twisted-0.2.0.dist-info/METADATA,sha256=qnRETtC8Zolg3ovjr-acV9dIaAqBOnPUHgDmTpcd38w,8013
+pyjo_reactor_twisted-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pyjo_reactor_twisted-0.2.0.dist-info/licenses/LICENSE,sha256=wqf_RI5i8Of0e_6xwFe7wBhw72jXAkF_9N8Ny9ScaP4,8894
+pyjo_reactor_twisted-0.2.0.dist-info/RECORD,,

pyjo_reactor_twisted-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyjo_reactor_twisted-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+		       The Artistic License 2.0
+
+	    Copyright (c) 2000-2006, The Perl Foundation.
+
+     Everyone is permitted to copy and distribute verbatim copies
+      of this license document, but changing it is not allowed.
+
+Preamble
+
+This license establishes the terms under which a given free software
+Package may be copied, modified, distributed, and/or redistributed.
+The intent is that the Copyright Holder maintains some artistic
+control over the development of that Package while still keeping the
+Package available as open source and free software.
+
+You are always permitted to make arrangements wholly outside of this
+license directly with the Copyright Holder of a given Package.  If the
+terms of this license do not permit the full use that you propose to
+make of the Package, you should contact the Copyright Holder and seek
+a different licensing arrangement.
+
+Definitions
+
+    "Copyright Holder" means the individual(s) or organization(s)
+    named in the copyright notice for the entire Package.
+
+    "Contributor" means any party that has contributed code or other
+    material to the Package, in accordance with the Copyright Holder's
+    procedures.
+
+    "You" and "your" means any person who would like to copy,
+    distribute, or modify the Package.
+
+    "Package" means the collection of files distributed by the
+    Copyright Holder, and derivatives of that collection and/or of
+    those files. A given Package may consist of either the Standard
+    Version, or a Modified Version.
+
+    "Distribute" means providing a copy of the Package or making it
+    accessible to anyone else, or in the case of a company or
+    organization, to others outside of your company or organization.
+
+    "Distributor Fee" means any fee that you charge for Distributing
+    this Package or providing support for this Package to another
+    party.  It does not mean licensing fees.
+
+    "Standard Version" refers to the Package if it has not been
+    modified, or has been modified only in ways explicitly requested
+    by the Copyright Holder.
+
+    "Modified Version" means the Package, if it has been changed, and
+    such changes were not explicitly requested by the Copyright
+    Holder.
+
+    "Original License" means this Artistic License as Distributed with
+    the Standard Version of the Package, in its current version or as
+    it may be modified by The Perl Foundation in the future.
+
+    "Source" form means the source code, documentation source, and
+    configuration files for the Package.
+
+    "Compiled" form means the compiled bytecode, object code, binary,
+    or any other form resulting from mechanical transformation or
+    translation of the Source form.
+
+
+Permission for Use and Modification Without Distribution
+
+(1)  You are permitted to use the Standard Version and create and use
+Modified Versions for any purpose without restriction, provided that
+you do not Distribute the Modified Version.
+
+
+Permissions for Redistribution of the Standard Version
+
+(2)  You may Distribute verbatim copies of the Source form of the
+Standard Version of this Package in any medium without restriction,
+either gratis or for a Distributor Fee, provided that you duplicate
+all of the original copyright notices and associated disclaimers.  At
+your discretion, such verbatim copies may or may not include a
+Compiled form of the Package.
+
+(3)  You may apply any bug fixes, portability changes, and other
+modifications made available from the Copyright Holder.  The resulting
+Package will still be considered the Standard Version, and as such
+will be subject to the Original License.
+
+
+Distribution of Modified Versions of the Package as Source
+
+(4)  You may Distribute your Modified Version as Source (either gratis
+or for a Distributor Fee, and with or without a Compiled form of the
+Modified Version) provided that you clearly document how it differs
+from the Standard Version, including, but not limited to, documenting
+any non-standard features, executables, or modules, and provided that
+you do at least ONE of the following:
+
+    (a)  make the Modified Version available to the Copyright Holder
+    of the Standard Version, under the Original License, so that the
+    Copyright Holder may include your modifications in the Standard
+    Version.
+
+    (b)  ensure that installation of your Modified Version does not
+    prevent the user installing or running the Standard Version. In
+    addition, the Modified Version must bear a name that is different
+    from the name of the Standard Version.
+
+    (c)  allow anyone who receives a copy of the Modified Version to
+    make the Source form of the Modified Version available to others
+    under
+
+	(i)  the Original License or
+
+	(ii)  a license that permits the licensee to freely copy,
+	modify and redistribute the Modified Version using the same
+	licensing terms that apply to the copy that the licensee
+	received, and requires that the Source form of the Modified
+	Version, and of any works derived from it, be made freely
+	available in that license fees are prohibited but Distributor
+	Fees are allowed.
+
+
+Distribution of Compiled Forms of the Standard Version
+or Modified Versions without the Source
+
+(5)  You may Distribute Compiled forms of the Standard Version without
+the Source, provided that you include complete instructions on how to
+get the Source of the Standard Version.  Such instructions must be
+valid at the time of your distribution.  If these instructions, at any
+time while you are carrying out such distribution, become invalid, you
+must provide new instructions on demand or cease further distribution.
+If you provide valid instructions or cease distribution within thirty
+days after you become aware that the instructions are invalid, then
+you do not forfeit any of your rights under this license.
+
+(6)  You may Distribute a Modified Version in Compiled form without
+the Source, provided that you comply with Section 4 with respect to
+the Source of the Modified Version.
+
+
+Aggregating or Linking the Package
+
+(7)  You may aggregate the Package (either the Standard Version or
+Modified Version) with other packages and Distribute the resulting
+aggregation provided that you do not charge a licensing fee for the
+Package.  Distributor Fees are permitted, and licensing fees for other
+components in the aggregation are permitted. The terms of this license
+apply to the use and Distribution of the Standard or Modified Versions
+as included in the aggregation.
+
+(8) You are permitted to link Modified and Standard Versions with
+other works, to embed the Package in a larger work of your own, or to
+build stand-alone binary or bytecode versions of applications that
+include the Package, and Distribute the result without restriction,
+provided the result does not expose a direct interface to the Package.
+
+
+Items That are Not Considered Part of a Modified Version
+
+(9) Works (including, but not limited to, modules and scripts) that
+merely extend or make use of the Package, do not, by themselves, cause
+the Package to be a Modified Version.  In addition, such works are not
+considered parts of the Package itself, and are not subject to the
+terms of this license.
+
+
+General Provisions
+
+(10)  Any use, modification, and distribution of the Standard or
+Modified Versions is governed by this Artistic License. By using,
+modifying or distributing the Package, you accept this license. Do not
+use, modify, or distribute the Package, if you do not accept this
+license.
+
+(11)  If your Modified Version has been derived from a Modified
+Version made by someone other than you, you are nevertheless required
+to ensure that your Modified Version complies with the requirements of
+this license.
+
+(12)  This license does not grant you the right to use any trademark,
+service mark, tradename, or logo of the Copyright Holder.
+
+(13)  This license includes the non-exclusive, worldwide,
+free-of-charge patent license to make, have made, use, offer to sell,
+sell, import and otherwise transfer the Package with respect to any
+patent claims licensable by the Copyright Holder that are necessarily
+infringed by the Package. If you institute patent litigation
+(including a cross-claim or counterclaim) against any party alleging
+that the Package constitutes direct or contributory patent
+infringement, then this Artistic License to you shall terminate on the
+date that such litigation is filed.
+
+(14)  Disclaimer of Warranty:
+THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
+NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL
+LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.