omlish 0.0.0.dev2__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

omlish/defs.py

@@ -4,6 +4,8 @@ class definitions. Should be used sparingly for methods not directly used by hum
 remain @property's for type annotation, tool assistance, debugging, and otherwise, but these are still nice to have in
 certain circumstances (the real-world alternative usually being simply not adding them).
 """
+# ruff: noqa: ANN201
+
 import abc
 import functools
 import operator
@@ -62,29 +64,23 @@ def build_attr_repr(obj, *, mro=False):
     if mro:
         attrs = [
             attr
-            for ty in sorted(reversed(type(obj).__mro__), key=lambda _ty: _ty.__dict__.get('__repr_priority__', 0))
+            for ty in sorted(reversed(type(obj).__mro__), key=lambda _ty: _ty.__dict__.get('__repr_priority__', 0))  # noqa
             for attr in ty.__dict__.get('__repr_attrs__', [])]
     else:
         attrs = obj.__repr_attrs__
-    return '%s@%s(%s)' % (
-        type(obj).__name__,
-        hex(id(obj))[2:],
-        ', '.join('%s=%s' % (attr, '<self>' if value is obj else _repr(value))
-                  for attr in attrs for value in [getattr(obj, attr)]))
+    s = ', '.join(f'{a}={"<self>" if v is obj else _repr(v)}' for a in attrs for v in [getattr(obj, a)])
+    return f'{type(obj).__name__}@{hex(id(obj))[2:]}({s})'
 
 
 @_repr_guard
 def build_repr(obj, *attrs):
-    return '%s@%s(%s)' % (
-        type(obj).__name__,
-        hex(id(obj))[2:],
-        ', '.join('%s=%r' % (attr, getattr(obj, attr)) for attr in attrs))
+    return f'{type(obj).__name__}@{hex(id(obj))[2:]}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
 
 
 @_basic
 @lang.cls_dct_fn()
-def repr(cls_dct, *attrs, mro=False, priority=None):
-    def __repr__(self):
+def repr(cls_dct, *attrs, mro=False, priority=None):  # noqa
+    def __repr__(self):  # noqa
         return build_attr_repr(self, mro=mro)
 
     cls_dct['__repr_attrs__'] = attrs
@@ -95,7 +91,7 @@ def repr(cls_dct, *attrs, mro=False, priority=None):
 
 @lang.cls_dct_fn()
 def bare_repr(cls_dct, *attrs):
-    def __repr__(self):
+    def __repr__(self):  # noqa
         return lang.attr_repr(self, *attrs)
 
     cls_dct['__repr__'] = __repr__
@@ -103,7 +99,7 @@ def bare_repr(cls_dct, *attrs):
 
 @lang.cls_dct_fn()
 def name_repr(cls_dct):
-    def __repr__(self):
+    def __repr__(self):  # noqa
         return self.__name__
 
     cls_dct['__repr__'] = __repr__
@@ -111,7 +107,7 @@ def name_repr(cls_dct):
 
 @lang.cls_dct_fn()
 def ne(cls_dct):
-    def __ne__(self, other):
+    def __ne__(self, other):  # noqa
         return not (self == other)
 
     cls_dct['__ne__'] = __ne__
@@ -137,12 +133,12 @@ def no_order(cls_dct, *, raise_=None):
 @_basic
 @lang.cls_dct_fn()
 def hash_eq(cls_dct, *attrs):
-    def __hash__(self):
+    def __hash__(self):  # noqa
         return hash(tuple(getattr(self, attr) for attr in attrs))
 
     cls_dct['__hash__'] = __hash__
 
-    def __eq__(self, other):
+    def __eq__(self, other):  # noqa
         if type(other) is not type(self):
             return False
         for attr in attrs:

omlish/{procfs.py → diag/procfs.py}

@@ -11,10 +11,10 @@ import struct
 import sys
 import typing as ta
 
-from . import iterators as it
-from . import json
-from . import lang
-from . import os as oos
+from .. import iterators as it
+from .. import json
+from .. import lang
+from .. import os as oos
 
 
 log = logging.getLogger(__name__)
@@ -98,18 +98,18 @@ def _check_linux() -> None:
         raise OSError
 
 
-def get_process_stats(pid: PidLike = 'self') -> ta.List[str]:
+def get_process_stats(pid: PidLike = 'self') -> list[str]:
     """http://man7.org/linux/man-pages/man5/proc.5.html -> /proc/[pid]/stat"""
 
     _check_linux()
