omlish 0.0.0.dev161__py3-none-any.whl → 0.0.0.dev162__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev161'
-__revision__ = '60fcd526dba581c88e3b27a1defac7fb75614a7b'
+__version__ = '0.0.0.dev162'
+__revision__ = 'd9129e1bcec87862768d3a2fc10011def8f3fd52'
 
 
 #

omlish/asyncs/bluelet/LICENSE

@@ -0,0 +1,6 @@
+Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

omlish/asyncs/bluelet/all.py

@@ -0,0 +1,67 @@
+# ruff: noqa: I001
+from .api import (  # noqa
+    bluelet,
+)
+
+from .core import (  # noqa
+    BlueletCoro as Coro,
+    BlueletExcInfo as ExcInfo,
+    CoreBlueletEvent as CoreEvent,
+    DelegationBlueletEvent as DelegationEvent,
+    ExceptionBlueletEvent as ExceptionEvent,
+    JoinBlueletEvent as JoinEvent,
+    KillBlueletEvent as KillEvent,
+    ReturnBlueletEvent as ReturnEvent,
+    SleepBlueletEvent as SleepEvent,
+    SpawnBlueletEvent as SpawnEvent,
+    ValueBlueletEvent as ValueEvent,
+)
+
+from .events import (  # noqa
+    BlueletEvent as Event,
+    BlueletFuture as Future,
+    BlueletHasFileno as HasFileno,
+    BlueletWaitable as Waitable,
+    BlueletWaitables as Waitables,
+    WaitableBlueletEvent as WaitableEvent,
+)
+
+from .files import (  # noqa
+    FileBlueletEvent as FileEvent,
+    ReadBlueletEvent as ReadEvent,
+    WriteBlueletEvent as WriteEvent,
+)
+
+from .runner import (  # noqa
+    BlueletCoroException as CoroException,
+)
+
+from .sockets import (  # noqa
+    AcceptBlueletEvent as AcceptEvent,
+    BlueletConnection as Connection,
+    BlueletListener as Listener,
+    ReceiveBlueletEvent as ReceiveEvent,
+    SendBlueletEvent as SendEvent,
+    SocketBlueletEvent as SocketEvent,
+    SocketClosedBlueletError as SocketClosedError,
+)
+
+
+##
+
+
+call = bluelet.call
+end = bluelet.end
+join = bluelet.join
+kill = bluelet.kill
+null = bluelet.null
+sleep = bluelet.sleep
+spawn = bluelet.spawn
+
+read = bluelet.read
+write = bluelet.write
+
+run = bluelet.run
+
+connect = bluelet.connect
+server = bluelet.server

omlish/asyncs/bluelet/api.py

@@ -0,0 +1,23 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+from .core import _CoreBlueletApi
+from .files import _FilesBlueletApi
+from .runner import _RunnerBlueletApi
+from .sockets import _SocketsBlueletApi
+
+
+class BlueletApi(
+    _RunnerBlueletApi,
+    _SocketsBlueletApi,
+    _FilesBlueletApi,
+    _CoreBlueletApi,
+):
+    pass
+
+
+bluelet = BlueletApi()

omlish/asyncs/bluelet/core.py

