omlish 0.0.0.dev230__py3-none-any.whl → 0.0.0.dev231__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev230'
-__revision__ = 'ed2672ad6a2fb4718c57e281c5ce91fdc7998a6f'
+__version__ = '0.0.0.dev231'
+__revision__ = '2eb4140ac802af2814bc4b4d5a8d37613083ae32'
 
 
 #

omlish/daemons/daemon.py

@@ -0,0 +1,200 @@
+"""
+TODO:
+ - OK.. this is useful for non-system-daemons too... which have no pidfile..
+ - split out pidfile concern to.. identity?
+ - async[io] support, really just waiting
+ - helpers for http, json, etc
+ - heartbeat? status checks? heartbeat file?
+ - zmq
+ - cli, cfg reload
+ - bootstrap
+  - rsrc limit
+  - logs
+ - https://github.com/Homebrew/homebrew-services
+ - deathpacts
+ - timebomb
+ - pickle protocol, revision / venv check, multiprocessing manager support
+"""
+import contextlib
+import functools
+import logging
+import os.path
+import threading
+import time
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from ..os.pidfiles.manager import _PidfileManager  # noqa
+from ..os.pidfiles.manager import open_inheritable_pidfile
+from ..os.pidfiles.pidfile import Pidfile
+from .reparent import reparent_process
+from .spawning import InProcessSpawner
+from .spawning import Spawn
+from .spawning import Spawner
+from .spawning import Spawning
+from .spawning import spawner_for
+from .targets import Target
+from .targets import target_runner_for
+from .waiting import Wait
+from .waiting import waiter_for
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+class Daemon:
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Config:
+        target: Target
+        spawning: Spawning
+
+        #
+
+        reparent_process: bool = False
+
+        pid_file: str | None = None
+
+        #
+
+        wait: Wait | None = None
+
+        wait_timeout: lang.TimeoutLike = 10.
+        wait_sleep_s: float = .1
+
+        launched_timeout_s: float = 5.
+
+        #
+
+        def __post_init__(self) -> None:
+            check.isinstance(self.pid_file, (str, None))
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+
+        self._config = config
+
+    @property
+    def config(self) -> Config:
+        return self._config
+
+    #
+
+    @property
+    def has_pidfile(self) -> bool:
+        return self._config.pid_file is not None
+
+    def _non_inheritable_pidfile(self) -> Pidfile:
+        check.state(self.has_pidfile)
+        return Pidfile(
+            check.non_empty_str(self._config.pid_file),
+            inheritable=False,
+        )
+
+    def is_running(self) -> bool:
+        check.state(self.has_pidfile)
+
+        if not os.path.isfile(check.non_empty_str(self._config.pid_file)):
+            return False
+
+        with self._non_inheritable_pidfile() as pf:
+            return not pf.try_acquire_lock()
+
+    #
+
+    def _inner_launch(
+            self,
+            *,
+            pidfile_manager: ta.ContextManager | None,
+            launched_callback: ta.Callable[[], None] | None = None,
+    ) -> None:
+        try:
+            if self._config.reparent_process:
+                log.info('Reparenting')
+                reparent_process()
+
+            with contextlib.ExitStack() as es:
+                pidfile: Pidfile | None = None  # noqa
+                if pidfile_manager is not None:
+                    pidfile = check.isinstance(es.enter_context(pidfile_manager), Pidfile)
+                    pidfile.write()
+
+                if launched_callback is not None:
+                    launched_callback()
+
+                runner = target_runner_for(self._config.target)
+                runner.run()
+
+        finally:
+            if launched_callback is not None:
+                launched_callback()
+
+    def launch_no_wait(self) -> bool:
+        with contextlib.ExitStack() as es:
+            spawner: Spawner = es.enter_context(spawner_for(self._config.spawning))
+
+            #
+
+            inherit_fds: set[int] = set()
+            launched_event: threading.Event | None = None
+
+            pidfile: Pidfile | None = None  # noqa
+            pidfile_manager: ta.ContextManager | None = None
+
+            if (pid_file := self._config.pid_file) is not None:
+                if not isinstance(spawner, InProcessSpawner):
+                    pidfile = es.enter_context(open_inheritable_pidfile(pid_file))
+                    pidfile_manager = lang.NopContextManager(pidfile)
+
+                else:
+                    check.state(not self._config.reparent_process)
+                    pidfile = es.enter_context(Pidfile(pid_file))
+                    pidfile_manager = pidfile.dup()
+                    launched_event = threading.Event()
+
+                if not pidfile.try_acquire_lock():
+                    return False
+
+                inherit_fds.add(check.isinstance(pidfile.fileno(), int))
+
+            #
+
+            spawner.spawn(Spawn(
+                functools.partial(
+                    self._inner_launch,
+                    pidfile_manager=pidfile_manager,
+                    launched_callback=launched_event.set if launched_event is not None else None,
+                ),
+                inherit_fds=inherit_fds,
+            ))
+
+            if launched_event is not None:
+                check.state(launched_event.wait(timeout=self._config.launched_timeout_s))
+
+            return True
+
+    #
+
+    def wait_sync(self, timeout: lang.TimeoutLike = lang.Timeout.Default) -> None:
+        if self._config.wait is None:
+            return
+
+        timeout = lang.Timeout.of(timeout, self._config.wait_timeout)
+        waiter = waiter_for(self._config.wait)
+        while not waiter.do_wait():
+            timeout()
+            time.sleep(self._config.wait_sleep_s or 0.)
+
+    #
+
+    class _NOT_SET(lang.Marker):  # noqa
+        pass
+
+    def launch(self, timeout: lang.TimeoutLike = lang.Timeout.Default) -> None:
+        self.launch_no_wait()
+
+        self.wait_sync(timeout)

