omlish 0.0.0.dev225__py3-none-any.whl → 0.0.0.dev226__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev225'
-__revision__ = '99eb1740a6c8647c20c80278b6d0bedff0f7c103'
+__version__ = '0.0.0.dev226'
+__revision__ = '1f3419dac98e9db37df48a9a952f780d17bf31ed'
 
 
 #

omlish/asyncs/asyncio/subprocesses.py

@@ -10,6 +10,7 @@ import sys
 import typing as ta
 
 from ...lite.check import check
+from ...lite.timeouts import TimeoutLike
 from ...subprocesses.async_ import AbstractAsyncSubprocesses
 from ...subprocesses.run import SubprocessRun
 from ...subprocesses.run import SubprocessRunOutput
@@ -130,7 +131,7 @@ class AsyncioProcessCommunicator:
     async def communicate(
             self,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
     ) -> Communication:
         return await asyncio_maybe_timeout(self._communicate(input), timeout)
 
@@ -143,7 +144,7 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
             self,
             proc: asyncio.subprocess.Process,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
     ) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
         return await AsyncioProcessCommunicator(proc).communicate(input, timeout)  # noqa
 
@@ -154,7 +155,7 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
             self,
             *cmd: str,
             shell: bool = False,
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             **kwargs: ta.Any,
     ) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
         with self.prepare_and_wrap( *cmd, shell=shell, **kwargs) as (cmd, kwargs):  # noqa

omlish/asyncs/asyncio/timeouts.py

@@ -3,14 +3,17 @@
 import asyncio
 import typing as ta
 
+from ...lite.timeouts import Timeout
+from ...lite.timeouts import TimeoutLike
+
 
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
 
 def asyncio_maybe_timeout(
         fut: AwaitableT,
-        timeout: ta.Optional[float] = None,
+        timeout: ta.Optional[TimeoutLike] = None,
 ) -> AwaitableT:
     if timeout is not None:
-        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+        fut = asyncio.wait_for(fut, Timeout.of(timeout)())  # type: ignore
     return fut

omlish/diag/lslocks.py

@@ -0,0 +1,64 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+https://github.com/util-linux/util-linux/blob/a4436c7bf07f98a6381c7dfa2ab3f9a415f9c479/misc-utils/lslocks.c
+"""
+import dataclasses as dc
+import json
+import typing as ta
+
+from ..lite.check import check
+from ..lite.marshal import OBJ_MARSHALER_FIELD_KEY
+from ..lite.marshal import unmarshal_obj
+from ..subprocesses.run import SubprocessRun
+from ..subprocesses.run import SubprocessRunnable
+from ..subprocesses.run import SubprocessRunOutput
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class LsLocksItem:
+    """https://manpages.ubuntu.com/manpages/lunar/man8/lslocks.8.html"""
+
+    command: str
+    pid: int
+    type: str  # POSIX | FLOCK | OFDLCK
+    size: ta.Optional[int]
+    mode: str  # READ | WRITE
+    mandatory: bool = dc.field(metadata={OBJ_MARSHALER_FIELD_KEY: 'm'})
+    start: int
+    end: int
+    path: str
+    blocker: ta.Optional[int] = None
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class LsLocksCommand(SubprocessRunnable):
+    pid: ta.Optional[int] = None
+    no_inaccessible: bool = False
+
+    def make_run(self) -> SubprocessRun:
+        return SubprocessRun.of(
+            'lslocks',
+            '--json',
+            '--bytes',
+            '--notruncate',
+            *(['--pid', str(self.pid)] if self.pid is not None else []),
+            *(['--noinaccessible'] if self.no_inaccessible else []),
+
+            check=True,
+            stdout='pipe',
+            stderr='devnull',
+        )
+
+    def handle_run_output(self, output: SubprocessRunOutput) -> ta.List[LsLocksItem]:
+        buf = check.not_none(output.stdout).decode().strip()
+        if not buf:
+            return []
+        obj = json.loads(buf)
+        return unmarshal_obj(obj['locks'], ta.List[LsLocksItem])

omlish/diag/lsof.py

