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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev225'
-__revision__ = '99eb1740a6c8647c20c80278b6d0bedff0f7c103'
+__version__ = '0.0.0.dev227'
+__revision__ = '2faa3e7f9120edd3e6dd79fad6401fd87d89f5cf'
 
 
 #

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[ta.List[LslocksItem]]):
+    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':
+        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))