omlish/daemons/reparent.py

@@ -0,0 +1,16 @@
+import os
+import sys
+
+
+def reparent_process() -> None:
+    if (pid := os.fork()):  # noqa
+        sys.exit(0)
+        raise RuntimeError('Unreachable')  # noqa
+
+    os.setsid()
+
+    if (pid := os.fork()):  # noqa
+        sys.exit(0)
+
+    sys.stdout.flush()
+    sys.stderr.flush()

omlish/daemons/spawning.py

@@ -0,0 +1,166 @@
+import abc
+import functools
+import os
+import sys
+import threading
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from ..diag import pydevd
+
+
+if ta.TYPE_CHECKING:
+    import multiprocessing as mp
+    import multiprocessing.context
+    import multiprocessing.process  # noqa
+
+    from ..multiprocessing import spawn as omp_spawn
+
+else:
+    mp = lang.proxy_import('multiprocessing', extras=['context', 'process'])
+    subprocess = lang.proxy_import('subprocess')
+
+    omp_spawn = lang.proxy_import('..multiprocessing.spawn', __package__)
+
+
+##
+
+
+class Spawning(dc.Case):
+    pass
+
+
+class Spawn(dc.Frozen, final=True):
+    fn: ta.Callable[[], None]
+
+    _: dc.KW_ONLY
+
+    inherit_fds: ta.Collection[int] | None = None
+
+
+class Spawner(lang.ContextManaged, abc.ABC):
+    @abc.abstractmethod
+    def spawn(self, spawn: Spawn) -> None:
+        raise NotImplementedError
+
+
+class InProcessSpawner(Spawner, abc.ABC):
+    pass
+
+
+@functools.singledispatch
+def spawner_for(spawning: Spawning) -> Spawner:
+    raise TypeError(spawning)
+
+
+##
+
+
+class MultiprocessingSpawning(Spawning, kw_only=True):
+    # Defaults to 'fork' if under pydevd, else 'spawn'
+    start_method: str | None = None
+
+    non_daemon: bool = False
+
+
+class MultiprocessingSpawner(Spawner):
+    def __init__(self, spawning: MultiprocessingSpawning) -> None:
+        super().__init__()
+
+        self._spawning = spawning
+        self._process: ta.Optional['mp.process.BaseProcess'] = None  # noqa
+
+    def _process_cls(self, spawn: Spawn) -> type['mp.process.BaseProcess']:
+        if (start_method := self._spawning.start_method) is None:
+            # Unfortunately, pydevd forces the use of the 'fork' start_method, which cannot be mixed with 'spawn':
+            #   https://github.com/python/cpython/blob/a7427f2db937adb4c787754deb4c337f1894fe86/Lib/multiprocessing/spawn.py#L102  # noqa
+            if pydevd.is_running():
+                start_method = 'fork'
+            else:
+                start_method = 'spawn'
+
+        ctx: 'mp.context.BaseContext'  # noqa
+        if start_method == 'fork':
+            ctx = mp.get_context(check.non_empty_str(start_method))
+
+        elif start_method == 'spawn':
+            ctx = omp_spawn.ExtrasSpawnContext(omp_spawn.SpawnExtras(
+                pass_fds=frozenset(spawn.inherit_fds) if spawn.inherit_fds is not None else None,
+            ))
+
+        else:
+            raise ValueError(start_method)
+
+        return ctx.Process  # type: ignore
+
+    def spawn(self, spawn: Spawn) -> None:
+        check.none(self._process)
+        self._process = self._process_cls(spawn)(
+            target=spawn.fn,
+            daemon=not self._spawning.non_daemon,
+        )
+        self._process.start()
+
+
+@spawner_for.register
+def _(spawning: MultiprocessingSpawning) -> MultiprocessingSpawner:
+    return MultiprocessingSpawner(spawning)
+
+
+##
+
+
+class ForkSpawning(Spawning):
+    pass
+
+
+class ForkSpawner(Spawner, dc.Frozen):
+    spawning: ForkSpawning
+
+    def spawn(self, spawn: Spawn) -> None:
+        if (pid := os.fork()):  # noqa
+            return
+
+        try:
+            spawn.fn()
+        except BaseException:  # noqa
+            sys.exit(1)
+        else:
+            sys.exit(0)
+
+        raise RuntimeError('Unreachable')  # noqa
+
+
+@spawner_for.register
+def _(spawning: ForkSpawning) -> ForkSpawner:
+    return ForkSpawner(spawning)
+
+
+##
+
+
+class ThreadSpawning(Spawning, kw_only=True):
+    non_daemon: bool = False
+
+
+class ThreadSpawner(InProcessSpawner):
+    def __init__(self, spawning: ThreadSpawning) -> None:
+        super().__init__()
+
+        self._spawning = spawning
+        self._thread: threading.Thread | None = None
+
+    def spawn(self, spawn: Spawn) -> None:
+        check.none(self._thread)
+        self._thread = threading.Thread(
+            target=spawn.fn,
+            daemon=not self._spawning.non_daemon,
+        )
+        self._thread.start()
+
+
+@spawner_for.register
+def _(spawning: ThreadSpawning) -> ThreadSpawner:
+    return ThreadSpawner(spawning)