@@ -0,0 +1,264 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+https://man7.org/linux/man-pages/man8/lsof.8.html
+
+Included in the process set are fields that identify the command, the process group IDentification (PGID) number, the
+task (thread) ID (TID), and the user ID (UID) number or login name.
+"""
+import dataclasses as dc
+import enum
+import typing as ta
+
+from ..lite.check import check
+from ..lite.dataclasses import dataclass_repr_omit_falsey
+from ..lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
+from ..subprocesses.run import SubprocessRun
+from ..subprocesses.run import SubprocessRunnable
+from ..subprocesses.run import SubprocessRunOutput
+
+
+##
+
+
+# FIXME: ??
+# https://unix.stackexchange.com/a/86011
+class LsofItemMode(enum.Enum):
+    SOLARIS_NFS_LOCK = 'N'
+    READ_LOCK_PARTIAL = 'r'
+    READ_LOCK_FULL = 'R'
+    WRITE_LOCK_PARTIAL = 'w'
+    WRITE_LOCK_FULL = 'W'
+    READ_WRITE_LOCK = 'u'
+    UNKNOWN_LOCK_TYPE = 'U'
+    XENIX_LOCK_PARTIAL = 'x'
+    XENIX_LOCK_FULL = 'X'
+
+
+@dc.dataclass(frozen=True)
+class _LsofFieldMeta:
+    prefix: str
+    process: bool = False
+    variadic: bool = False
+
+    @classmethod
+    def make(cls, *args, **kwargs):
+        return {
+            cls: cls(*args, **kwargs),
+            OBJ_MARSHALER_OMIT_IF_NONE: True,
+        }
+
+
+@dc.dataclass(frozen=True)
+class LsofItem:
+    __repr__ = dataclass_repr_omit_falsey
+
+    class _PREFIX:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    class _PROCESS:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    pid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('p', process=True))
+    pgid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('g', process=True))
+    ppid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('R', process=True))
+    cmd: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('c', process=True))
+
+    uid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('u', process=True))
+    login_name: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('L', process=True))
+
+    # FD is the File Descriptor number of the file or:
+    #   cwd  current working directory;
+    #   Lnn  library references (AIX);
+    #   ctty character tty;
+    #   DEL  deleted file;
+    #   err  FD information error (see NAME column);
+    #   fp.  Fileport (Darwin);
+    #   jld  jail directory (FreeBSD);
+    #   ltx  shared library text (code and data);
+    #   Mxx  hex memory-mapped type number xx.
+    #   m86  DOS Merge mapped file;
+    #   mem  memory-mapped file;
+    #   mmap memory-mapped device;
+    #   NOFD for a Linux /proc/<PID>/fd directory that can't be opened -- the directory path appears in the NAME column,
+    #     followed by an error message;
+    #   pd   parent directory;
+    #   Rnn  unknown pregion number (HP-UX);
+    #   rtd  root directory;
+    #   twd  per task current working directory;
+    #   txt  program text (code and data);
+    #   v86  VP/ix mapped file;
+    #
+    # FD is followed by one of these characters, describing the mode under which the file is open:
+    #   r for read access;
+    #   w for write access;
+    #   u for read and write access;
+    #   space if mode unknown and no lock
+    #   character follows;
+    #   `-' if mode unknown and lock
+    #   character follows.
+    #
+    # The mode character is followed by one of these lock characters, describing the type of lock applied to the file:
+    #   N for a Solaris NFS lock of unknown type;
+    #   r for read lock on part of the file;
+    #   R for a read lock on the entire file;
+    #   w for a write lock on part of the file;
+    #   W for a write lock on the entire file;
+    #   u for a read and write lock of any length;
+    #   U for a lock of unknown type;
+    #   x for an SCO OpenServer Xenix lock on part of the file;
+    #   X for an SCO OpenServer Xenix lock on the entire file;
+    #   space if there is no lock.
+    #
+    fd: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('f'))
+
+    inode: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('i'))
+    name: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('n'))
+
+    # r = read; w = write; u = read/write
+    access: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('a'))
+
+    # r/R = read; w/W = write; u = read/write
+    lock: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('l'))
+
+    file_flags: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('G'))
+    file_type: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('t'))
+    file_size: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('s'))
+    file_offset: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('o'))  # as 0t<dec> or 0x<hex>
+
+    device_character_code: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('d'))
+    device_number: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('D'))  # as 0x<hex>
+    raw_device_number: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('r'))  # as 0x<hex>
+
+    share_count: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('C'))
+    link_count: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('k'))
+
+    stream_info: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('S'))
+    protocol_name: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('P'))
+
+    tcp_tpi_info: ta.Optional[ta.Sequence[str]] = dc.field(
+        default=None,
+        metadata=_LsofFieldMeta.make('T', variadic=True),
+    )
+
+    # 'K':  'task_id',  # unknown field
+    # 'M':  'task_command_name',  # unknown field
+
+    _FIELDS_BY_PREFIX: ta.ClassVar[ta.Mapping[str, dc.Field]]
+    _DEFAULT_PREFIXES: ta.ClassVar[str]
+
+    @classmethod
+    def from_prefixes(cls, dct: ta.Mapping[str, ta.Any]) -> 'LsofItem':
+        print(dct)
+        kw: ta.Dict[str, ta.Any] = {
+            fld.name: val
+            for pfx, val in dct.items()
+            if (fld := cls._FIELDS_BY_PREFIX.get(pfx)) is not None
+        }
+
+        return cls(**kw)
+
+    @classmethod
+    def from_prefix_lines(cls, lines: ta.Iterable[str]) -> ta.List['LsofItem']:
+        proc_dct: ta.Dict[str, ta.Any] = {}
+        file_dct: ta.Dict[str, ta.Any] = {}
+        out: ta.List[LsofItem] = []
+
+        def emit() -> None:
+            if file_dct:
+                out.append(cls.from_prefixes({**proc_dct, **file_dct}))
+
+        for line in lines:
+            pfx, val = line[0], line[1:]
+            try:
+                fld = cls._FIELDS_BY_PREFIX[pfx]
+            except KeyError:
+                continue
+            meta: _LsofFieldMeta = fld.metadata[_LsofFieldMeta]
+
+            if pfx == 'p':
+                emit()
+                proc_dct = {}
+                file_dct = {}
+            elif pfx == 'f':
+                emit()
+                file_dct = {}
+
+            if meta.process:
+                dct = proc_dct
+            else:
+                dct = file_dct
+
+            if meta.variadic:
+                dct.setdefault(pfx, []).append(val)
+            else:
+                if pfx in dct:
+                    raise KeyError(pfx)
+                dct[pfx] = val
+
+        emit()
+
+        return out
+
+
+LsofItem._FIELDS_BY_PREFIX = {  # noqa
+    meta.prefix: fld
+    for fld in dc.fields(LsofItem)  # noqa
+    if (meta := fld.metadata.get(_LsofFieldMeta)) is not None  # noqa
+}
+
+LsofItem._DEFAULT_PREFIXES = ''.join(LsofItem._FIELDS_BY_PREFIX)  # noqa
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class LsofCommand(SubprocessRunnable[ta.List[LsofItem]]):
+    pid: ta.Optional[int] = None
+    file: ta.Optional[str] = None
+
+    prefixes: ta.Optional[ta.Sequence[str]] = None
+
+    def make_run(self) -> SubprocessRun:
+        if (prefixes := self.prefixes) is None:
+            prefixes = LsofItem._DEFAULT_PREFIXES  # noqa
+
+        return SubprocessRun.of(
+            'lsof',
+            '-F', ''.join(prefixes),
+            *(['-p', str(self.pid)] if self.pid is not None else []),
+            *([self.file] if self.file is not None else []),
+
+            stdout='pipe',
+            stderr='devnull',
+            check=True,
+        )
+
+    def handle_run_output(self, output: SubprocessRunOutput) -> ta.List[LsofItem]:
+        lines = [s for l in check.not_none(output.stdout).decode().splitlines() if (s := l.strip())]
+        return LsofItem.from_prefix_lines(lines)
+
+
+if __name__ == '__main__':
+    def _main() -> None:
+        argparse = __import__('argparse')
+        parser = argparse.ArgumentParser()
+        parser.add_argument('--pid', '-p', type=int)
+        parser.add_argument('file', nargs='?')
+        args = parser.parse_args()
+
+        importlib = __import__('importlib')
+        subprocesses = importlib.import_module('..subprocesses.sync', package=__package__).subprocesses
+        items = LsofCommand(
+            pid=args.pid,
+            file=args.file,
+        ).run(subprocesses)
+
+        json = __import__('json')
+        marshal_obj = importlib.import_module('..lite.marshal', package=__package__).marshal_obj
+        print(json.dumps(marshal_obj(items), indent=2))
+
+    _main()

omlish/diag/ps.py

@@ -1,8 +1,15 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import os
-import subprocess
+import typing as ta
 
-from .. import lang
+from ..lite.check import check
+from ..lite.timeouts import Timeout
+from ..subprocesses.run import SubprocessRun
+from ..subprocesses.run import SubprocessRunnable
+from ..subprocesses.run import SubprocessRunOutput
+from ..subprocesses.sync import subprocesses
 
 
 @dc.dataclass(frozen=True)
@@ -12,23 +19,36 @@ class PsItem:
     cmd: str
 
 
-def get_ps_item(pid: int, timeout: lang.Timeout | None = None) -> PsItem:
-    timeout = lang.timeout(timeout)
-    out = subprocess.check_output(
-        ['ps', '-o', 'pid=,ppid=,command=', str(int(pid))],
-        timeout=timeout.or_(None),
-    ).decode().strip()
-    opid, _, rest = out.partition(' ')
-    ppid, _, cmd = rest.strip().partition(' ')
-    return PsItem(
-        int(opid),
-        int(ppid),
-        cmd.strip(),
-    )
+@dc.dataclass(frozen=True)
+class PsCommand(SubprocessRunnable):
+    pid: ta.Optional[int] = None
+
+    def make_run(self) -> SubprocessRun:
+        return SubprocessRun.of(
+            'ps',
+            '-o', 'pid=,ppid=,command=',
+            *([str(int(self.pid))] if self.pid is not None else []),
+
+            check=True,
+            stdout='pipe',
+            stderr='devnull',
+        )
+
+    def handle_run_output(self, output: SubprocessRunOutput) -> PsItem:
+        opid, ppid, cmd = check.not_none(output.stdout).decode().split(maxsplit=2)
+        return PsItem(
+            int(opid),
+            int(ppid),
+            cmd.strip(),
+        )
+
 
+def get_ps_item(pid: int, timeout: ta.Optional[Timeout] = None) -> PsItem:
+    return PsCommand(pid).run(subprocesses, timeout=timeout)
 
-def get_ps_lineage(pid: int, timeout: lang.Timeout | None = None) -> list[PsItem]:
-    timeout = lang.timeout(timeout)
+
+def get_ps_lineage(pid: int, timeout: ta.Optional[Timeout] = None) -> ta.List[PsItem]:
+    timeout = Timeout.of(timeout)
     ret: list[PsItem] = []
     while True:
         cur = get_ps_item(pid, timeout)
@@ -39,9 +59,8 @@ def get_ps_lineage(pid: int, timeout: lang.Timeout | None = None) -> list[PsItem
     return ret
 
 
-def _main() -> None:
-    print(get_ps_lineage(os.getpid()))
-
-
 if __name__ == '__main__':
+    def _main() -> None:
+        print(get_ps_lineage(os.getpid()))
+
     _main()

omlish/lang/__init__.py

@@ -226,14 +226,6 @@ from .sys import (  # noqa
     is_gil_enabled,
 )
 
-from .timeouts import (  # noqa
-    DeadlineTimeout,
-    InfiniteTimeout,
-    Timeout,
-    TimeoutLike,
-    timeout,
-)
-
 from .typing import (  # noqa
     BytesLike,
     SequenceNotStr,
@@ -244,6 +236,13 @@ from .typing import (  # noqa
 
 ##
 
+from ..lite.timeouts import (  # noqa
+    DeadlineTimeout,
+    InfiniteTimeout,
+    Timeout,
+    TimeoutLike,
+)
+
 from ..lite.types import (  # noqa
     BUILTIN_SCALAR_ITERABLE_TYPES,
 )

omlish/lite/dataclasses.py

@@ -42,3 +42,26 @@ def dataclass_maybe_post_init(sup: ta.Any) -> bool:
         return False
     fn()
     return True
+
+
+def dataclass_repr_filtered(
+        obj: ta.Any,
+        fn: ta.Callable[[ta.Any, dc.Field, ta.Any], bool],
+) -> str:
+    return (
+        f'{obj.__class__.__qualname__}(' +
+        ', '.join([
+            f'{f.name}={v!r}'
+            for f in dc.fields(obj)
+            if fn(obj, f, v := getattr(obj, f.name))
+        ]) +
+        ')'
+    )
+
+
+def dataclass_repr_omit_none(obj: ta.Any) -> str:
+    return dataclass_repr_filtered(obj, lambda o, f, v: v is not None)
+
+
+def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
+    return dataclass_repr_filtered(obj, lambda o, f, v: bool(v))

omlish/lite/timeouts.py

@@ -0,0 +1,202 @@
+# ruff: noqa: UP006 UP007
+"""
+TODO:
+ - Event (/ Predicate)
+"""
+import abc
+import time
+import typing as ta
+
+
+TimeoutLike = ta.Union['Timeout', 'Timeout.Default', ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
+
+
+##
+
+
+class Timeout(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def can_expire(self) -> bool:
+        """Indicates whether or not this timeout will ever expire."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def expired(self) -> bool:
+        """Return whether or not this timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def remaining(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires. May be negative and/or infinite."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __call__(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires, or raises if the timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_(self, o: ta.Any) -> ta.Any:
+        """Evaluates time remaining via remaining() if this timeout can expire, otherwise returns `o`."""
+
+        raise NotImplementedError
+
+    #
+
+    @classmethod
+    def _now(cls) -> float:
+        return time.time()
+
+    #
+
+    class Default:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    class _NOT_SPECIFIED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    @classmethod
+    def of(
+            cls,
+            obj: ta.Optional[TimeoutLike],
+            default: ta.Union[TimeoutLike, ta.Type[_NOT_SPECIFIED]] = _NOT_SPECIFIED,
+    ) -> 'Timeout':
+        if obj is None:
+            return InfiniteTimeout()
+
+        elif isinstance(obj, Timeout):
+            return obj
+
+        elif isinstance(obj, (float, int)):
+            return DeadlineTimeout(cls._now() + obj)
+
+        elif isinstance(obj, ta.Iterable):
+            return CompositeTimeout(*[Timeout.of(c) for c in obj])
+
+        elif obj is Timeout.Default:
+            if default is Timeout._NOT_SPECIFIED or default is Timeout.Default:
+                raise RuntimeError('Must specify a default timeout')
+
+            else:
+                return Timeout.of(default)  # type: ignore[arg-type]
+
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def of_deadline(cls, deadline: float) -> 'DeadlineTimeout':
+        return DeadlineTimeout(deadline)
+
+    @classmethod
+    def of_predicate(cls, expired_fn: ta.Callable[[], bool]) -> 'PredicateTimeout':
+        return PredicateTimeout(expired_fn)
+
+
+class DeadlineTimeout(Timeout):
+    def __init__(
+            self,
+            deadline: float,
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.deadline = deadline
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return not (self.remaining() > 0)
+
+    def remaining(self) -> float:
+        return self.deadline - self._now()
+
+    def __call__(self) -> float:
+        if (rem := self.remaining()) > 0:
+            return rem
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()
+
+
+class InfiniteTimeout(Timeout):
+    @property
+    def can_expire(self) -> bool:
+        return False
+
+    def expired(self) -> bool:
+        return False
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        return float('inf')
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return o
+
+
+class CompositeTimeout(Timeout):
+    def __init__(self, *children: Timeout) -> None:
+        super().__init__()
+
+        self.children = children
+
+    @property
+    def can_expire(self) -> bool:
+        return any(c.can_expire for c in self.children)
+
+    def expired(self) -> bool:
+        return any(c.expired() for c in self.children)
+
+    def remaining(self) -> float:
+        return min(c.remaining() for c in self.children)
+
+    def __call__(self) -> float:
+        return min(c() for c in self.children)
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        if self.can_expire:
+            return self()
+        return o
+
+
+class PredicateTimeout(Timeout):
+    def __init__(
+            self,
+            expired_fn: ta.Callable[[], bool],
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.expired_fn = expired_fn
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return self.expired_fn()
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        if not self.expired_fn():
+            return float('inf')
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()

omlish/os/fcntl.py

@@ -0,0 +1,59 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import dataclasses as dc
+import os
+import struct
+import sys
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class FcntlLockData:
+    # cmd = {F_SETLK, F_SETLKW, F_GETLK}
+
+    type: int  # {F_RDLCK, F_WRLCK, F_UNLCK}
+    whence: int = os.SEEK_SET
+    start: int = 0
+    len: int = 0
+    pid: int = 0
+
+    #
+
+    _STRUCT_PACK_BY_PLATFORM: ta.ClassVar[ta.Mapping[str, ta.Sequence[ta.Tuple[str, str]]]] = {
+        'linux': [
+            ('type', 'h'),
+            ('whence', 'h'),
+            ('start', 'q'),
+            ('len', 'q'),
+            ('pid', 'i'),
+        ],
+        'darwin': [
+            ('start', 'q'),
+            ('len', 'q'),
+            ('pid', 'i'),
+            ('type', 'h'),
+            ('whence', 'h'),
+        ],
+    }
+
+    def pack(self) -> bytes:
+        try:
+            pack = self._STRUCT_PACK_BY_PLATFORM[sys.platform]
+        except KeyError:
+            raise OSError from None
+
+        fmt = ''.join(f for _, f in pack)
+        tup = [getattr(self, a) for a, _ in pack]
+        return struct.pack(fmt, *tup)
+
+    @classmethod
+    def unpack(cls, data: bytes) -> 'FcntlLockData':
+        try:
+            pack = cls._STRUCT_PACK_BY_PLATFORM[sys.platform]
+        except KeyError:
+            raise OSError from None
+
+        fmt = ''.join(f for _, f in pack)
+        tup = struct.unpack(fmt, data)
+        kw = {a: v for (a, _), v in zip(pack, tup)}
+        return FcntlLockData(**kw)

omlish/os/pidfiles/manager.py

@@ -14,6 +14,14 @@ from .pidfile import Pidfile
 
 
 class _PidfileManager:
+    """
+    Manager for controlled inheritance of Pidfiles across forks.
+
+    Not implemented as an instantiated class as there is no way to unregister at_fork listeners, and because Pidfiles
+    may be pickled and there must be no possibility of accidentally unpickling and instantiating a new instance of the
+    manager.
+    """
+
     def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError
 
@@ -71,6 +79,11 @@ class _PidfileManager:
             inheritable: bool = True,
             **kwargs: ta.Any,
     ) -> ta.Iterator[Pidfile]:
+        """
+        A contextmanager for creating and managing a Pidfile which will only be inherited by forks of the calling /
+        creating thread.
+        """
+
         check.arg(inheritable)
 
         cls.install()
@@ -84,6 +97,7 @@ class _PidfileManager:
         with cls._lock:
             cls._pidfile_threads[pf] = threading.current_thread()
         try:
+
             with pf:
                 os.set_inheritable(check.not_none(pf.fileno()), True)
                 yield pf

omlish/os/pidfiles/pidfile.py

@@ -10,6 +10,7 @@ TODO:
    - 3) recheck current pid of flock holder == that pid
   - racy as to if it's a different actual process as initial check, just with same pid, but due to 'identity' / semantic
     meaning of the named pidfile the processes are considered equivalent
+  - read_checked(), contextmanager
 """
 import fcntl
 import os