-    with open('/proc/%s/stat' % (pid,)) as f:
+    with open(f'/proc/{pid}/stat') as f:
         buf = f.read()
     l, _, r = buf.rpartition(')')
     pid, _, comm = l.partition('(')
-    return [pid.strip(), comm] + r.strip().split(' ')
+    return [pid.strip(), comm, *r.strip().split(' ')]
 
 
-def get_process_chain(pid: PidLike = 'self') -> ta.List[ta.Tuple[int, str]]:
+def get_process_chain(pid: PidLike = 'self') -> list[tuple[int, str]]:
     _check_linux()
     lst = []
     while pid:
@@ -144,7 +144,7 @@ def get_process_rss(pid: PidLike = 'self') -> int:
 
 def set_process_oom_score_adj(score: str, pid: PidLike = 'self') -> None:
     _check_linux()
-    with open('/proc/%s/oom_score_adj' % (pid,), 'w') as f:
+    with open(f'/proc/{pid}/oom_score_adj', 'w') as f:
         f.write(str(score))
 
 
@@ -160,11 +160,11 @@ MAP_LINE_RX = re.compile(
 )
 
 
-def get_process_maps(pid: PidLike = 'self', sharing: bool = False) -> ta.Iterator[ta.Dict[str, ta.Any]]:
+def get_process_maps(pid: PidLike = 'self', sharing: bool = False) -> ta.Iterator[dict[str, ta.Any]]:
     """http://man7.org/linux/man-pages/man5/proc.5.html -> /proc/[pid]/maps"""
 
     _check_linux()
-    with open('/proc/%s/%s' % (pid, 'smaps' if sharing else 'maps'), 'r') as map_file:
+    with open(f'/proc/{pid}/{"smaps" if sharing else "maps"}') as map_file:
         while True:
             line = map_file.readline()
             if not line:
@@ -210,14 +210,14 @@ PAGEMAP_KEYS = (
 )
 
 
-def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> ta.Iterable[ta.Dict[str, int]]:
+def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> ta.Iterable[dict[str, int]]:
     """https://www.kernel.org/doc/Documentation/vm/pagemap.txt"""
 
     _check_linux()
     offset = (start // oos.PAGE_SIZE) * 8
     npages = ((end - start) // oos.PAGE_SIZE)
     size = npages * 8
-    with open('/proc/%s/pagemap' % (pid,), 'rb') as pagemap_file:
+    with open(f'/proc/{pid}/pagemap', 'rb') as pagemap_file:
         pagemap_file.seek(offset)
         pagemap_buf = pagemap_file.read(size)
     if not pagemap_buf:
@@ -237,14 +237,13 @@ def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> t
         }
 
 
-def get_process_pagemaps(pid: PidLike = 'self') -> ta.Iterable[ta.Dict[str, int]]:
+def get_process_pagemaps(pid: PidLike = 'self') -> ta.Iterable[dict[str, int]]:
     _check_linux()
     for m in get_process_maps(pid):
-        for p in get_process_range_pagemaps(m['address'], m['end_address'], pid):
-            yield p
+        yield from get_process_range_pagemaps(m['address'], m['end_address'], pid)
 
 
-def _dump_cmd(args):
+def _dump_cmd(args: ta.Any) -> None:
     total = 0
     dirty_total = 0
     for m in get_process_maps(args.pid, sharing=True):
@@ -264,7 +263,7 @@ def _dump_cmd(args):
     sys.stdout.write('\n')
 
 
-def _cmp_cmd(args):
+def _cmp_cmd(args: ta.Any) -> None:
     if len(args.pids) == 1:
         [rpid] = args.pids
         lpid = get_process_chain(rpid)[1][0]
@@ -273,12 +272,11 @@ def _cmp_cmd(args):
     else:
         raise TypeError('Invalid arguments')
 
-    def g(pid):
+    def g(pid: int) -> ta.Iterator[dict[str, int]]:
         for m in get_process_maps(pid, sharing=True):
-            for pm in get_process_range_pagemaps(m['address'], m['end_address'], pid):
-                yield pm
+            yield from get_process_range_pagemaps(m['address'], m['end_address'], pid)
 
-    lpms, rpms = [g(pid) for pid in (lpid, rpid)]
+    lpms, rpms = (g(pid) for pid in (lpid, rpid))
 
     l_pages = 0
     r_pages = 0
@@ -289,7 +287,7 @@ def _cmp_cmd(args):
             l_pages += 1
         elif l is None and r is not None:
             r_pages += 1
-        elif l['pfn'] != r['pfn']:
+        elif l['pfn'] != r['pfn']:  # type: ignore
             c_pages += 1
         else:
             continue
@@ -310,7 +308,7 @@ def _cmp_cmd(args):
     sys.stdout.write('\n')
 
 
-def _main():
+def _main() -> None:
     _check_linux()
 
     arg_parser = argparse.ArgumentParser()

omlish/diag/ps.py

@@ -0,0 +1,47 @@
+import dataclasses as dc
+import os
+import subprocess
+
+from .. import lang
+
+
+@dc.dataclass(frozen=True)
+class PsItem:
+    pid: int
+    ppid: int
+    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(),
+    )
+
+
+def get_ps_lineage(pid: int, timeout: lang.Timeout | None = None) -> list[PsItem]:
+    timeout = lang.timeout(timeout)
+    ret: list[PsItem] = []
+    while True:
+        cur = get_ps_item(pid, timeout)
+        if cur.ppid < 1:
+            break
+        ret.append(cur)
+        pid = cur.ppid
+    return ret
+
+
+def _main() -> None:
+    print(get_ps_lineage(os.getpid()))
+
+
+if __name__ == '__main__':
+    _main()