omlish/daemons/targets.py

@@ -0,0 +1,89 @@
+import abc
+import functools
+import os
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import runpy
+else:
+    runpy = lang.proxy_import('runpy')
+
+
+##
+
+
+class Target(dc.Case):
+    pass
+
+
+class TargetRunner(abc.ABC):
+    @abc.abstractmethod
+    def run(self) -> None:
+        raise NotImplementedError
+
+
+@functools.singledispatch
+def target_runner_for(target: Target) -> TargetRunner:
+    raise TypeError(target)
+
+
+##
+
+
+class FnTarget(Target):
+    fn: ta.Callable[[], None]
+
+
+class FnTargetRunner(TargetRunner, dc.Frozen):
+    target: FnTarget
+
+    def run(self) -> None:
+        self.target.fn()
+
+
+@target_runner_for.register
+def _(target: FnTarget) -> FnTargetRunner:
+    return FnTargetRunner(target)
+
+
+##
+
+
+class NameTarget(Target):
+    name: str
+
+
+class NameTargetRunner(TargetRunner, dc.Frozen):
+    target: NameTarget
+
+    def run(self) -> None:
+        name = self.target.name
+        if lang.can_import(name):
+            runpy._run_module_as_main(name)  # type: ignore  # noqa
+        else:
+            obj = lang.import_attr(self.target.name)
+            obj()
+
+
+##
+
+
+class ExecTarget(Target):
+    cmd: ta.Sequence[str] = dc.xfield(coerce=check.of_not_isinstance(str))
+
+
+class ExecTargetRunner(TargetRunner, dc.Frozen):
+    target: ExecTarget
+
+    def run(self) -> None:
+        os.execl(*self.target.cmd)
+
+
+@target_runner_for.register
+def _(target: ExecTarget) -> ExecTargetRunner:
+    return ExecTargetRunner(target)