@@ -32,6 +33,14 @@ class Pidfile:
         self._path = path
         self._inheritable = inheritable
 
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @property
+    def inheritable(self) -> bool:
+        return self._inheritable
+
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({self._path!r})'
 
@@ -75,6 +84,7 @@ class Pidfile:
         state = self.__dict__.copy()
 
         if '_f' in state:
+            # self._inheritable may be decoupled from actual file inheritability - for example when using the manager.
             if os.get_inheritable(fd := state.pop('_f').fileno()):
                 state['__fd'] = fd
 
@@ -135,8 +145,8 @@ class Pidfile:
             raise RuntimeError('Got lock')
 
         self._f.seek(0)
-        return int(self._f.read())  # FIXME: could be empty or hold old value, race w proc start
+        return int(self._f.read())
 
     def kill(self, sig: int = signal.SIGTERM) -> None:
         pid = self.read()
-        os.kill(pid, sig)  # FIXME: Still racy - pidfd_send_signal?
+        os.kill(pid, sig)

omlish/subprocesses/async_.py

@@ -4,6 +4,7 @@ import abc
 import sys
 import typing as ta
 
+from ..lite.timeouts import TimeoutLike
 from .base import BaseSubprocesses
 from .run import SubprocessRun
 from .run import SubprocessRunOutput
