Pyjo-Reactor-Gevent 0.1.0__py3-none-any.whl

Pyjo/Reactor/Gevent.py

@@ -0,0 +1,565 @@
+"""
+Pyjo.Reactor.Gevent - Low-level event reactor on gevent
+=======================================================
+::
+
+    from Pyjo.Reactor.Gevent import Gevent
+
+    # Watch if handle becomes readable or writable
+    reactor = Gevent()
+    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.Gevent
+
+    # Watch if handle becomes readable or writable
+    reactor = Pyjo.Reactor.Gevent.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.Gevent` is a low-level event reactor based on the hub of
+`gevent <https://www.gevent.org>`_, whose loop of libev or libuv watches the
+handles and runs the timers, so that the servers of Pyjoyment, as
+:mod:`Pyjo.Server.Daemon`, :mod:`Pyjo.Server.Prefork` and
+:mod:`Pyjo.Server.Prethread`, and its user agent run along with the greenlets
+of a program of gevent. ``PYJO_REACTOR`` selects it for :mod:`Pyjo.IOLoop`::
+
+    PYJO_REACTOR=Pyjo.Reactor.Gevent python myapp.py daemon
+
+The reactor runs in the greenlet that calls :meth:`~Pyjo_Reactor_Gevent.start`
+or :meth:`~Pyjo_Reactor_Gevent.one_tick`, the main one or any other, which
+waits for the events in the hub, where the other greenlets of the program run
+in the meantime, and the callbacks of the reactor run in that greenlet. A
+callback can wait for a greenlet or for a function of gevent, as
+``gevent.sleep``, which stops the events of the reactor until it returns, but
+not the other greenlets. A blocking request of :mod:`Pyjo.UserAgent`, which
+runs an event loop of its own, waits in the greenlet that makes it, while the
+other greenlets, a server of Pyjoyment among them, run. The reactor cannot run
+in the hub itself, as in a callback of the loop of gevent, where gevent raises
+``BlockingSwitchOutError``.
+
+A reactor uses the hub of the thread that makes it, so the threads of
+:mod:`Pyjo.Server.Prethread` have hubs of their own, and any number of reactors
+share the hub of a thread. The child of a fork, as a worker of
+:mod:`Pyjo.Server.Prefork`, reinitializes the hub, as ``gevent.os.fork`` does.
+
+The environment variable ``GEVENT_LOOP`` of gevent selects the loop, libev
+(``libev-cext``, the default) or libuv (``libuv-cffi``), for which
+`cffi <https://pypi.org/project/cffi/>`_ is installed too::
+
+    pip install Pyjo-Reactor-Gevent cffi
+    GEVENT_LOOP=libuv-cffi PYJO_REACTOR=Pyjo.Reactor.Gevent python myapp.py daemon
+
+A program that calls ``gevent.monkey.patch_all()`` runs the reactor as well,
+but its threads are greenlets then, and so is the thread of
+:attr:`Pyjo.IOLoop.Pyjo_IOLoop.singleton`, which each greenlet has of its own,
+and :mod:`Pyjo.Server.Prethread` and :mod:`Pyjo.IOLoop.ChildProcess` do not
+work with the threads and the subprocesses of gevent.
+
+Events
+------
+
+:mod:`Pyjo.Reactor.Gevent` 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 threading
+import weakref
+
+from collections.abc import Callable
+from typing import Any, Self, TypedDict
+
+import gevent
+import gevent.hub
+import gevent.monkey
+
+from greenlet import getcurrent
+
+
+__version__ = importlib.metadata.version('Pyjo-Reactor-Gevent')
+"""The version of the distribution, of its metadata, which the workflow Automated version sets in pyproject.toml."""
+
+# The events of a watcher of I/O, the same in libev and libuv
+_READ = 1
+_WRITE = 2
+
+# The thread, not the greenlet that threading takes for it with gevent.monkey
+_get_ident: Callable[[], int] = gevent.monkey.get_original('_thread', 'get_ident')
+
+
+class _Timer(TypedDict):
+    cb: TimerCallback | None
+    after: float
+    recurring: bool
+    watcher: Any
+    seq: int
+
+
+class Pyjo_Reactor_Gevent(Pyjo.Reactor.Poll.object):
+    """
+    :mod:`Pyjo.Reactor.Gevent` inherits all methods from
+    :mod:`Pyjo.Reactor.Poll` and implements the following new ones.
+    """
+
+    # Not in Mojolicious: gevent, whose hub runs the watchers and the timers of the reactor, and whose code a finalizer of
+    # the garbage collector may interrupt
+    event_loop_modules = ('gevent',)
+
+    _timers: dict[str, _Timer]  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    hub: Any
+    """::
+
+        hub = reactor.hub
+
+    The hub of gevent of the thread that made the reactor, whose loop watches
+    the handles and runs the timers.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        # gevent has no types for the hub and its loop
+        self.hub = gevent.get_hub()
+        loop = self._loop = self.hub.loop
+        self._libuv: bool = type(loop).__module__.startswith('gevent.libuv')
+        self._ref: weakref.ref[Pyjo_Reactor_Gevent] = weakref.ref(self)
+        ref = self._ref
+
+        # The watchers of the handles, which the loop calls in the hub, where the events wait for the greenlet that runs
+        # the reactor, and the order of the handles
+        self._watchers: dict[int, Any] = {}
+        self._ready: dict[int, int] = {}
+        self._suspended: set[int] = set()
+        self._order: dict[int, int] = {}
+
+        # The timers that are due, which wait for that greenlet too, and the order of the timers
+        self._fired: set[str] = set()
+        self._seq = 0
+        self._timers = {}  # pyright: ignore[reportIncompatibleVariableOverride]
+
+        # The greenlets that wait for the events, and whether they are woken up already
+        self._waiting: list[Any] = []
+        self._woken = False
+
+        # The watchers of the loop are not referenced, so that the reactor does not keep a program of gevent alive when
+        # it does not run; one of these timers is, while a greenlet waits, so that the hub does not end, and wakes it up
+        # as the reactor of poll wakes up at least every half a second, or after one iteration of the loop, which polls
+        # the handles without waiting, when an event is ready already
+        self._keepalive: Any = loop.timer(0.5, 0.5)
+        self._poll: Any = loop.timer(0, 0)
+        self._keepalive_cb = lambda: _notify(ref)
+        weakref.finalize(self, _release, self.hub, self._watchers, self._timers, (self._keepalive, self._poll))
+
+    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 and after != timer['after']:
+            timer['after'] = after
+            if (watcher := timer['watcher']) is not None:
+                timer['watcher'] = None
+                watcher.stop()
+                watcher.close()
+        self._arm(id, timer)
+
+    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)
+        if fd not in self._io:
+            self._seq += 1
+            self._order[fd] = self._seq
+        self._io[fd] = {'cb': cb, 'mode': 0}
+        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, while the other greenlets run.
+        """
+        running = self._running
+        if not running:
+            self._running = 1
+
+        try:
+            i = 0
+            while not i 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()
+
+                self._wait(0 if self._ready or self._fired else 0.5)
+                i = self._dispatch()
+        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
+            self._fired.discard(remove)
+            if (watcher := timer['watcher']) is not None:
+                watcher.stop()
+                watcher.close()
+            return True
+        fd = _fileno(remove)
+        if self._io.pop(fd, None) is None:
+            return False
+        del self._order[fd]
+        self._unwatch(fd)
+        return True
+
+    def reset(self) -> None:
+        """::
+
+            reactor.reset()
+
+        Remove all handles and timers.
+        """
+        _stop(self._watchers, self._timers, ())
+        self._ready.clear()
+        self._suspended.clear()
+        self._order.clear()
+        self._fired.clear()
+        self._events = {}
+        self._io = {}
+        self._next_tick.clear()
+        self._next_timer = None
+        self._running = 0
+
+    def stop(self) -> None:
+        """::
+
+            reactor.stop()
+
+        Stop watching for I/O and timer events, also from another greenlet
+        than the one that runs the reactor.
+        """
+        self._running = 0
+        self._notify()
+
+    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 (io := self._io.get(fd)) is None:
+            Pyjo.Exception.object.throw('I/O watcher not active')
+        mode = (_READ if read else 0) | (_WRITE if write else 0)
+        if mode == io['mode'] and fd not in self._suspended:
+            return self
+        io['mode'] = mode
+        self._suspended.discard(fd)
+        if (watcher := self._watchers.get(fd)) is not None:
+            watcher.stop()
+        if not mode:
+            return self
+        if watcher is None:
+            # libuv sets a handle to the non-blocking mode when it makes the watcher, and never back, where a terminal,
+            # which Pyjo.IOLoop.Stdio reads and writes in the blocking mode, shares the mode with the shell
+            blocking = self._libuv and os.get_blocking(fd)
+            watcher = self._watchers[fd] = self._loop.io(fd, mode, ref=False)
+            if blocking:
+                os.set_blocking(fd, True)
+        else:
+            watcher.events = mode
+        watcher.start(_io_ready, self._ref, fd, pass_events=True)
+        return self
+
+    # A timer of no time is due at once, without a timer of the loop, as the reactor of poll runs the ones that a callback
+    # of I/O adds after the I/O of the same tick, where the loop would run them after the I/O of the next one
+    def _arm(self, id: str, timer: _Timer) -> None:
+        if timer['after'] <= 0:
+            if (watcher := timer['watcher']) is not None:
+                watcher.stop()
+            self._fired.add(id)
+            self._notify()
+            return
+        self._fired.discard(id)
+        # The time of the loop is updated, as libev and libuv take the time of the start of the iteration, which the
+        # callbacks of the reactor may have taken long after
+        if (watcher := timer['watcher']) is None:
+            # The interval repeats the timer for again, which stops a timer without one; the callback stops a timer
+            # that is not recurring
+            watcher = timer['watcher'] = self._loop.timer(timer['after'], timer['after'], ref=False)
+            watcher.start(_timer_ready, self._ref, id, update=True)
+        else:
+            watcher.again(_timer_ready, self._ref, id, update=True)
+
+    # The events that are ready, the handles in the order in which they were added, as the reactor of poll has them,
+    # where libev calls the watchers in the reverse order of its backend, then the timers in the order in which they were
+    # made
+    def _dispatch(self) -> int:
+        i = 0
+        if self._ready:
+            ready, self._ready = self._ready, {}
+            order = self._order
+            for fd in sorted(ready, key=lambda fd: order.get(fd, 0)) if len(ready) > 1 else ready:
+                revents = ready[fd]
+                if revents & _READ and (io := self._io.get(fd)) is not None and io['mode'] & _READ:
+                    i += 1
+                    self._try('I/O watcher', io['cb'], False)
+                if revents & _WRITE and (io := self._io.get(fd)) is not None and io['mode'] & _WRITE:
+                    i += 1
+                    self._try('I/O watcher', io['cb'], True)
+
+        if self._fired:
+            fired, self._fired = self._fired, set()
+            timers = self._timers
+            for id in sorted(fired, key=lambda id: timers[id]['seq'] if id in timers else 0):
+                if (t := timers.get(id)) is None:
+                    continue
+
+                # Recurring timer of no time, which is due again at the next tick
+                if t['recurring']:
+                    if not t['after']:
+                        self._fired.add(id)
+
+                # Normal timer
+                else:
+                    self.remove(id)
+
+                if (cb := t['cb']) is not None:
+                    i += 1
+                    self._try('Timer', cb)
+        return i
+
+    # In the hub, from the loop
+    def _io_ready(self, fd: int, revents: int) -> None:
+        # An error of the handle, which libuv reports with a status, after which it watches the handle no more, while
+        # gevent takes it for watched still: readable and writable, as for poll, and watched again at the next wait, so
+        # that the callback is called for as long as the error lasts
+        error = revents < 0
+        if error:
+            revents = _READ | _WRITE
+        self._ready[fd] = self._ready.get(fd, 0) | revents
+
+        # Nobody waits for the reactor: the handle is not watched until somebody does, as the loop would report it on
+        # every iteration, which the other greenlets make
+        if (error or not self._waiting) and (watcher := self._watchers.get(fd)) is not None:
+            watcher.stop()
+            self._suspended.add(fd)
+        self._notify()
+
+    # The greenlets that wait are woken up after the events of the iteration of the loop, before it waits again, by a
+    # callback of the loop, which gevent runs then
+    def _notify(self) -> None:
+        if self._waiting and not self._woken:
+            self._woken = True
+            self._loop.run_callback(_resume, self._ref)
+
+    # In the hub, from the loop; only the greenlets that still wait, as a greenlet that woke up first may have killed
+    # another one, which waits for something else then
+    def _resume(self) -> None:
+        self._woken = False
+        for greenlet in list(self._waiting):
+            if greenlet in self._waiting:
+                greenlet.switch()
+
+    def _timer(self, recurring: bool, after: float, cb: TimerCallback) -> str:
+        id = self._id()
+        self._seq += 1
+        timer: _Timer = {'cb': cb, 'after': after, 'recurring': recurring, 'watcher': None, 'seq': self._seq}
+        self._timers[id] = timer
+        self._arm(id, timer)
+        return id
+
+    # In the hub, from the loop
+    def _timer_ready(self, id: str) -> None:
+        if (timer := self._timers.get(id)) is None:
+            return
+        if not timer['recurring'] and (watcher := timer['watcher']) is not None:
+            watcher.stop()
+        self._fired.add(id)
+        self._notify()
+
+    def _unwatch(self, fd: int) -> None:
+        self._ready.pop(fd, None)
+        self._suspended.discard(fd)
+        if (watcher := self._watchers.pop(fd, None)) is not None:
+            watcher.stop()
+            watcher.close()
+
+    # The greenlet waits in the hub, where the other greenlets run, until the loop has an event of the reactor, or the
+    # reactor stops; gevent raises BlockingSwitchOutError in the hub itself
+    def _wait(self, timeout: float) -> None:
+        current = getcurrent()
+        for fd in self._suspended:
+            if (watcher := self._watchers.get(fd)) is not None:
+                watcher.start(_io_ready, self._ref, fd, pass_events=True)
+        self._suspended.clear()
+
+        waiting = self._waiting
+        waiting.append(current)
+        if len(waiting) == 1:
+            self._keepalive.start(self._keepalive_cb, update=True)
+        if timeout <= 0 and not self._poll.active:
+            self._poll.start(self._keepalive_cb, update=True)
+        try:
+            self.hub.switch()
+        finally:
+            waiting.remove(current)
+            if not waiting:
+                self._keepalive.stop()
+                self._poll.stop()
+
+    # The cleanups that finalizers deferred, from any thread
+    def _wake(self) -> None:
+        self._loop.run_callback_threadsafe(_notify, self._ref)
+
+
+# The callbacks of the loop refer to the reactor weakly, as the loop of the hub lives as long as the thread
+def _io_ready(revents: int, ref: 'weakref.ref[Pyjo_Reactor_Gevent]', fd: int) -> None:
+    if (reactor := ref()) is not None:
+        reactor._io_ready(fd, revents)  # pyright: ignore[reportPrivateUsage]
+
+
+def _timer_ready(ref: 'weakref.ref[Pyjo_Reactor_Gevent]', id: str) -> None:
+    if (reactor := ref()) is not None:
+        reactor._timer_ready(id)  # pyright: ignore[reportPrivateUsage]
+
+
+def _notify(ref: 'weakref.ref[Pyjo_Reactor_Gevent]') -> None:
+    if (reactor := ref()) is not None:
+        reactor._notify()  # pyright: ignore[reportPrivateUsage]
+
+
+def _resume(ref: 'weakref.ref[Pyjo_Reactor_Gevent]') -> None:
+    if (reactor := ref()) is not None:
+        reactor._resume()  # pyright: ignore[reportPrivateUsage]
+
+
+# The child of a fork reinitializes the hub, which gevent.os.fork does, as os.fork of gevent.monkey
+def _after_fork_in_child() -> None:
+    if not gevent.monkey.is_module_patched('os'):
+        gevent.hub.reinit()
+
+
+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 watchers that an object leaves in the loop when it is freed, in the thread of the hub, as the garbage collector runs
+# a finalizer in any thread
+def _release(hub: Any, watchers: dict[int, Any], timers: dict[str, _Timer], aux: tuple[Any, ...]) -> None:
+    if hub.thread_ident == _get_ident():
+        _stop(watchers, timers, aux)
+    else:
+        hub.loop.run_callback_threadsafe(_stop, watchers, timers, aux)
+
+
+def _stop(watchers: dict[int, Any], timers: dict[str, _Timer], aux: tuple[Any, ...]) -> None:
+    for watcher in watchers.values():
+        watcher.stop()
+        watcher.close()
+    watchers.clear()
+    for timer in timers.values():
+        if (watcher := timer['watcher']) is not None:
+            watcher.stop()
+            watcher.close()
+    timers.clear()
+    for watcher in aux:
+        watcher.stop()
+        watcher.close()
+
+
+if hasattr(os, 'register_at_fork'):
+    os.register_at_fork(after_in_child=_after_fork_in_child)
+
+new = Pyjo_Reactor_Gevent.new
+object = Pyjo_Reactor_Gevent
+Gevent = Pyjo_Reactor_Gevent

pyjo_reactor_gevent-0.1.0.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.5
+Name: Pyjo-Reactor-Gevent
+Version: 0.1.0
+Summary: Low level event reactor with gevent support for Pyjoyment.
+Project-URL: Homepage, https://github.com/pyjoyment/Pyjo-Reactor-Gevent
+Project-URL: Documentation, https://pyjoyment.readthedocs.io/projects/pyjo-reactor-gevent/en/stable/
+Author-email: Piotr Roszatycki <piotr.roszatycki@gmail.com>
+License-Expression: Artistic-2.0
+License-File: LICENSE
+Keywords: gevent,greenlet,pyjoyment,reactor
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Requires-Dist: gevent>=26.9.0
+Requires-Dist: pyjoyment>=0.3.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-Gevent?style=flat&label=GitHub%20%E2%AD%90&logo=github)](https://github.com/pyjoyment/Pyjo-Reactor-Gevent)
+[![Documentation](https://img.shields.io/badge/docs-Read_the_Docs-blue?logo=readthedocs&logoColor=white)](https://pyjoyment.readthedocs.io/projects/pyjo-reactor-gevent/en/stable/)
+[![License](https://img.shields.io/github/license/pyjoyment/Pyjo-Reactor-Gevent.svg)](https://github.com/pyjoyment/Pyjo-Reactor-Gevent/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/Pyjo-Reactor-Gevent?logo=pypi&logoColor=white)](https://pypi.org/project/Pyjo-Reactor-Gevent/)
+[![Tests](https://github.com/pyjoyment/Pyjo-Reactor-Gevent/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/pyjoyment/Pyjo-Reactor-Gevent/actions/workflows/tests.yaml)
+[![Trunk Check](https://github.com/pyjoyment/Pyjo-Reactor-Gevent/actions/workflows/trunk-check.yaml/badge.svg?branch=main)](https://github.com/pyjoyment/Pyjo-Reactor-Gevent/actions/workflows/trunk-check.yaml)
+
+# Pyjo-Reactor-Gevent
+
+<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 [gevent](https://www.gevent.org) support for
+[Pyjoyment](https://github.com/pyjoyment/Pyjoyment).
+
+`Pyjo.Reactor.Gevent` is a reactor of Pyjoyment on the hub of gevent, whose
+loop of libev or libuv watches the handles and runs the timers, so that the
+servers of Pyjoyment, `daemon`, `prefork` and `prethread`, and its user agent
+run along with the greenlets of a program of gevent.
+
+## Installation
+
+From [PyPI](https://pypi.org/project/Pyjo-Reactor-Gevent/), with
+[Pyjoyment](https://pypi.org/project/Pyjoyment/) and
+[gevent](https://pypi.org/project/gevent/), which it depends on:
+
+```sh
+pip install Pyjo-Reactor-Gevent
+```
+
+or, in a project managed with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv add Pyjo-Reactor-Gevent
+```
+
+The development version is installed from the Git repository:
+
+```sh
+pip install git+https://github.com/pyjoyment/Pyjo-Reactor-Gevent
+```
+
+## Usage
+
+Select the reactor with `PYJO_REACTOR` before `Pyjo.IOLoop` is loaded:
+
+```sh
+PYJO_REACTOR=Pyjo.Reactor.Gevent python myapp.py daemon
+PYJO_REACTOR=Pyjo.Reactor.Gevent python myapp.py prefork
+```
+
+The reactor runs in the greenlet that starts it, and the other greenlets of the
+program run while it waits for events. A blocking request of the user agent
+waits in the greenlet that makes it, without blocking the others.
+
+gevent runs on libev by default. Its loop of libuv needs
+[cffi](https://pypi.org/project/cffi/):
+
+```sh
+pip install Pyjo-Reactor-Gevent cffi
+GEVENT_LOOP=libuv-cffi PYJO_REACTOR=Pyjo.Reactor.Gevent python myapp.py daemon
+```
+
+With `gevent.monkey.patch_all()`, the threads of the program are greenlets, so
+each greenlet has a `Pyjo.IOLoop.singleton` of its own, and
+`Pyjo.Server.Prethread` and `Pyjo.IOLoop.ChildProcess` do not work.
+
+## Examples
+
+`examples/hello_world_gevent.py` runs `Pyjo.HelloWorld` on the server of
+Pyjoyment on gevent until the signal `INT` or `TERM`, in a `with` block, which
+closes the listen sockets of the server at its end:
+
+```python
+import os
+
+
+# The reactor of Pyjoyment on gevent, selected before Pyjo.IOLoop is loaded
+os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Gevent'
+
+import Pyjo.HelloWorld  # noqa: E402
+import Pyjo.Server.Daemon  # noqa: E402
+
+
+# The server of Pyjoyment on gevent, 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()
+```
+
+```console
+$ python examples/hello_world_gevent.py
+Web application available at http://127.0.0.1:3000
+```
+
+```console
+$ curl http://127.0.0.1:3000/
+Your Pyjo is working!
+```
+
+`examples/loopback_gevent.py` is a server of Pyjoyment and its user agent on
+the hub of gevent, a blocking request, which runs the event loop until the
+response, and the class of the reactor and whether it runs on the hub of
+gevent, which Build checks with the wheel:
+
+```python
+import os
+
+
+# The reactor of Pyjoyment on gevent, selected before Pyjo.IOLoop is loaded
+os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Gevent'
+
+import Pyjo.HelloWorld  # noqa: E402
+import Pyjo.IOLoop  # noqa: E402
+import Pyjo.Server.Daemon  # noqa: E402
+import Pyjo.UserAgent  # noqa: E402
+
+import gevent  # 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 hub of gevent 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__, 'gevent' if getattr(reactor, 'hub', None) is gevent.get_hub() else 'other')
+    print(tx.result.code, tx.result.text)
+```
+
+```console
+$ python examples/loopback_gevent.py
+Pyjo_Reactor_Gevent gevent
+200 Your Pyjo is working!
+```
+
+`examples/greenlets_gevent.py` is a server of Pyjoyment in the main greenlet,
+along with two greenlets of the application that request it, one with a socket
+of gevent and one with a blocking request of the user agent of Pyjoyment:
+
+```python
+import os
+
+
+# The reactor of Pyjoyment on gevent, selected before Pyjo.IOLoop is loaded
+os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Gevent'
+
+import Pyjo.HelloWorld  # noqa: E402
+import Pyjo.IOLoop  # noqa: E402
+import Pyjo.Server.Daemon  # noqa: E402
+import Pyjo.UserAgent  # noqa: E402
+
+import gevent  # noqa: E402
+import gevent.socket  # noqa: E402
+
+
+# A greenlet with a socket of gevent, which waits in the hub of gevent, where the server of Pyjoyment runs
+def with_socket(port):
+    with gevent.socket.create_connection(('127.0.0.1', port)) as sock:
+        sock.sendall(b'GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n')
+        response = b''
+        while b'\r\n' not in response and (chunk := sock.recv(4096)):
+            response += chunk
+    status = response.split(b'\r\n')[0].decode()
+    return f'gevent.socket: {status}'
+
+
+# A greenlet with a blocking request of the user agent of Pyjoyment, whose event loop of its own waits in the greenlet
+def with_user_agent(port):
+    with Pyjo.UserAgent.new() as ua:
+        tx = ua.get(f'http://127.0.0.1:{port}/')
+    return f'Pyjo.UserAgent: {tx.result.code} {tx.result.text}'
+
+
+# The server, on a port that the system picks, which runs in the main greenlet until the greenlets are done, and 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]
+    greenlets = [gevent.spawn(with_socket, port), gevent.spawn(with_user_agent, port)]
+    gevent.spawn(lambda: (gevent.joinall(greenlets), Pyjo.IOLoop.stop()))
+    Pyjo.IOLoop.start()
+    for greenlet in greenlets:
+        print(greenlet.value)
+```
+
+```console
+$ python examples/greenlets_gevent.py
+gevent.socket: HTTP/1.1 200 OK
+Pyjo.UserAgent: 200 Your Pyjo is working!
+```
+
+## Documentation
+
+The API of the module and the examples are on
+[Read the Docs](https://pyjoyment.readthedocs.io/projects/pyjo-reactor-gevent/en/stable/).
+
+## Status
+
+A reactor of Pyjoyment in a distribution of its own, as
+[Pyjo-Reactor-Twisted](https://github.com/pyjoyment/Pyjo-Reactor-Twisted) and
+[Pyjo-Reactor-Uvloop](https://github.com/pyjoyment/Pyjo-Reactor-Uvloop).

pyjo_reactor_gevent-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+Pyjo/Reactor/Gevent.py,sha256=OiwTIlFvSRSOO7F4k1n5dITVICpQ-p5MgzH77b3BKLw,21198
+pyjo_reactor_gevent-0.1.0.dist-info/METADATA,sha256=2c-4nBCs3_0yayXsjx0WU_g69jGNBVEjOEWHu_42Pjk,8757
+pyjo_reactor_gevent-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pyjo_reactor_gevent-0.1.0.dist-info/licenses/LICENSE,sha256=wqf_RI5i8Of0e_6xwFe7wBhw72jXAkF_9N8Ny9ScaP4,8894
+pyjo_reactor_gevent-0.1.0.dist-info/RECORD,,

pyjo_reactor_gevent-0.1.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_gevent-0.1.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.