omlish/daemons/waiting.py

@@ -0,0 +1,95 @@
+import abc
+import functools
+import socket
+import typing as ta
+
+from .. import dataclasses as dc
+
+
+##
+
+
+class Wait(dc.Case):
+    pass
+
+
+class Waiter(abc.ABC):
+    @abc.abstractmethod
+    def do_wait(self) -> bool:
+        raise NotImplementedError
+
+
+@functools.singledispatch
+def waiter_for(wait: Wait) -> Waiter:
+    raise TypeError(wait)
+
+
+##
+
+
+class SequentialWait(Wait):
+    waits: ta.Sequence[Wait]
+
+
+class SequentialWaiter(Waiter):
+    def __init__(self, waiters: ta.Sequence[Waiter]) -> None:
+        super().__init__()
+
+        self._waiters = waiters
+        self._idx = 0
+
+    def do_wait(self) -> bool:
+        while self._idx < len(self._waiters):
+            if not self._waiters[self._idx].do_wait():
+                return False
+            self._idx += 1
+        return True
+
+
+@waiter_for.register
+def _(wait: SequentialWait) -> SequentialWaiter:
+    return SequentialWaiter([waiter_for(c) for c in wait.waits])
+
+
+##
+
+
+class FnWait(Wait):
+    fn: ta.Callable[[], bool]
+
+
+class FnWaiter(Waiter, dc.Frozen):
+    wait: FnWait
+
+    def do_wait(self) -> bool:
+        return self.wait.fn()
+
+
+@waiter_for.register
+def _(wait: FnWait) -> FnWaiter:
+    return FnWaiter(wait)
+
+
+##
+
+
+class ConnectWait(Wait):
+    address: ta.Any
+
+
+class ConnectWaiter(Waiter, dc.Frozen):
+    wait: ConnectWait
+
+    def do_wait(self) -> bool:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.connect(self.wait.address)
+            except ConnectionRefusedError:
+                return False
+            else:
+                return True
+
+
+@waiter_for.register
+def _(wait: ConnectWait) -> ConnectWaiter:
+    return ConnectWaiter(wait)

omlish/lang/__init__.py