@@ -0,0 +1,178 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+import abc
+import dataclasses as dc
+import time
+import types
+import typing as ta
+
+from .events import BlueletEvent
+from .events import BlueletFuture
+from .events import WaitableBlueletEvent
+
+
+T = ta.TypeVar('T')
+
+BlueletExcInfo = ta.Tuple[ta.Type[BaseException], BaseException, types.TracebackType]  # ta.TypeAlias
+
+BlueletCoro = ta.Generator[ta.Union['BlueletEvent', 'BlueletCoro'], ta.Any, None]  # ta.TypeAlias
+
+BlueletSpawnable = ta.Union[BlueletCoro, ta.Awaitable]  # ta.TypeAlias
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class _BlueletAwaitableDriver:
+    a: ta.Awaitable
+
+    def __call__(self) -> BlueletCoro:
+        g = self.a.__await__()
+        gi = iter(g)
+        while True:
+            try:
+                f = gi.send(None)
+            except StopIteration as e:
+                yield ReturnBlueletEvent(e.value)
+                break
+            else:
+                if not isinstance(f, BlueletFuture):
+                    raise TypeError(f)
+                res = yield f.event
+                f.done = True
+                f.result = res
+
+
+##
+
+
+class CoreBlueletEvent(BlueletEvent, abc.ABC):  # noqa
+    pass
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ValueBlueletEvent(CoreBlueletEvent, ta.Generic[T]):
+    """An event that does nothing but return a fixed value."""
+
+    value: T
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ExceptionBlueletEvent(CoreBlueletEvent):
+    """Raise an exception at the yield point. Used internally."""
+
+    exc_info: BlueletExcInfo
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SpawnBlueletEvent(CoreBlueletEvent):
+    """Add a new coroutine coro to the scheduler."""
+
+    spawned: BlueletSpawnable
+
+
+@dc.dataclass(frozen=True, eq=False)
+class JoinBlueletEvent(CoreBlueletEvent):
+    """Suspend the coro until the specified child coro has completed."""
+
+    child: BlueletCoro
+
+
+@dc.dataclass(frozen=True, eq=False)
+class KillBlueletEvent(CoreBlueletEvent):
+    """Unschedule a child coro."""
+
+    child: BlueletCoro
+
+
+@dc.dataclass(frozen=True, eq=False)
+class DelegationBlueletEvent(CoreBlueletEvent):
+    """
+    Suspend execution of the current coro, start a new coro and, once the child coro finished, return control to
+    the parent coro.
+    """
+
+    spawned: BlueletCoro
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ReturnBlueletEvent(CoreBlueletEvent, ta.Generic[T]):
+    """Return a value the current coro's delegator at the point of delegation. Ends the current (delegate) coro."""
+
+    value: ta.Optional[T]
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SleepBlueletEvent(WaitableBlueletEvent, CoreBlueletEvent):
+    """Suspend the coro for a given duration."""
+
+    wakeup_time: float
+
+    def time_left(self) -> float:
+        return max(self.wakeup_time - time.time(), 0.)
+
+
+##
+
+
+class _CoreBlueletApi:
+    def value(self, v: T) -> ValueBlueletEvent[T]:
+        """Event: yield a value."""
+
+        return ValueBlueletEvent(v)
+
+    def null(self) -> ValueBlueletEvent[None]:
+        """Event: yield to the scheduler without doing anything special."""
+
+        return ValueBlueletEvent(None)
+
+    def spawn(self, spawned: BlueletSpawnable) -> SpawnBlueletEvent:
+        """Event: add another coroutine to the scheduler. Both the parent and child coroutines run concurrently."""
+
+        if isinstance(spawned, types.CoroutineType):
+            spawned = _BlueletAwaitableDriver(spawned)()
+
+        if not isinstance(spawned, types.GeneratorType):
+            raise TypeError(f'{spawned} is not spawnable')
+
+        return SpawnBlueletEvent(spawned)
+
+    def join(self, coro: BlueletCoro) -> JoinBlueletEvent:
+        """Suspend the coro until another, previously `spawn`ed coro completes."""
+
+        return JoinBlueletEvent(coro)
+
+    def kill(self, coro: BlueletCoro) -> KillBlueletEvent:
+        """Halt the execution of a different `spawn`ed coro."""
+
+        return KillBlueletEvent(coro)
+
+    def call(self, spawned: BlueletSpawnable) -> DelegationBlueletEvent:
+        """
+        Event: delegate to another coroutine. The current coroutine is resumed once the sub-coroutine finishes. If the
+        sub-coroutine returns a value using end(), then this event returns that value.
+        """
+
+        if isinstance(spawned, types.CoroutineType):
+            spawned = _BlueletAwaitableDriver(spawned)()
+
+        if not isinstance(spawned, types.GeneratorType):
+            raise TypeError(f'{spawned} is not spawnable')
+
+        return DelegationBlueletEvent(spawned)
+
+    def end(self, value: ta.Optional[T] = None) -> ReturnBlueletEvent[T]:
+        """Event: ends the coroutine and returns a value to its delegator."""
+
+        return ReturnBlueletEvent(value)
+
+    def sleep(self, duration: float) -> SleepBlueletEvent:
+        """Event: suspend the coro for ``duration`` seconds."""
+
+        return SleepBlueletEvent(time.time() + duration)

omlish/asyncs/bluelet/events.py

@@ -0,0 +1,78 @@
+# ruff: noqa: UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+import abc
+import dataclasses as dc
+import typing as ta
+
+
+R = ta.TypeVar('R')
+
+BlueletEventT = ta.TypeVar('BlueletEventT', bound='BlueletEvent')  # ta.TypeAlias
+
+BlueletWaitable = ta.Union[int, 'BlueletHasFileno']  # ta.TypeAlias
+
+
+##
+
+
+class BlueletEvent(abc.ABC):  # noqa
+    """
+    Just a base class identifying Bluelet events. An event is an object yielded from a Bluelet coro coroutine to
+    suspend operation and communicate with the scheduler.
+    """
+
+    def __await__(self):
+        return BlueletFuture(self).__await__()
+
+
+##
+
+
+class BlueletHasFileno(ta.Protocol):
+    def fileno(self) -> int: ...
+
+
+@dc.dataclass(frozen=True)
+class BlueletWaitables:
+    r: ta.Sequence[BlueletWaitable] = ()
+    w: ta.Sequence[BlueletWaitable] = ()
+    x: ta.Sequence[BlueletWaitable] = ()
+
+
+class WaitableBlueletEvent(BlueletEvent, abc.ABC):  # noqa
+    """
+    A waitable event is one encapsulating an action that can be waited for using a select() call. That is, it's an event
+    with an associated file descriptor.
+    """
+
+    def waitables(self) -> BlueletWaitables:
+        """
+        Return "waitable" objects to pass to select(). Should return three iterables for input readiness, output
+        readiness, and exceptional conditions (i.e., the three lists passed to select()).
+        """
+        return BlueletWaitables()
+
+    def fire(self) -> ta.Any:
+        """Called when an associated file descriptor becomes ready (i.e., is returned from a select() call)."""
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class BlueletFuture(ta.Generic[BlueletEventT, R]):
+    event: BlueletEventT
+    done: bool = False
+    result: ta.Optional[R] = None
+
+    def __await__(self):
+        if not self.done:
+            yield self
+        if not self.done:
+            raise RuntimeError("await wasn't used with event future")
+        return self.result