omlish/{replserver → diag/replserver}/console.py

@@ -25,13 +25,13 @@ import traceback
 import types
 import typing as ta
 
-from .. import check
+from ... import check
 
 
 log = logging.getLogger(__name__)
 
 
-class DisconnectException(Exception):
+class DisconnectError(Exception):
     pass
 
 
@@ -43,13 +43,13 @@ class InteractiveSocketConsole:
     def __init__(
             self,
             conn: sock.socket,
-            locals: dict[str, ta.Any] | None = None,
+            locals: dict[str, ta.Any] | None = None,  # noqa
             filename: str = '<console>',
     ) -> None:
         super().__init__()
 
         if locals is None:
-            locals = {
+            locals = {  # noqa
                 '__name__': '__console__',
                 '__doc__': None,
                 '__console__': self,
@@ -81,11 +81,9 @@ class InteractiveSocketConsole:
             ps2 = getattr(sys, 'ps2', '... ')
 
             if banner is None:
-                self.write(
-                    'Python %s on %s\n%s\n(%s)\n' %
-                    (sys.version, sys.platform, self.CPRT, self.__class__.__name__))
+                self.write(f'Python {sys.version} on {sys.platform}\n{self.CPRT}\n({self.__class__.__name__})\n')
             elif banner:
-                self.write('%s\n' % (str(banner),))
+                self.write(f'{banner!s}\n')
 
             more = False
             while True:
@@ -104,12 +102,12 @@ class InteractiveSocketConsole:
                     more = False
 
             if exitmsg is None:
-                self.write('now exiting %s...\n' % self.__class__.__name__)
+                self.write(f'now exiting {self.__class__.__name__}...\n')
 
             elif exitmsg != '':
-                self.write('%s\n' % exitmsg)
+                self.write(f'{exitmsg}\n')
 
-        except DisconnectException:
+        except DisconnectError:
             pass
 
         except OSError as oe:
@@ -133,7 +131,7 @@ class InteractiveSocketConsole:
         while True:
             b = self._conn.recv(1)
             if not b:
-                raise DisconnectException
+                raise DisconnectError
             if b == b'\n':
                 break
             buf += b
@@ -228,20 +226,20 @@ class InteractiveSocketConsole:
             last_tb = ei = None  # type: ignore  # noqa
 
     def show_syntax_error(self, filename: str | None = None) -> None:
-        type, value, tb = sys.exc_info()
-        sys.last_type = type
-        sys.last_value = value
+        et, e, tb = sys.exc_info()
+        sys.last_type = et
+        sys.last_value = e
         sys.last_traceback = tb
-        if filename and type is SyntaxError:
+        if filename and et is SyntaxError:
             # Work hard to stuff the correct filename in the exception
             try:
-                msg, (dummy_filename, lineno, offset, line) = value.args  # type: ignore
+                msg, (dummy_filename, lineno, offset, line) = e.args  # type: ignore
             except ValueError:
                 # Not the format we expect; leave it alone
                 pass
             else:
                 # Stuff in the right filename
-                value = SyntaxError(msg, (filename, lineno, offset, line))
-                sys.last_value = value
-        lines = traceback.format_exception_only(type, value)
+                e = SyntaxError(msg, (filename, lineno, offset, line))
+                sys.last_value = e
+        lines = traceback.format_exception_only(et, e)
         self.write(''.join(lines))

omlish/{replserver → diag/replserver}/server.py

@@ -23,8 +23,8 @@ import threading
 import typing as ta
 import weakref
 
-from .. import check
-from .. import dataclasses as dc
+from ... import check
+from ... import dataclasses as dc
 from .console import InteractiveSocketConsole
 
 
@@ -62,12 +62,12 @@ class ReplServer:
     def path(self) -> str:
         return self._config.path
 
-    def __enter__(self):
+    def __enter__(self) -> ta.Self:
         check.state(not self._is_running)
         check.state(not self._is_shutdown.is_set())
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         if not self._is_shutdown.is_set():
             self.shutdown(True, self._config.exit_timeout)
 
@@ -91,7 +91,7 @@ class ReplServer:
                 while not self._should_shutdown:
                     try:
                         conn, _ = self._socket.accept()
-                    except sock.timeout:
+                    except TimeoutError:
                         continue
 
                     log.info(f'Got repl server connection on file {self._config.path}')
@@ -117,13 +117,13 @@ class ReplServer:
                         name=self.CONNECTION_THREAD_NAME)
                     thread.start()
 
-                for thread, console in self._consoles_by_threads.items():
+                for console in self._consoles_by_threads.values():
                     try:
                         console.conn.close()
                     except Exception:
                         log.exception('Error shutting down')
 
-                for thread in self._consoles_by_threads.keys():
+                for thread in self._consoles_by_threads:
                     try:
                         thread.join(self._config.exit_timeout)
                     except Exception:
@@ -141,6 +141,6 @@ class ReplServer:
             self._is_shutdown.wait(timeout=timeout)
 
 
-def run():
+def run() -> None:
     with ReplServer(ReplServer.Config('repl.sock')) as repl_server:
         repl_server.run()

omlish/dispatch/dispatch.py

@@ -1,4 +1,5 @@
 import abc
+import contextlib
 import typing as ta
 import weakref
 
@@ -13,14 +14,12 @@ T = ta.TypeVar('T')
 ##
 
 
-_IMPL_FUNC_CLS_SET_CACHE: ta.MutableMapping[ta.Callable, ta.FrozenSet[type]] = weakref.WeakKeyDictionary()
+_IMPL_FUNC_CLS_SET_CACHE: ta.MutableMapping[ta.Callable, frozenset[type]] = weakref.WeakKeyDictionary()
 
 
-def get_impl_func_cls_set(func: ta.Callable) -> ta.FrozenSet[type]:
-    try:
+def get_impl_func_cls_set(func: ta.Callable) -> frozenset[type]:
+    with contextlib.suppress(KeyError):
         return _IMPL_FUNC_CLS_SET_CACHE[func]
-    except KeyError:
-        pass
 
     ann = getattr(func, '__annotations__', {})
     if not ann:
@@ -78,10 +77,8 @@ class Dispatcher(ta.Generic[T]):
         def cache_remove(k, self_ref=weakref.ref(self)):
             if (ref_self := self_ref()) is not None:
                 cache = ref_self._get_dispatch_cache()  # noqa
-                try:
+                with contextlib.suppress(KeyError):
                     del cache[k]
-                except KeyError:
-                    pass
 
         cache_token: ta.Any = None
         self._get_cache_token = lambda: cache_token

omlish/dispatch/functions.py

@@ -10,7 +10,7 @@ from .dispatch import get_impl_func_cls_set
 USE_EXTENSION = False
 
 
-def function(func):
+def function(func):  # noqa
     disp = Dispatcher()  # type: ignore
     disp.register(func, [object])
 

omlish/dispatch/methods.py

@@ -4,6 +4,7 @@ TODO:
  - ALT: A.f(super(), ... ? :/
  - classmethod/staticmethod
 """
+import contextlib
 import functools
 import typing as ta
 import weakref
@@ -23,7 +24,7 @@ def build_mro_dct(instance_cls: type, owner_cls: type | None = None) -> ta.Mappi
     try:
         pos = mro.index(owner_cls)
     except ValueError:
-        raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}')
+        raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
     dct: dict[str, ta.Any] = {}
     for cur_cls in mro[:pos + 1]:
         dct.update(cur_cls.__dict__)
@@ -55,10 +56,8 @@ class Method:
         def dispatch_func_cache_remove(k, self_ref=weakref.ref(self)):
             if (ref_self := self_ref()) is not None:
                 cache = ref_self._dispatch_func_cache  # noqa
-                try:
+                with contextlib.suppress(KeyError):
                     del cache[k]
-                except KeyError:
-                    pass
 
         self._dispatch_func_cache_remove = dispatch_func_cache_remove
 
@@ -158,5 +157,5 @@ class Method:
         return func.__get__(instance)(*args, **kwargs)  # noqa
 
 
-def method(func):
+def method(func):  # noqa
     return Method(func)

omlish/docker.py

@@ -127,7 +127,7 @@ class ComposeConfig:
 
     @lang.cached_function
     def get_config(self) -> ta.Mapping[str, ta.Any]:
-        with open(check.not_none(self._file_path), 'r') as f:
+        with open(check.not_none(self._file_path)) as f:
             buf = f.read()
         return yaml.safe_load(buf)
 

omlish/dynamic.py

@@ -25,7 +25,7 @@ _HOISTED_CODE_DEPTH: ta.MutableMapping[types.CodeType, int] = weakref.WeakKeyDic
 _MAX_HOIST_DEPTH = 0
 
 
-def hoist(depth=0):
+def hoist(depth=0):  # noqa
     def inner(fn):
         _HOISTED_CODE_DEPTH[fn.__code__] = depth
         global _MAX_HOIST_DEPTH
@@ -87,7 +87,7 @@ class Var(ta.Generic[T]):
             self._validate(self.value)
         return Binding(self, value, offset=offset)
 
-    def with_binding(self, value):
+    def with_binding(self, value):  # noqa
         def outer(fn):
             @functools.wraps(fn)
             def inner(*args, **kwargs):
@@ -96,7 +96,7 @@ class Var(ta.Generic[T]):
             return inner
         return outer
 
-    def with_binding_fn(self, binding_fn):
+    def with_binding_fn(self, binding_fn):  # noqa
         this = self
 
         def outer(fn):
@@ -104,7 +104,7 @@ class Var(ta.Generic[T]):
 
                 @staticmethod
                 @functools.wraps(fn)
-                def __call__(*args, **kwargs):
+                def __call__(*args, **kwargs):  # noqa
                     with this.binding(binding_fn(*args, **kwargs)):
                         return fn(*args, **kwargs)
 
@@ -119,7 +119,7 @@ class Var(ta.Generic[T]):
 
                     return inner
 
-            dct = dict((k, getattr(fn, k)) for k in functools.WRAPPER_ASSIGNMENTS)
+            dct: dict[str, ta.Any] = {k: getattr(fn, k) for k in functools.WRAPPER_ASSIGNMENTS}
             return lang.new_type(fn.__name__, (Descriptor,), dct)()
 
         return outer
@@ -133,7 +133,7 @@ class Var(ta.Generic[T]):
             except KeyError:
                 pass
             else:
-                for level, frame_binding in sorted(frame_bindings.items()):
+                for level, frame_binding in sorted(frame_bindings.items()):  # noqa
                     yield frame_binding._value  # noqa
             frame = frame.f_back
 
@@ -148,7 +148,7 @@ class Var(ta.Generic[T]):
         try:
             return next(self.values)
         except StopIteration:
-            raise UnboundVarError
+            raise UnboundVarError from None
 
 
 class Binding(ta.Generic[T]):
@@ -213,7 +213,7 @@ class _GeneratorContextManager(contextlib._GeneratorContextManager):  # noqa
         return super().__enter__()
 
 
-def contextmanager(fn):
+def contextmanager(fn):  # noqa
     @functools.wraps(fn)
     def helper(*args, **kwds):
         return _GeneratorContextManager(fn, args, kwds)