@@ -61,9 +61,7 @@ from .contextmanagers import (  # noqa
     DefaultLockable,
     ExitStacked,
     Lockable,
-    NOP_CONTEXT_MANAGED,
     NOP_CONTEXT_MANAGER,
-    NopContextManaged,
     NopContextManager,
     Timer,
     a_defer,

omlish/lang/contextmanagers.py

@@ -18,6 +18,11 @@ T = ta.TypeVar('T')
 ##
 
 
+class _NOT_SET:  # noqa
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+
 class ContextManaged:
     def __enter__(self) -> ta.Self:
         return self
@@ -31,21 +36,21 @@ class ContextManaged:
         return None
 
 
-class NopContextManaged(ContextManaged):
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        raise TypeError
-
+class NopContextManager(ContextManaged):
+    def __init__(self, /, value: ta.Any = _NOT_SET) -> None:
+        super().__init__()
 
-NOP_CONTEXT_MANAGED = NopContextManaged()
+        self._value = value
 
+    def __enter__(self):
+        if (value := self._value) is _NOT_SET:
+            return self
+        else:
+            return value
 
-class NopContextManager:
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         raise TypeError
 
-    def __call__(self, *args, **kwargs):
-        return NOP_CONTEXT_MANAGED
-
 
 NOP_CONTEXT_MANAGER = NopContextManager()
 
@@ -350,7 +355,7 @@ def default_lock(value: DefaultLockable, default: DefaultLockable = None) -> Loc
         return lambda: lock
 
     elif value is False or value is None:
-        return NOP_CONTEXT_MANAGER
+        return lambda: NOP_CONTEXT_MANAGER
 
     elif callable(value):
         return value

omlish/libc.py

@@ -62,7 +62,6 @@ libc.free.argtypes = [ct.c_void_p]
 
 
 class Malloc:
-
     def __init__(self, sz: int) -> None:
         super().__init__()
 
@@ -174,7 +173,6 @@ if LINUX:
 
 
 class Mmap:
-
     def __init__(
             self,
             length: int,
@@ -537,14 +535,14 @@ elif DARWIN:
 
 
 if LINUX:
-    def gettid():
+    def gettid() -> int:
         syscalls = {
             'i386': 224,  # unistd_32.h: #define __NR_gettid 224
             'x86_64': 186,  # unistd_64.h: #define __NR_gettid 186
             'aarch64': 178,  # asm-generic/unistd.h: #define __NR_gettid 178
         }
         try:
-            tid = ct.CDLL('libc.so.6').syscall(syscalls[platform.machine()])
+            tid = libc.syscall(syscalls[platform.machine()])
         except Exception:  # noqa
             tid = -1
         return tid

omlish/lite/timeouts.py

@@ -8,7 +8,7 @@ import time
 import typing as ta
 
 
-TimeoutLike = ta.Union['Timeout', 'Timeout.Default', ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
+TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.Default'], ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
 
 
 ##

omlish/os/pidfiles/pidfile.py

@@ -56,8 +56,25 @@ class Pidfile:
 
     #
 
+    _fd_to_dup: int
+
+    def dup(self) -> 'Pidfile':
+        fd = self._f.fileno()
+        dup = Pidfile(
+            self._path,
+            inheritable=self._inheritable,
+        )
+        dup._fd_to_dup = fd  # noqa
+        return dup
+
+    #
+
     def __enter__(self) -> 'Pidfile':
-        fd = os.open(self._path, os.O_RDWR | os.O_CREAT, 0o600)
+        if hasattr(self, '_fd_to_dup'):
+            fd = os.dup(self._fd_to_dup)
+            del self._fd_to_dup
+        else:
+            fd = os.open(self._path, os.O_RDWR | os.O_CREAT, 0o600)
 
         try:
             if self._inheritable:

{omlish-0.0.0.dev230.dist-info → omlish-0.0.0.dev231.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev230
+Version: 0.0.0.dev231
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev230.dist-info → omlish-0.0.0.dev231.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=YGmAnUBszmosQQ_7Hh2wwtDiYdYZ4unNKYzOtALuels,7968
-omlish/__about__.py,sha256=5Ic1ejTV8SWSaVGgOg2_WDgpVTfT-KBLADFDeHHanA4,3380
+omlish/__about__.py,sha256=ZBkJyvFWxZFNvvD7zkGGThXCoE7JjItJdlIadSjnLho,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -7,7 +7,7 @@ omlish/check.py,sha256=THqm6jD1a0skAO5EC8SOVg58yq96Vk5wcuruBkCYxyU,2016
 omlish/datetimes.py,sha256=HajeM1kBvwlTa-uR1TTZHmZ3zTPnnUr1uGGQhiO1XQ0,2152
 omlish/defs.py,sha256=9uUjJuVIbCBL3g14fyzAp-9gH935MFofvlfOGwcBIaM,4913
 omlish/dynamic.py,sha256=kIZokHHid8a0pIAPXMNiXrVJvJJyBnY49WP1a2m-HUQ,6525
-omlish/libc.py,sha256=20YdP3Sh45d-c13OMV0Od6FEAIxqKvU3d5kCOIW9xCQ,15650
+omlish/libc.py,sha256=8K4c66YV1ziJerl5poAAYCmsV-VSsHkT3EHhPW04ufg,15639
 omlish/outcome.py,sha256=ABIE0zjjTyTNtn-ZqQ_9_mUzLiBQ3sDAyqc9JVD8N2k,7852
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
 omlish/shlex.py,sha256=bsW2XUD8GiMTUTDefJejZ5AyqT1pTgWMPD0BMoF02jE,248
@@ -175,6 +175,12 @@ omlish/configs/processing/matching.py,sha256=R64RxpPB1uX5Ztvvk2dQ2xi_xwlaxkxQgZw
 omlish/configs/processing/names.py,sha256=weHmaTclzgM9lUn3aBtw-kwZ3mc2N-CZlFg3Kd_UsKo,1093
 omlish/configs/processing/rewriting.py,sha256=v7PfHtuTn5v_5Y6Au7oMN2Z0nxAMy1iYyO5CXnTvZhs,4226
 omlish/configs/processing/strings.py,sha256=qFS2oh6z02IaM_q4lTKLdufzkJqAJ6J-Qjrz5S-QJoM,826
+omlish/daemons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/daemons/daemon.py,sha256=rK5T_ZbQPwwF-yLgS03fmJ0cZsVGSjTF5M4xSq_YiM0,5534
+omlish/daemons/reparent.py,sha256=UaG2X6VJHJPOlUwHPNRH3aWGgF0Fg771jjO9IRPLlyY,280
+omlish/daemons/spawning.py,sha256=cx00xeqSrfhlFbjCtKqaBHvMuHwB9hdjuKNHzAAo_dw,4030
+omlish/daemons/targets.py,sha256=scq6BYgzi0H2apfgD74U0D8_msQuYAel3Qiij74YWVo,1501
+omlish/daemons/waiting.py,sha256=RfgD1L33QQVbD2431dkKZGE4w6DUcGvYeRXXi8puAP4,1676
 omlish/dataclasses/__init__.py,sha256=D7I6ZJjEFeLN2re8oOZ_7JKWiG2plrPnaUFq3iEXYmQ,1553
 omlish/dataclasses/utils.py,sha256=N2seT8cJtfOv-41D7F3E-q4us-FCTQmnxxPv3dt1OcI,3796
 omlish/dataclasses/impl/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
@@ -385,11 +391,11 @@ omlish/iterators/iterators.py,sha256=ghI4dO6WPyyFOLTIIMaHQ_IOy2xXaFpGPqveZ5YGIBU
 omlish/iterators/recipes.py,sha256=53mkexitMhkwXQZbL6DrhpT0WePQ_56uXd5Jaw3DfzI,467
 omlish/iterators/tools.py,sha256=Pi4ybXytUXVZ3xwK89xpPImQfYYId9p1vIFQvVqVLqA,2551
 omlish/iterators/unique.py,sha256=0jAX3kwzVfRNhe0Tmh7kVP_Q2WBIn8POo_O-rgFV0rQ,1390
-omlish/lang/__init__.py,sha256=_DddR5PNgjqr51AB5DPUq0iKVqJrKz55WMJnBm97LL0,4127
+omlish/lang/__init__.py,sha256=bE8ra_QM5M4k8v3qFtreTjQswaZClIOaqXt9fE43MD0,4079
 omlish/lang/cached.py,sha256=tQaqMu1LID0q4NSTk5vPXsgxIBWSFAmjs5AhQoEHoCQ,7833
 omlish/lang/clsdct.py,sha256=sJYadm-fwzti-gsi98knR5qQUxriBmOqQE_qz3RopNk,1743
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
-omlish/lang/contextmanagers.py,sha256=V-XRwj1Em17Pr92i9mSYeeElQs9pmfM_B4jTF732qIg,10400
+omlish/lang/contextmanagers.py,sha256=Mrn8NJ3pP0Zxi-IoGqSjZDdWUctsyee2vrZ2FtZvNmo,10529
 omlish/lang/datetimes.py,sha256=ehI_DhQRM-bDxAavnp470XcekbbXc4Gdw9y1KpHDJT0,223
 omlish/lang/descriptors.py,sha256=njkYDS1gn5p4-3v1jr-s_srauC7tvvt571RjE7Q4LXE,6616
 omlish/lang/exceptions.py,sha256=qJBo3NU1mOWWm-NhQUHCY5feYXR3arZVyEHinLsmRH4,47
@@ -434,7 +440,7 @@ omlish/lite/resources.py,sha256=YNSmX1Ohck1aoWRs55a-o5ChVbFJIQhtbqE-XwF55Oc,326
 omlish/lite/runtime.py,sha256=XQo408zxTdJdppUZqOWHyeUR50VlCpNIExNGHz4U6O4,459
 omlish/lite/secrets.py,sha256=3Mz3V2jf__XU9qNHcH56sBSw95L3U2UPL24bjvobG0c,816
 omlish/lite/strings.py,sha256=QGxT1Yh4oI8ycsfeobxnjEhvDob_GiAKLeIhZwo1j24,1986
-omlish/lite/timeouts.py,sha256=wZ6PP1D3B8jpAI7-cQm7wkGTh2sE366XIn6FSMH6DZ4,4959
+omlish/lite/timeouts.py,sha256=lhXo0zwpLM7nr2-AliBRui2BO9jh7B8ALxetwOq6hYI,4968
 omlish/lite/timing.py,sha256=aVu3hEDB_jyTF_ryZI7iU-xg4q8CNwqpp9Apfru_iwY,196
 omlish/lite/types.py,sha256=fP5EMyBdEp2LmDxcHjUDtwAMdR06ISr9lKOL7smWfHM,140
 omlish/lite/typing.py,sha256=U3-JaEnkDSYxK4tsu_MzUn3RP6qALBe5FXQXpD-licE,1090
@@ -520,7 +526,7 @@ omlish/os/deathpacts/heartbeatfile.py,sha256=OybdvhM2kxBTuoJWOJJ5LcX-0lg3jTOvvD2
 omlish/os/deathpacts/pipe.py,sha256=ZH-l-fIKyurocCehqOgvaYRurxIEMWe8D7l2dsJeGws,3214
 omlish/os/pidfiles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/os/pidfiles/manager.py,sha256=qSEwNaWT1KOAnU0KxliwvU_uowme5jyf1FyIPsGwnTY,2391
-omlish/os/pidfiles/pidfile.py,sha256=WmZt_c8fvztPgZQnYHhcQCKWgHqAEsaI3Ggz6Wqgkc8,3748
+omlish/os/pidfiles/pidfile.py,sha256=wrttUQB7rk2SJ7MqtaRlqVGii5Kg6LWm3eV2auHb3zA,4125
 omlish/os/pidfiles/pinning.py,sha256=_AwYjJc1UGX7mdCOk4mItJJcsOJo3RW2ebBOm2noW5Y,6359
 omlish/reflect/__init__.py,sha256=Er2yBHibVO16hFNA1szQF2_f43Y3HRCBWtS-fjsOIYc,798
 omlish/reflect/inspect.py,sha256=WCo2YpBYauKw6k758FLlZ_H4Q05rgVPs96fEv9w6zHQ,1538
@@ -695,9 +701,9 @@ omlish/text/indent.py,sha256=YjtJEBYWuk8--b9JU_T6q4yxV85_TR7VEVr5ViRCFwk,1336
 omlish/text/minja.py,sha256=jZC-fp3Xuhx48ppqsf2Sf1pHbC0t8XBB7UpUUoOk2Qw,5751
 omlish/text/parts.py,sha256=JkNZpyR2tv2CNcTaWJJhpQ9E4F0yPR8P_YfDbZfMtwQ,6182
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev230.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev230.dist-info/METADATA,sha256=9A2Cqst8XnecLQcMoWK5ElLcgfKuHa_CQqsM5YCaeUc,4176
-omlish-0.0.0.dev230.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-omlish-0.0.0.dev230.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev230.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev230.dist-info/RECORD,,
+omlish-0.0.0.dev231.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev231.dist-info/METADATA,sha256=glvhjWJ8XJlRwe1JuGQQYJBpwdsJhjPFHEWn7Z985oE,4176
+omlish-0.0.0.dev231.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+omlish-0.0.0.dev231.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev231.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev231.dist-info/RECORD,,