omlish/asyncs/bluelet/files.py

@@ -0,0 +1,80 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+import abc
+import dataclasses as dc
+import typing as ta
+
+from .core import DelegationBlueletEvent
+from .core import ReturnBlueletEvent
+from .events import BlueletEvent
+from .events import BlueletWaitables
+from .events import WaitableBlueletEvent
+
+
+##
+
+
+class FileBlueletEvent(BlueletEvent, abc.ABC):
+    pass
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ReadBlueletEvent(WaitableBlueletEvent, FileBlueletEvent):
+    """Reads from a file-like object."""
+
+    fd: ta.IO
+    bufsize: int
+
+    def waitables(self) -> BlueletWaitables:
+        return BlueletWaitables(r=[self.fd])
+
+    def fire(self) -> bytes:
+        return self.fd.read(self.bufsize)
+
+
+@dc.dataclass(frozen=True, eq=False)
+class WriteBlueletEvent(WaitableBlueletEvent, FileBlueletEvent):
+    """Writes to a file-like object."""
+
+    fd: ta.IO
+    data: bytes
+
+    def waitables(self) -> BlueletWaitables:
+        return BlueletWaitables(w=[self.fd])
+
+    def fire(self) -> None:
+        self.fd.write(self.data)
+
+
+##
+
+
+class _FilesBlueletApi:
+    def read(self, fd: ta.IO, bufsize: ta.Optional[int] = None) -> BlueletEvent:
+        """Event: read from a file descriptor asynchronously."""
+
+        if bufsize is None:
+            # Read all.
+            def reader():
+                buf = []
+                while True:
+                    data = yield self.read(fd, 1024)
+                    if not data:
+                        break
+                    buf.append(data)
+                yield ReturnBlueletEvent(''.join(buf))
+
+            return DelegationBlueletEvent(reader())
+
+        else:
+            return ReadBlueletEvent(fd, bufsize)
+
+    def write(self, fd: ta.IO, data: bytes) -> BlueletEvent:
+        """Event: write to a file descriptor asynchronously."""
+
+        return WriteBlueletEvent(fd, data)

omlish/asyncs/bluelet/runner.py