@@ -21,7 +22,7 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             self,
             *cmd: str,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             check: bool = False,
             capture_output: ta.Optional[bool] = None,
             **kwargs: ta.Any,

omlish/subprocesses/base.py

@@ -8,6 +8,7 @@ import subprocess
 import time
 import typing as ta
 
+from ..lite.timeouts import Timeout
 from .wrap import subprocess_maybe_shell_wrap_exec
 
 
@@ -111,6 +112,11 @@ class BaseSubprocesses(abc.ABC):  # noqa
 
         #
 
+        if 'timeout' in kwargs:
+            kwargs['timeout'] = Timeout.of(kwargs['timeout']).or_(None)
+
+        #
+
         return cmd, dict(
             env=env,
             shell=shell,

omlish/subprocesses/run.py

@@ -5,6 +5,7 @@ import dataclasses as dc
 import typing as ta
 
 from ..lite.check import check
+from ..lite.timeouts import TimeoutLike
 
 
 T = ta.TypeVar('T')
@@ -30,17 +31,43 @@ class SubprocessRunOutput(ta.Generic[T]):
 class SubprocessRun:
     cmd: ta.Sequence[str]
     input: ta.Any = None
-    timeout: ta.Optional[float] = None
+    timeout: ta.Optional[TimeoutLike] = None
     check: bool = False
     capture_output: ta.Optional[bool] = None
     kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None
 
+    #
+
+    _FIELD_NAMES: ta.ClassVar[ta.FrozenSet[str]]
+
+    def replace(self, **kwargs: ta.Any) -> 'SubprocessRun':
+        if not kwargs:
+            return self
+
+        field_kws = {}
+        extra_kws = {}
+        for k, v in kwargs.items():
+            if k in self._FIELD_NAMES:
+                field_kws[k] = v
+            else:
+                extra_kws[k] = v
+
+        return dc.replace(self, **{
+            **dict(kwargs={
+                **(self.kwargs or {}),
+                **extra_kws,
+            }),
+            **field_kws,  # passing a kwarg named 'kwargs' intentionally clobbers
+        })
+
+    #
+
     @classmethod
     def of(
             cls,
             *cmd: str,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             check: bool = False,  # noqa
             capture_output: ta.Optional[bool] = None,
             **kwargs: ta.Any,
@@ -61,20 +88,25 @@ class SubprocessRun:
     def run(
             self,
             subprocesses: ta.Optional[ta.Any] = None,  # AbstractSubprocesses
+            **kwargs: ta.Any,
     ) -> SubprocessRunOutput:
         if subprocesses is None:
             subprocesses = self._DEFAULT_SUBPROCESSES
-        return check.not_none(subprocesses).run_(self)  # type: ignore[attr-defined]
+        return check.not_none(subprocesses).run_(self.replace(**kwargs))  # type: ignore[attr-defined]
 
     _DEFAULT_ASYNC_SUBPROCESSES: ta.ClassVar[ta.Optional[ta.Any]] = None  # AbstractAsyncSubprocesses
 
     async def async_run(
             self,
             async_subprocesses: ta.Optional[ta.Any] = None,  # AbstractAsyncSubprocesses
+            **kwargs: ta.Any,
     ) -> SubprocessRunOutput:
         if async_subprocesses is None:
             async_subprocesses = self._DEFAULT_ASYNC_SUBPROCESSES
-        return await check.not_none(async_subprocesses).run_(self)  # type: ignore[attr-defined]
+        return await check.not_none(async_subprocesses).run_(self.replace(**kwargs))  # type: ignore[attr-defined]
+
+
+SubprocessRun._FIELD_NAMES = frozenset(fld.name for fld in dc.fields(SubprocessRun))  # noqa
 
 
 ##
@@ -91,8 +123,16 @@ class SubprocessRunnable(abc.ABC, ta.Generic[T]):
 
     #
 
-    def run(self, subprocesses: ta.Optional[ta.Any] = None) -> T:  # AbstractSubprocesses
-        return self.handle_run_output(self.make_run().run(subprocesses))
+    def run(
+            self,
+            subprocesses: ta.Optional[ta.Any] = None,  # AbstractSubprocesses
+            **kwargs: ta.Any,
+    ) -> T:
+        return self.handle_run_output(self.make_run().run(subprocesses, **kwargs))
 
-    async def async_run(self, async_subprocesses: ta.Optional[ta.Any] = None) -> T:  # AbstractAsyncSubprocesses
-        return self.handle_run_output(await self.make_run().async_run(async_subprocesses))
+    async def async_run(
+            self,
+            async_subprocesses: ta.Optional[ta.Any] = None,  # AbstractAsyncSubprocesses
+            **kwargs: ta.Any,
+    ) -> T:
+        return self.handle_run_output(await self.make_run().async_run(async_subprocesses, **kwargs))

omlish/subprocesses/sync.py

@@ -1,10 +1,16 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
+"""
+TODO:
+ - popen
+ - route check_calls through run_?
+"""
 import abc
 import subprocess
 import sys
 import typing as ta
 
+from ..lite.timeouts import TimeoutLike
 from .base import BaseSubprocesses
 from .run import SubprocessRun
 from .run import SubprocessRunOutput
@@ -22,7 +28,7 @@ class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
             self,
             *cmd: str,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             check: bool = False,
             capture_output: ta.Optional[bool] = None,
             **kwargs: ta.Any,

{omlish-0.0.0.dev225.dist-info → omlish-0.0.0.dev226.dist-info}/METADATA

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

{omlish-0.0.0.dev225.dist-info → omlish-0.0.0.dev226.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=YGmAnUBszmosQQ_7Hh2wwtDiYdYZ4unNKYzOtALuels,7968
-omlish/__about__.py,sha256=gehJaunJejmNajD_3gJSN6_vRuZdXjgTLUMaCAxAmJA,3380
+omlish/__about__.py,sha256=QR1QmjxqAJ538XauJdEuHH505rJ9QF67p3blNgi6kwc,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -101,8 +101,8 @@ omlish/asyncs/asyncio/all.py,sha256=KpTanEtpTlc3rqv5SyiJaJGb_DXBzp_WKLhlRq6lrhY,
 omlish/asyncs/asyncio/asyncio.py,sha256=3BMhVIF-QTjsFRGDtNYlRbBqKPCA3_AwJsjJoIWdM8k,1783
 omlish/asyncs/asyncio/channels.py,sha256=ZbmsEmdK1fV96liHdcVpRqA2dAMkXJt4Q3rFAg3YOIw,1074
 omlish/asyncs/asyncio/streams.py,sha256=Uc9PCWSfBqrK2kdVtfjjQU1eaYTWYmZm8QISDj2xiuw,1004
-omlish/asyncs/asyncio/subprocesses.py,sha256=0NXHmCXeONwOiJlPfWop6WPfSiQH_keiyHT_pnfZm7U,6872
-omlish/asyncs/asyncio/timeouts.py,sha256=Rj5OU9BIAPcVZZKp74z7SzUXF5xokh4dgsWkUqOy1aE,355
+omlish/asyncs/asyncio/subprocesses.py,sha256=f30-wi-3n9R5dftm4CMrzp23EEa4GX283bORixm1_UU,6931
+omlish/asyncs/asyncio/timeouts.py,sha256=hokhi7jZSAtBv0ME3qL1cO5eshNA9ViEH7BLafNCBpQ,454
 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
@@ -203,9 +203,11 @@ omlish/dataclasses/impl/utils.py,sha256=aER2iL3UAtgS1BdLuEvTr9Tr2wC28wk1kiOeO-jI
 omlish/diag/__init__.py,sha256=4S8v0myJM4Zld6_FV6cPe_nSv0aJb6kXftEit0HkiGE,1141
 omlish/diag/asts.py,sha256=BveUUNUcaAm4Hg55f4ZxGSI313E4L8cCZ5XjHpEkKVI,3325
 omlish/diag/debug.py,sha256=ClED7kKXeVMyKrjGIxcq14kXk9kvUJfytBQwK9y7c4Q,1637
+omlish/diag/lslocks.py,sha256=7I_u-Vx0Dz0KN59Y6dk9nBZynHa6usvKIXVSywGCiWE,1722
+omlish/diag/lsof.py,sha256=gMtNmfBo1AlYmvZWBB51u4NfbfC6yJyEVwfr1HgktP8,9328
 omlish/diag/procfs.py,sha256=KaGTAA2Gj8eEEp7MjClRe4aimwzd-HDABThFzvq2cBQ,9684
 omlish/diag/procstats.py,sha256=UkqxREqfd-38xPYZ9T1SIJISz5ARQCEhTtOZrxtm2dE,777
-omlish/diag/ps.py,sha256=1JWxZen3fVG-20R6ZZ8BtO_gpzw_5bhHZiKdoHkgxoU,1004
+omlish/diag/ps.py,sha256=mwraPO6Nze_2r9RiC4dyLL0aJ_lHR1_fSN9BlYNBoHw,1651
 omlish/diag/pycharm.py,sha256=7-r_F-whXt8v-0dehxAX-MeMFPM3iZXX9IfeL0GfUtk,4643
 omlish/diag/pydevd.py,sha256=UN55ZjkWLCVyHxE2CNRRYamuvSKfzWsn0D5oczRTXO4,7536
 omlish/diag/threads.py,sha256=1-x02VCDZ407gfbtXm1pWK-ubqhqfePm9PMqkHCVoqk,3642
@@ -382,7 +384,7 @@ 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=9H6fElLMlA5MwT3tIW2CpojG5chn-hAvKW9tuA8REDQ,4134
+omlish/lang/__init__.py,sha256=_DddR5PNgjqr51AB5DPUq0iKVqJrKz55WMJnBm97LL0,4127
 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
@@ -400,7 +402,6 @@ omlish/lang/resolving.py,sha256=OuN2mDTPNyBUbcrswtvFKtj4xgH4H4WglgqSKv3MTy0,1606
 omlish/lang/resources.py,sha256=N64KeVE-rYMxqBBRp91qzgVqpOVR2uX7k1WlS_bo5hM,2681
 omlish/lang/strings.py,sha256=egdv8PxLNG40-5V93agP5j2rBUDIsahCx048zV7uEbU,4690
 omlish/lang/sys.py,sha256=UoZz_PJYVKLQAKqYxxn-LHz1okK_38I__maZgnXMcxU,406
-omlish/lang/timeouts.py,sha256=vECdWYhc_IZgcal1Ng1Y42wf2FV3KAx-i8As-MgGHIQ,1186
 omlish/lang/typing.py,sha256=Zdad9Zv0sa-hIaUXPrzPidT7sDVpRcussAI7D-j-I1c,3296
 omlish/lang/classes/__init__.py,sha256=HY9UD3Tg8_sH59emZUKgP1Kb8-8r0GCw5hUOumxwKlM,658
 omlish/lang/classes/abstract.py,sha256=bIcuAetV_aChhpSURypmjjcqP07xi20uVYPKh1kvQNU,3710
@@ -420,7 +421,7 @@ omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 omlish/lite/check.py,sha256=OLwtE2x6nlbGx4vS3Rda7zMHpgqzDSLJminTAX2lqLA,13529
 omlish/lite/configs.py,sha256=Ev_19sbII67pTWzInYjYqa9VyTiZBvyjhZqyG8TtufE,908
 omlish/lite/contextmanagers.py,sha256=ciaMl0D3QDHToM7M28-kwZ-Q48LtwgCxiud3nekgutA,2863
-omlish/lite/dataclasses.py,sha256=k1588egoF3h_Kb21tuQb8WyJ9wxhT06EztFvaKOHzNU,1115
+omlish/lite/dataclasses.py,sha256=sjJnZ4tZXMzKRkr-gymMbhuMxJAY8parJ_sopEqBc6M,1704
 omlish/lite/inject.py,sha256=qBUftFeXMiRgANYbNS2e7TePMYyFAcuLgsJiLyMTW5o,28769
 omlish/lite/json.py,sha256=7-02Ny4fq-6YAu5ynvqoijhuYXWpLmfCI19GUeZnb1c,740
 omlish/lite/logs.py,sha256=CWFG0NKGhqNeEgryF5atN2gkPYbUdTINEw_s1phbINM,51
@@ -432,6 +433,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=Bd_XaEmaGTsKcORfPt-AJECmf8Bt9XwjBfjkMacpEdM,4954
 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
@@ -495,6 +497,7 @@ omlish/os/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/os/atomics.py,sha256=KhWNeh4mzU3M-TF0v8uR6hUqMfZJW42MeyIK9Jl6R0k,5246
 omlish/os/death.py,sha256=_JV88yxwYIalamIMuqmGTQ4KYd0t-UHLjVkdoliPWL8,2943
 omlish/os/deathsig.py,sha256=hk9Yq2kyDdI-cI7OQH7mOfpRbOKzY_TfPKEqgrjVYbA,641
+omlish/os/fcntl.py,sha256=hSlCqzMu5iqEsxlp9me6KtoG9FK7g3sdjZIpDba-kLQ,1458
 omlish/os/files.py,sha256=O1Um1iCLeIzDSKQq2zByVC_4NZ3tLMqv6vICyU21U3Q,861
 omlish/os/journald.py,sha256=2nI8Res1poXkbLc31--MPUlzYMESnCcPUkIxDOCjZW0,3903
 omlish/os/linux.py,sha256=whJ6scwMKSFBdXiVhJW0BCpJV4jOGMr-a_a3Bhwz6Ls,18938
@@ -502,8 +505,8 @@ omlish/os/paths.py,sha256=hqPiyg_eYaRoIVPdAeX4oeLEV4Kpln_XsH0tHvbOf8Q,844
 omlish/os/sizes.py,sha256=ohkALLvqSqBX4iR-7DMKJ4pfOCRdZXV8htH4QywUNM0,152
 omlish/os/temp.py,sha256=P97KiVeNB7rfGn4tlgU5ro86JUxAsiphLMlxsjQgfB0,1198
 omlish/os/pidfiles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/os/pidfiles/manager.py,sha256=u8N7z6fSMHeE4aEHhkYShIymos1B6k1hxMd9sP6IuKE,2330
-omlish/os/pidfiles/pidfile.py,sha256=NHpt4721J_VsCKaInG6u4sjFkHiZaor7lDneTTykr8w,3177
+omlish/os/pidfiles/manager.py,sha256=ssnxCvSoL3OapzcMmxSgiy9o1NogR6PTX4LLTJXuPkM,2830
+omlish/os/pidfiles/pidfile.py,sha256=833aPCV7cQqFqYnxwma8np0eoy0CJzVHRskn-YSQwis,3378
 omlish/reflect/__init__.py,sha256=JBWwxKwP4IEaomkK0PTju02STU1BVXT14SCrShT1Sm0,769
 omlish/reflect/inspect.py,sha256=veJ424-9oZrqyvhVpvxOi7hcKW-PDBkdYL2yjrFlk4o,495
 omlish/reflect/ops.py,sha256=RJ6jzrM4ieFsXzWyNXWV43O_WgzEaUvlHSc5N2ezW2A,2044
@@ -627,10 +630,10 @@ omlish/sql/tabledefs/lower.py,sha256=YQf8gl1kxD5Fm-vOxV6G0Feh_D9PP1pYwz_vz6XjTPQ
 omlish/sql/tabledefs/marshal.py,sha256=j-Rz1HsiXmABv39-2VoJdzSSB3kbxqaVevbdkZWMyG8,504
 omlish/sql/tabledefs/tabledefs.py,sha256=lIhvlt0pk6G7RZAtDFsFXm5j0l9BvRfnP7vNGeydHtE,816
 omlish/subprocesses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/subprocesses/async_.py,sha256=Ic9luphqOGdOsBCnH76msy5SCrudMYqvUD1bw-l8ABY,2327
-omlish/subprocesses/base.py,sha256=tWh5ivsPCpz6e3qayhfnapxuiFWO3nNvgnbYbzSXxAs,5981
-omlish/subprocesses/run.py,sha256=iRYiGqoLpB6aQ7a3t-GiJ_6XFLljr6PrZZER7XvibXM,2663
-omlish/subprocesses/sync.py,sha256=wAJeA4awo53AlrF6kzRM4usj9gMy7bOYIHnMcr93ETg,3567
+omlish/subprocesses/async_.py,sha256=hPQTWFa3k5CE_s9p1JTY4KdTPOsqLJtq3lGMRznrVpY,2373
+omlish/subprocesses/base.py,sha256=W6El-PUKKF9KLAks5LB6kzqs_n3FfkblJ-JOv6NFQbY,6133
+omlish/subprocesses/run.py,sha256=3jwSnQJvFMDMHmJvtAkrrK5D-i7_8cw12vX84EWTuJo,3668
+omlish/subprocesses/sync.py,sha256=HKmKM99_Y7tkJRg_n5onXrw41IZt5M5fqU0281LY-mo,3671
 omlish/subprocesses/utils.py,sha256=MJb6hvKhZceTmBeFVqlc5oM7rDxWkUzSzK9nKvbIvM8,396
 omlish/subprocesses/wrap.py,sha256=v7vrbDhl_FVWESnXIOJ3oGtE3Y-OHQa5sH3MTtFTBUE,504
 omlish/term/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -676,9 +679,9 @@ omlish/text/indent.py,sha256=YjtJEBYWuk8--b9JU_T6q4yxV85_TR7VEVr5ViRCFwk,1336
 omlish/text/minja.py,sha256=jZC-fp3Xuhx48ppqsf2Sf1pHbC0t8XBB7UpUUoOk2Qw,5751
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev225.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev225.dist-info/METADATA,sha256=8NMIcuuTxgyCnPF4F5NHPdeRYbajQPP030dNBorRANg,4176
-omlish-0.0.0.dev225.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-omlish-0.0.0.dev225.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev225.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev225.dist-info/RECORD,,
+omlish-0.0.0.dev226.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev226.dist-info/METADATA,sha256=0HcF368bfjlzkGzprdbRX4GJagL5c9PDPRUqiBYWIlY,4176
+omlish-0.0.0.dev226.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+omlish-0.0.0.dev226.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev226.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev226.dist-info/RECORD,,

omlish/lang/timeouts.py

@@ -1,53 +0,0 @@
-import abc
-import time
-import typing as ta
-
-
-TimeoutLike: ta.TypeAlias = ta.Union['Timeout', float]
-
-
-class Timeout(abc.ABC):
-    @abc.abstractmethod
-    def __call__(self) -> float:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def or_(self, o: ta.Any) -> ta.Any:
-        raise NotImplementedError
-
-
-class DeadlineTimeout(Timeout):
-    def __init__(
-            self,
-            deadline: float,
-            exc: type[BaseException] | BaseException = TimeoutError,
-    ) -> None:
-        super().__init__()
-        self.deadline = deadline
-        self.exc = exc
-
-    def __call__(self) -> float:
-        if (rem := self.deadline - time.time()) > 0:
-            return rem
-        raise self.exc
-
-    def or_(self, o: ta.Any) -> ta.Any:
-        return self()
-
-
-class InfiniteTimeout(Timeout):
-    def __call__(self) -> float:
-        return float('inf')
-
-    def or_(self, o: ta.Any) -> ta.Any:
-        return o
-
-
-def timeout(t: TimeoutLike | None) -> Timeout:
-    if t is None:
-        return InfiniteTimeout()
-    if isinstance(t, Timeout):
-        return t
-    if isinstance(t, (float, int)):
-        return DeadlineTimeout(time.time() + t)
-    raise TypeError(t)