@@ -0,0 +1,416 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+TODO:
+ - use fdio
+ - wrap coros in Tasks :|
+ - (unit)tests lol
+ - * subprocesses
+ - canceling
+ - timeouts
+ - task groups
+ - gather
+ - locks / semaphores / events / etc
+ - rename Coro to Bluelet?
+ - shutdown
+ - ensure resource cleanup
+ - run_thread? whatever?
+
+Subprocs:
+ - https://github.com/python/cpython/issues/120804 - GH-120804: Remove get_child_watcher and set_child_watcher from
+   asyncio
+ - https://github.com/python/cpython/pull/17063/files bpo-38692: Add os.pidfd_open
+ - clone PidfdChildWatcher + ThreadedChildWatcher
+"""
+import collections
+import dataclasses as dc
+import errno
+import logging
+import select
+import sys
+import time
+import traceback
+import types
+import typing as ta
+import weakref
+
+from .core import BlueletCoro
+from .core import BlueletExcInfo
+from .core import CoreBlueletEvent
+from .core import DelegationBlueletEvent
+from .core import ExceptionBlueletEvent
+from .core import JoinBlueletEvent
+from .core import KillBlueletEvent
+from .core import ReturnBlueletEvent
+from .core import SleepBlueletEvent
+from .core import SpawnBlueletEvent
+from .core import ValueBlueletEvent
+from .core import _BlueletAwaitableDriver
+from .events import BlueletEvent
+from .events import BlueletWaitable
+from .events import WaitableBlueletEvent
+
+
+##
+
+
+class BlueletCoroException(Exception):  # noqa
+    def __init__(self, coro: BlueletCoro, exc_info: BlueletExcInfo) -> None:
+        super().__init__()
+        self.coro = coro
+        self.exc_info = exc_info
+
+    @staticmethod
+    def _exc_info() -> BlueletExcInfo:
+        return sys.exc_info()  # type: ignore
+
+    @staticmethod
+    def _reraise(typ: ta.Type[BaseException], exc: BaseException, tb: types.TracebackType) -> ta.NoReturn:  # noqa
+        raise exc.with_traceback(tb)
+
+    def reraise(self) -> ta.NoReturn:
+        self._reraise(self.exc_info[0], self.exc_info[1], self.exc_info[2])
+
+
+##
+
+
+def _bluelet_event_select(
+        events: ta.Iterable[BlueletEvent],
+        *,
+        log: ta.Optional[logging.Logger] = None,
+) -> ta.Set[WaitableBlueletEvent]:
+    """
+    Perform a select() over all the Events provided, returning the ones ready to be fired. Only WaitableEvents
+    (including SleepEvents) matter here; all other events are ignored (and thus postponed).
+    """
+
+    waitable_to_event: ta.Dict[ta.Tuple[str, BlueletWaitable], WaitableBlueletEvent] = {}
+    rlist: ta.List[BlueletWaitable] = []
+    wlist: ta.List[BlueletWaitable] = []
+    xlist: ta.List[BlueletWaitable] = []
+    earliest_wakeup: ta.Optional[float] = None
+
+    # Gather waitables and wakeup times.
+    for event in events:
+        if isinstance(event, SleepBlueletEvent):
+            if not earliest_wakeup:
+                earliest_wakeup = event.wakeup_time
+            else:
+                earliest_wakeup = min(earliest_wakeup, event.wakeup_time)
+
+        elif isinstance(event, WaitableBlueletEvent):
+            ew = event.waitables()
+            rlist.extend(ew.r)
+            wlist.extend(ew.w)
+            xlist.extend(ew.x)
+            for waitable in ew.r:
+                waitable_to_event[('r', waitable)] = event
+            for waitable in ew.w:
+                waitable_to_event[('w', waitable)] = event
+            for waitable in ew.x:
+                waitable_to_event[('x', waitable)] = event
+
+    # If we have a any sleeping coros, determine how long to sleep.
+    if earliest_wakeup:
+        timeout = max(earliest_wakeup - time.time(), 0.)
+    else:
+        timeout = None
+
+    # Perform select() if we have any waitables.
+    if rlist or wlist or xlist:
+        if log:
+            log.debug('_bluelet_event_select: +select: %r %r %r %r', rlist, wlist, xlist, timeout)
+        rready, wready, xready = select.select(rlist, wlist, xlist, timeout)
+        if log:
+            log.debug('_bluelet_event_select: -select: %r %r %r', rready, wready, xready)
+
+    else:
+        rready, wready, xready = [], [], []
+        if timeout:
+            if log:
+                log.debug('_bluelet_event_select: sleep: %r', timeout)
+            time.sleep(timeout)
+
+    # Gather ready events corresponding to the ready waitables.
+    ready_events: ta.Set[WaitableBlueletEvent] = set()
+    for ready in rready:
+        ready_events.add(waitable_to_event[('r', ready)])
+    for ready in wready:
+        ready_events.add(waitable_to_event[('w', ready)])
+    for ready in xready:
+        ready_events.add(waitable_to_event[('x', ready)])
+
+    # Gather any finished sleeps.
+    for event in events:
+        if isinstance(event, SleepBlueletEvent) and not event.time_left():
+            ready_events.add(event)
+
+    return ready_events
+
+
+##
+
+
+class _SuspendedBlueletEvent(CoreBlueletEvent):
+    pass
+
+
+_BLUELET_SUSPENDED = _SuspendedBlueletEvent()  # Special sentinel placeholder for suspended coros.
+
+
+@dc.dataclass(frozen=True, eq=False)
+class _DelegatedBlueletEvent(CoreBlueletEvent):
+    """Placeholder indicating that a coro has delegated execution to a different coro."""
+
+    child: BlueletCoro
+
+
+class _BlueletRunner:
+    """
+    Schedules a coroutine, running it to completion. This encapsulates the Bluelet scheduler, which the root coroutine
+    can add to by spawning new coroutines.
+    """
+
+    def __init__(
+            self,
+            root_coro: BlueletCoro,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+    ) -> None:
+        super().__init__()
+
+        self._root_coro = root_coro
+        self._log = log
+
+        # The "coros" dictionary keeps track of all the currently-executing and suspended coroutines. It maps
+        # coroutines to their currently "blocking" event. The event value may be SUSPENDED if the coroutine is waiting
+        # on some other condition: namely, a delegated coroutine or a joined coroutine. In this case, the coroutine
+        # should *also* appear as a value in one of the below dictionaries `delegators` or `joiners`.
+        self._coros: ta.Dict[BlueletCoro, BlueletEvent] = {self._root_coro: ValueBlueletEvent(None)}
+
+        # Maps child coroutines to delegating parents.
+        self._delegators: ta.Dict[BlueletCoro, BlueletCoro] = {}
+
+        # Maps child coroutines to joining (exit-waiting) parents.
+        self._joiners: ta.MutableMapping[BlueletCoro, ta.List[BlueletCoro]] = collections.defaultdict(list)
+
+        # History of spawned coroutines for joining of already completed coroutines.
+        self._history: ta.MutableMapping[BlueletCoro, ta.Optional[BlueletEvent]] = \
+            weakref.WeakKeyDictionary({self._root_coro: None})
+
+    def _complete_coro(self, coro: BlueletCoro, return_value: ta.Any) -> None:
+        """
+        Remove a coroutine from the scheduling pool, awaking delegators and joiners as necessary and returning the
+        specified value to any delegating parent.
+        """
+
+        del self._coros[coro]
+
+        # Resume delegator.
+        if coro in self._delegators:
+            self._coros[self._delegators[coro]] = ValueBlueletEvent(return_value)
+            del self._delegators[coro]
+
+        # Resume joiners.
+        if coro in self._joiners:
+            for parent in self._joiners[coro]:
+                self._coros[parent] = ValueBlueletEvent(None)
+            del self._joiners[coro]
+
+    def _advance_coro(self, coro: BlueletCoro, value: ta.Any, is_exc: bool = False) -> None:
+        """
+        After an event is fired, run a given coroutine associated with it in the coros dict until it yields again. If
+        the coroutine exits, then the coro is removed from the pool. If the coroutine raises an exception, it is
+        reraised in a CoroException. If is_exc is True, then the value must be an exc_info tuple and the exception is
+        thrown into the coroutine.
+        """
+
+        try:
+            if is_exc:
+                next_event = coro.throw(*value)
+            else:
+                next_event = coro.send(value)
+
+        except StopIteration:
+            # Coro is done.
+            self._complete_coro(coro, None)
+
+        except BaseException:  # noqa
+            # Coro raised some other exception.
+            del self._coros[coro]
+            # Note: Don't use `raise from` as this should support 3.8.
+            raise BlueletCoroException(coro, BlueletCoroException._exc_info())  # noqa
+
+        else:
+            if isinstance(next_event, ta.Generator):
+                # Automatically invoke sub-coroutines. (Shorthand for explicit bluelet.call().)
+                next_event = DelegationBlueletEvent(next_event)
+
+            if isinstance(next_event, types.CoroutineType):  # type: ignore[unreachable]
+                next_event = DelegationBlueletEvent(_BlueletAwaitableDriver(next_event)())  # type: ignore[unreachable]
+
+            if not isinstance(next_event, BlueletEvent):
+                raise TypeError(next_event)
+
+            self._coros[coro] = next_event
+
+    def _kill_coro(self, coro: BlueletCoro) -> None:
+        """Unschedule this coro and its (recursive) delegates."""
+
+        # Collect all coroutines in the delegation stack.
+        coros = [coro]
+        while isinstance((cur := self._coros[coro]), _DelegatedBlueletEvent):
+            coro = cur.child  # noqa
+            coros.append(coro)
+
+        # Complete each coroutine from the top to the bottom of the stack.
+        for coro in reversed(coros):
+            self._complete_coro(coro, None)
+
+    def close(self) -> None:
+        # If any coros still remain, kill them.
+        for coro in self._coros:
+            coro.close()
+
+        self._coros.clear()
+
+    def _handle_core_event(self, coro: BlueletCoro, event: CoreBlueletEvent) -> bool:
+        if self._log:
+            self._log.debug(f'{self.__class__.__name__}._handle_core_event: %r %r', coro, event)
+
+        if isinstance(event, SpawnBlueletEvent):
+            sc = ta.cast(BlueletCoro, event.spawned)  # FIXME
+            self._coros[sc] = ValueBlueletEvent(None)  # Spawn.
+            self._history[sc] = None  # Record in history.
+            self._advance_coro(coro, None)
+            return True
+
+        elif isinstance(event, ValueBlueletEvent):
+            self._advance_coro(coro, event.value)
+            return True
+
+        elif isinstance(event, ExceptionBlueletEvent):
+            self._advance_coro(coro, event.exc_info, True)
+            return True
+
+        elif isinstance(event, DelegationBlueletEvent):
+            self._coros[coro] = _DelegatedBlueletEvent(event.spawned)  # Suspend.
+            self._coros[event.spawned] = ValueBlueletEvent(None)  # Spawn.
+            self._history[event.spawned] = None  # Record in history.
+            self._delegators[event.spawned] = coro
+            return True
+
+        elif isinstance(event, ReturnBlueletEvent):
+            # Coro is done.
+            self._complete_coro(coro, event.value)
+            return True
+
+        elif isinstance(event, JoinBlueletEvent):
+            if event.child not in self._coros and event.child in self._history:
+                self._coros[coro] = ValueBlueletEvent(None)
+            else:
+                self._coros[coro] = _BLUELET_SUSPENDED  # Suspend.
+                self._joiners[event.child].append(coro)
+            return True
+
+        elif isinstance(event, KillBlueletEvent):
+            self._coros[coro] = ValueBlueletEvent(None)
+            self._kill_coro(event.child)
+            return True
+
+        elif isinstance(event, (_DelegatedBlueletEvent, _SuspendedBlueletEvent)):
+            return False
+
+        else:
+            raise TypeError(event)
+
+    def _step(self) -> ta.Optional[BlueletCoroException]:
+        if self._log:
+            self._log.debug(f'{self.__class__.__name__}._step')  # Noqa
+
+        try:
+            # Look for events that can be run immediately. Continue running immediate events until nothing is ready.
+            while True:
+                have_ready = False
+                for coro, event in list(self._coros.items()):
+                    if isinstance(event, CoreBlueletEvent) and not isinstance(event, SleepBlueletEvent):
+                        have_ready |= self._handle_core_event(coro, event)
+                    elif isinstance(event, WaitableBlueletEvent):
+                        pass
+                    else:
+                        raise TypeError(f'Unknown event type: {event}')  # noqa
+
+                # Only start the select when nothing else is ready.
+                if not have_ready:
+                    break
+
+            # Wait and fire.
+            event2coro = {v: k for k, v in self._coros.items()}
+            for event in _bluelet_event_select(self._coros.values()):
+                # Run the IO operation, but catch socket errors.
+                try:
+                    value = event.fire()
+                except OSError as exc:
+                    if isinstance(exc.args, tuple) and exc.args[0] == errno.EPIPE:
+                        # Broken pipe. Remote host disconnected.
+                        pass
+                    elif isinstance(exc.args, tuple) and exc.args[0] == errno.ECONNRESET:
+                        # Connection was reset by peer.
+                        pass
+                    else:
+                        traceback.print_exc()
+                    # Abort the coroutine.
+                    self._coros[event2coro[event]] = ReturnBlueletEvent(None)
+                else:
+                    self._advance_coro(event2coro[event], value)
+
+        except BlueletCoroException as te:
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception(f'{self.__class__.__name__}._step')
+
+            # Exception raised from inside a coro.
+            event = ExceptionBlueletEvent(te.exc_info)
+            if te.coro in self._delegators:
+                # The coro is a delegate. Raise exception in its delegator.
+                self._coros[self._delegators[te.coro]] = event
+                del self._delegators[te.coro]
+            else:
+                # The coro is root-level. Raise in client code.
+                return te
+
+        except BaseException:  # noqa
+            ei = BlueletCoroException._exc_info()  # noqa
+
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception(f'{self.__class__.__name__}._step')
+
+            # For instance, KeyboardInterrupt during select(). Raise into root coro and terminate others.
+            self._coros = {self._root_coro: ExceptionBlueletEvent(ei)}  # noqa
+
+        return None
+
+    def run(self) -> None:
+        # Continue advancing coros until root coro exits.
+        exit_ce: BlueletCoroException | None = None
+        while self._coros:
+            exit_ce = self._step()
+
+        self.close()
+
+        # If we're exiting with an exception, raise it in the client.
+        if exit_ce:
+            exit_ce.reraise()
+
+
+##
+
+
+class _RunnerBlueletApi:
+    def run(self, root_coro: BlueletCoro) -> None:
+        _BlueletRunner(root_coro).run()

omlish/asyncs/bluelet/sockets.py

@@ -0,0 +1,214 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+import abc
+import dataclasses as dc
+import socket
+import typing as ta
+
+from .core import BlueletCoro
+from .core import ReturnBlueletEvent
+from .core import ValueBlueletEvent
+from .core import _CoreBlueletApi
+from .events import BlueletEvent
+from .events import BlueletWaitables
+from .events import WaitableBlueletEvent
+
+
+##
+
+
+class SocketClosedBlueletError(Exception):
+    pass
+
+
+class BlueletListener:
+    """A socket wrapper object for listening sockets."""
+
+    def __init__(self, host: str, port: int) -> None:
+        """Create a listening socket on the given hostname and port."""
+
+        super().__init__()
+        self._closed = False
+        self.host = host
+        self.port = port
+
+        self.sock = sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((host, port))
+        sock.listen(5)
+
+    def accept(self) -> 'AcceptBlueletEvent':
+        """
+        An event that waits for a connection on the listening socket. When a connection is made, the event returns a
+        Connection object.
+        """
+
+        if self._closed:
+            raise SocketClosedBlueletError
+        return AcceptBlueletEvent(self)
+
+    def close(self) -> None:
+        """Immediately close the listening socket. (Not an event.)"""
+
+        self._closed = True
+        self.sock.close()
+
+
+class BlueletConnection:
+    """A socket wrapper object for connected sockets."""
+
+    def __init__(self, sock: socket.socket, addr: ta.Tuple[str, int]) -> None:
+        super().__init__()
+        self.sock = sock
+        self.addr = addr
+        self._buf = bytearray()
+        self._closed: bool = False
+
+    def close(self) -> None:
+        """Close the connection."""
+
+        self._closed = True
+        self.sock.close()
+
+    def recv(self, size: int) -> BlueletEvent:
+        """Read at most size bytes of data from the socket."""
+
+        if self._closed:
+            raise SocketClosedBlueletError
+
+        if self._buf:
+            # We already have data read previously.
+            out = self._buf[:size]
+            self._buf = self._buf[size:]
+            return ValueBlueletEvent(bytes(out))
+        else:
+            return ReceiveBlueletEvent(self, size)
+
+    def send(self, data: bytes) -> BlueletEvent:
+        """Sends data on the socket, returning the number of bytes successfully sent."""
+
+        if self._closed:
+            raise SocketClosedBlueletError
+        return SendBlueletEvent(self, data)
+
+    def sendall(self, data: bytes) -> BlueletEvent:
+        """Send all of data on the socket."""
+
+        if self._closed:
+            raise SocketClosedBlueletError
+        return SendBlueletEvent(self, data, True)
+
+    def readline(self, terminator: bytes = b'\n', bufsize: int = 1024) -> BlueletCoro:
+        """Reads a line (delimited by terminator) from the socket."""
+
+        if self._closed:
+            raise SocketClosedBlueletError
+
+        while True:
+            if terminator in self._buf:
+                line, self._buf = self._buf.split(terminator, 1)
+                line += terminator
+                yield ReturnBlueletEvent(bytes(line))
+                break
+
+            if (data := (yield ReceiveBlueletEvent(self, bufsize))):
+                self._buf += data
+            else:
+                line = self._buf
+                self._buf = bytearray()
+                yield ReturnBlueletEvent(bytes(line))
+                break
+
+
+##
+
+
+class SocketBlueletEvent(BlueletEvent, abc.ABC):  # noqa
+    pass
+
+
+@dc.dataclass(frozen=True, eq=False)
+class AcceptBlueletEvent(WaitableBlueletEvent, SocketBlueletEvent):
+    """An event for Listener objects (listening sockets) that suspends execution until the socket gets a connection."""
+
+    listener: BlueletListener
+
+    def waitables(self) -> BlueletWaitables:
+        return BlueletWaitables(r=[self.listener.sock])
+
+    def fire(self) -> BlueletConnection:
+        sock, addr = self.listener.sock.accept()
+        return BlueletConnection(sock, addr)
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ReceiveBlueletEvent(WaitableBlueletEvent, SocketBlueletEvent):
+    """An event for Connection objects (connected sockets) for asynchronously reading data."""
+
+    conn: BlueletConnection
+    bufsize: int
+
+    def waitables(self) -> BlueletWaitables:
+        return BlueletWaitables(r=[self.conn.sock])
+
+    def fire(self) -> bytes:
+        return self.conn.sock.recv(self.bufsize)
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SendBlueletEvent(WaitableBlueletEvent, SocketBlueletEvent):
+    """An event for Connection objects (connected sockets) for asynchronously writing data."""
+
+    conn: BlueletConnection
+    data: bytes
+    sendall: bool = False
+
+    def waitables(self) -> BlueletWaitables:
+        return BlueletWaitables(w=[self.conn.sock])
+
+    def fire(self) -> ta.Optional[int]:
+        if self.sendall:
+            self.conn.sock.sendall(self.data)
+            return None
+        else:
+            return self.conn.sock.send(self.data)
+
+
+##
+
+
+class _SocketsBlueletApi(_CoreBlueletApi):
+    def connect(self, host: str, port: int) -> BlueletEvent:
+        """Event: connect to a network address and return a Connection object for communicating on the socket."""
+
+        addr = (host, port)
+        sock = socket.create_connection(addr)
+        return ValueBlueletEvent(BlueletConnection(sock, addr))
+
+    def server(self, host: str, port: int, func) -> BlueletCoro:
+        """
+        A coroutine that runs a network server. Host and port specify the listening address. func should be a coroutine
+        that takes a single parameter, a Connection object. The coroutine is invoked for every incoming connection on
+        the listening socket.
+        """
+
+        def handler(conn):
+            try:
+                yield func(conn)
+            finally:
+                conn.close()
+
+        listener = BlueletListener(host, port)
+        try:
+            while True:
+                conn = yield listener.accept()
+                yield self.spawn(handler(conn))
+        except KeyboardInterrupt:
+            pass
+        finally:
+            listener.close()

omlish/lite/inject.py

@@ -610,7 +610,7 @@ class InjectorBinder:
     def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError
 
-    _FN_TYPES: ta.Tuple[type, ...] = (
+    _FN_TYPES: ta.ClassVar[ta.Tuple[type, ...]] = (
         types.FunctionType,
         types.MethodType,
 
@@ -632,7 +632,7 @@ class InjectorBinder:
             cls._FN_TYPES = (*cls._FN_TYPES, icls)
         return icls
 
-    _BANNED_BIND_TYPES: ta.Tuple[type, ...] = (
+    _BANNED_BIND_TYPES: ta.ClassVar[ta.Tuple[type, ...]] = (
         InjectorProvider,
     )
 
@@ -811,45 +811,35 @@ def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
 ##
 
 
-class Injection:
-    def __new__(cls, *args, **kwargs):  # noqa
-        raise TypeError
-
+class InjectionApi:
     # keys
 
-    @classmethod
-    def as_key(cls, o: ta.Any) -> InjectorKey:
+    def as_key(self, o: ta.Any) -> InjectorKey:
         return as_injector_key(o)
 
-    @classmethod
-    def array(cls, o: ta.Any) -> InjectorKey:
+    def array(self, o: ta.Any) -> InjectorKey:
         return dc.replace(as_injector_key(o), array=True)
 
-    @classmethod
-    def tag(cls, o: ta.Any, t: ta.Any) -> InjectorKey:
+    def tag(self, o: ta.Any, t: ta.Any) -> InjectorKey:
         return dc.replace(as_injector_key(o), tag=t)
 
     # bindings
 
-    @classmethod
-    def as_bindings(cls, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    def as_bindings(self, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return as_injector_bindings(*args)
 
-    @classmethod
-    def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    def override(self, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
     # injector
 
-    @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
+    def create_injector(self, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
         return _Injector(as_injector_bindings(*args), parent)
 
     # binder
 
-    @classmethod
     def bind(
-            cls,
+            self,
             obj: ta.Any,
             *,
             key: ta.Any = None,
@@ -884,32 +874,29 @@ class Injection:
 
     # helpers
 
-    @classmethod
     def bind_factory(
-            cls,
+            self,
             fn: ta.Callable[..., T],
             cls_: U,
             ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_factory(fn, cls_, ann))
+        return self.bind(make_injector_factory(fn, cls_, ann))
 
-    @classmethod
     def bind_array(
-            cls,
+            self,
             obj: ta.Any = None,
             *,
             tag: ta.Any = None,
     ) -> InjectorBindingOrBindings:
         return bind_injector_array(obj, tag=tag)
 
-    @classmethod
     def bind_array_type(
-            cls,
+            self,
             ele: ta.Union[InjectorKey, InjectorKeyCls],
             cls_: U,
             ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_array_type(ele, cls_, ann))
+        return self.bind(make_injector_array_type(ele, cls_, ann))
 
 
-inj = Injection
+inj = InjectionApi()

{omlish-0.0.0.dev161.dist-info → omlish-0.0.0.dev162.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev161
+Version: 0.0.0.dev162
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev161.dist-info → omlish-0.0.0.dev162.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=RX24SRc6DCEg77PUVnaXOKCWa5TF_c9RQJdGIf7gl9c,1135
-omlish/__about__.py,sha256=mO53HhyG-ZTHxwvhTxgq__7mREyycsxsT-5hHzJF95Q,3409
+omlish/__about__.py,sha256=RGH11TXe-0tI-c-75Cmj5Em5DfZ8d1t-Xincc1SM3bE,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -92,6 +92,15 @@ omlish/asyncs/asyncio/channels.py,sha256=ZbmsEmdK1fV96liHdcVpRqA2dAMkXJt4Q3rFAg3
 omlish/asyncs/asyncio/streams.py,sha256=Uc9PCWSfBqrK2kdVtfjjQU1eaYTWYmZm8QISDj2xiuw,1004
 omlish/asyncs/asyncio/subprocesses.py,sha256=XlIWwSxpVB7sMVc75-f7dI6r08JkdipNFRWXUKS8zAw,6960
 omlish/asyncs/asyncio/timeouts.py,sha256=Rj5OU9BIAPcVZZKp74z7SzUXF5xokh4dgsWkUqOy1aE,355
+omlish/asyncs/bluelet/LICENSE,sha256=VHf3oPQihOHnWyIR8LcXX0dpONa1lgyJnjWC2qVuRR0,559
+omlish/asyncs/bluelet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/asyncs/bluelet/all.py,sha256=aUV6PwnR8DqnEBS9wsZuPW_UtP6G9M8_KY-mmxZeVG0,1516
+omlish/asyncs/bluelet/api.py,sha256=yeM5SauiIbvKj26mDdxn5mOj8s5fFIw2xBSe-P6HVC0,904
+omlish/asyncs/bluelet/core.py,sha256=NpGQhb865aeXPKV_67l-6FiuQzdDJJ85zjfvCR5R8Pc,5430
+omlish/asyncs/bluelet/events.py,sha256=iXpRWmy64YcshT_nuyiJ39jbketZdtj8LrdlX3JmpoY,2440
+omlish/asyncs/bluelet/files.py,sha256=pgcLV_3oGbpqQmOrii8SeizyYLp8XKofQJhqM82RlKw,2389
+omlish/asyncs/bluelet/runner.py,sha256=cwgVjwRRXzqfOqRD0rkPHjt_Udyt9ZKpVs36uAJ_Q7c,15473
+omlish/asyncs/bluelet/sockets.py,sha256=RrC2vU52dOEBYKzvoh1qA39uUE8p3uCB_oxnhaP1AeA,6752
 omlish/bootstrap/__init__.py,sha256=-Rtsg7uPQNhh1dIT9nqrz96XlqizwoLnWf-FwOEstJI,730
 omlish/bootstrap/__main__.py,sha256=4jCwsaogp0FrJjJZ85hzF4-WqluPeheHbfeoKynKvNs,194
 omlish/bootstrap/base.py,sha256=d8hqn4hp1XMMi5PgcJBQXPKmW47epu8CxBlqDZiRZb4,1073
@@ -339,7 +348,7 @@ omlish/lite/__init__.py,sha256=Y3l4WY4JRi2uLG6kgbGp93fuGfkxkKwZDvhsa0Rwgtk,15
 omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 omlish/lite/check.py,sha256=KvcO86LqWlh2j4ORaZXRR4FM8fFb7kUkNqq3lTs0Ta0,12821
 omlish/lite/contextmanagers.py,sha256=m9JO--p7L7mSl4cycXysH-1AO27weDKjP3DZG61cwwM,1683
-omlish/lite/inject.py,sha256=729Qi0TLbQgBtkvx97q1EUMe73VFYA1hu4woXkOTcwM,23572
+omlish/lite/inject.py,sha256=EEaioN9ESAveVCMe2s5osjwI97FPRUVoU8P95vGUiYo,23376
 omlish/lite/json.py,sha256=7-02Ny4fq-6YAu5ynvqoijhuYXWpLmfCI19GUeZnb1c,740
 omlish/lite/logs.py,sha256=CWFG0NKGhqNeEgryF5atN2gkPYbUdTINEw_s1phbINM,51
 omlish/lite/marshal.py,sha256=ldoZs_yiQIUpOjBviV9f4mwm7hSZy0hRLXrvQA-6POU,14257
@@ -526,9 +535,9 @@ omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,329
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev161.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev161.dist-info/METADATA,sha256=FeXlao_p21yJqF4nL1hTicjLO3Ir0XMm9jii9k8-2ws,4264
-omlish-0.0.0.dev161.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev161.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev161.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev161.dist-info/RECORD,,
+omlish-0.0.0.dev162.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev162.dist-info/METADATA,sha256=thW6t3ofpA5bodN1Uc7hDhNjXOwZd68S1SqJZuv4hIw,4264
+omlish-0.0.0.dev162.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev162.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev162.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev162.dist-info/RECORD,,