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

omlish/dataclasses/impl/api.py

@@ -1,4 +1,5 @@
 import collections.abc
+import contextlib
 import dataclasses as dc
 import keyword
 import sys
@@ -18,13 +19,13 @@ from .params import ParamsExtras
 MISSING = dc.MISSING
 
 
-def field(
+def field(  # noqa
         default=MISSING,
         *,
         default_factory=MISSING,
         init=True,
-        repr=True,
-        hash=None,
+        repr=True,  # noqa
+        hash=None,  # noqa
         compare=True,
         metadata=None,
         kw_only=MISSING,
@@ -66,12 +67,12 @@ def _strip_missing_values(d):
     return {k: v for k, v in d.items() if v is not MISSING}
 
 
-def dataclass(
+def dataclass(  # noqa
         cls=None,
         /,
         *,
         init=True,
-        repr=True,
+        repr=True,  # noqa
         eq=True,
         order=False,
         unsafe_hash=False,
@@ -135,14 +136,14 @@ def dataclass(
     return wrap(cls)
 
 
-def make_dataclass(
+def make_dataclass(  # noqa
         cls_name,
         fields,
         *,
         bases=(),
         namespace=None,
         init=True,
-        repr=True,
+        repr=True,  # noqa
         eq=True,
         order=False,
         unsafe_hash=False,
@@ -195,10 +196,8 @@ def make_dataclass(
         try:
             module = sys._getframemodulename(1) or '__main__'  # type: ignore  # noqa
         except AttributeError:
-            try:
+            with contextlib.suppress(AttributeError, ValueError):
                 module = sys._getframe(1).f_globals.get('__name__', '__main__')  # noqa
-            except (AttributeError, ValueError):
-                pass
     if module is not None:
         cls.__module__ = module
 
@@ -225,7 +224,7 @@ class _ExtraParamsKwargs:
     pass
 
 
-def extra_params(
+def extra_params(  # noqa
         *,
         reorder=MISSING,
         cache_hash=MISSING,

omlish/dataclasses/impl/as_.py

@@ -5,9 +5,9 @@ from .internals import is_dataclass_instance
 from .internals import ATOMIC_TYPES
 
 
-def asdict(obj, *, dict_factory=dict):
+def asdict(obj, *, dict_factory=dict):  # noqa
     if not is_dataclass_instance(obj):  # noqa
-        raise TypeError("asdict() should be called on dataclass instances")
+        raise TypeError('asdict() should be called on dataclass instances')
     return _asdict_inner(obj, dict_factory)
 
 
@@ -40,9 +40,9 @@ def _asdict_inner(obj, dict_factory):
         return copy.deepcopy(obj)
 
 
-def astuple(obj, *, tuple_factory=tuple):
+def astuple(obj, *, tuple_factory=tuple):  # noqa
     if not is_dataclass_instance(obj):
-        raise TypeError("astuple() should be called on dataclass instances")
+        raise TypeError('astuple() should be called on dataclass instances')
     return _astuple_inner(obj, tuple_factory)
 
 

omlish/dataclasses/impl/exceptions.py

@@ -1,2 +1,2 @@
-class CheckException(Exception):
+class CheckError(Exception):
     pass

omlish/dataclasses/impl/fields.py

@@ -55,7 +55,7 @@ def preprocess_field(
     if ft in (FieldType.CLASS, FieldType.INIT):
         if f.default_factory is not MISSING:
             raise TypeError(f'field {f.name} cannot have a default factory')
-    f._field_type = ft.value  # type: ignore
+    f._field_type = ft.value  # type: ignore  # noqa
 
     if ft in (FieldType.INSTANCE, FieldType.INIT):
         if f.kw_only is MISSING:
@@ -88,7 +88,7 @@ def field_assign(
 def field_init(
         f: dc.Field,
         frozen: bool,
-        locals: dict[str, ta.Any],
+        locals: dict[str, ta.Any],  # noqa
         self_name: str,
         slots: bool,
 ) -> ta.Sequence[str]:
@@ -135,12 +135,12 @@ def field_init(
             locals[default_name] = f.default
             value = f.name
 
+    elif slots and f.default is not MISSING:
+        locals[default_name] = f.default
+        value = default_name
+
     else:
-        if slots and f.default is not MISSING:
-            locals[default_name] = f.default
-            value = default_name
-        else:
-            pass
+        pass
 
     if value is not None and field_type(f) is not FieldType.INIT:
         lines.append(field_assign(frozen, f.name, value, self_name, fx.override))  # noqa

omlish/dataclasses/impl/frozen.py

@@ -10,9 +10,9 @@ from .utils import set_new_attribute
 def frozen_get_del_attr(
         cls: type,
         fields: ta.Sequence[dc.Field],
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> tuple[ta.Callable, ta.Callable]:
-    locals = {
+    locals = {  # noqa
         'cls': cls,
         'FrozenInstanceError': dc.FrozenInstanceError,
     }

omlish/dataclasses/impl/init.py

@@ -3,7 +3,7 @@ import inspect
 import typing as ta
 
 from ... import lang
-from .exceptions import CheckException
+from .exceptions import CheckError
 from .fields import field_init
 from .fields import field_type
 from .fields import has_default
@@ -64,7 +64,7 @@ class InitBuilder:
             fields: ta.Mapping[str, dc.Field],
             has_post_init: bool,
             self_name: str,
-            globals: Namespace,
+            globals: Namespace,  # noqa
     ) -> None:
         super().__init__()
 
@@ -86,7 +86,7 @@ class InitBuilder:
                 elif seen_default:
                     raise TypeError(f'non-default argument {f.name!r} follows default argument {seen_default.name!r}')
 
-        locals: dict[str, ta.Any] = {}
+        locals: dict[str, ta.Any] = {}  # noqa
 
         if self._info.params_extras.generic_init:
             get_fty = lambda f: self._info.generic_replaced_field_annotations[f.name]
@@ -99,7 +99,7 @@ class InitBuilder:
             '__dataclass_builtins_object__': object,
             '__dataclass_builtins_isinstance__': isinstance,
             '__dataclass_builtins_TypeError__': TypeError,
-            '__dataclass_CheckException__': CheckException,
+            '__dataclass_CheckException__': CheckError,
         })
 
         body_lines: list[str] = []
@@ -143,7 +143,7 @@ class InitBuilder:
 
         return create_fn(
             '__init__',
-            [self._self_name] + _init_params,
+            [self._self_name, *_init_params],
             body_lines,
             locals=locals,
             globals=self._globals,

omlish/dataclasses/impl/internals.py

@@ -42,7 +42,7 @@ is_dataclass_instance = dc._is_dataclass_instance  # type: ignore  # noqa
 ##
 
 
-ATOMIC_TYPES: ta.FrozenSet[type]
+ATOMIC_TYPES: frozenset[type]
 
 if hasattr(dc, '_ATOMIC_TYPES'):
     ATOMIC_TYPES = getattr(dc, '_ATOMIC_TYPES')

omlish/dataclasses/impl/metaclass.py

@@ -97,7 +97,7 @@ class Data(metaclass=DataMeta):
             spi = super().__post_init__  # type: ignore  # noqa
         except AttributeError:
             if args or kwargs:
-                raise TypeError(args, kwargs)
+                raise TypeError(args, kwargs) from None
         else:
             spi(*args, **kwargs)
 

omlish/dataclasses/impl/order.py

@@ -12,7 +12,7 @@ def cmp_fn(
         op: str,
         self_tuple: str,
         other_tuple: str,
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> ta.Callable:
     return create_fn(
         name,

omlish/dataclasses/impl/replace.py

@@ -11,7 +11,7 @@ from .utils import set_new_attribute
 MISSING = dc.MISSING
 
 
-def replace(obj, /, **changes):
+def replace(obj, /, **changes):  # noqa
     if not is_dataclass_instance(obj):
         raise TypeError('replace() should be called on dataclass instances')
     return _replace(obj, **changes)

omlish/dataclasses/impl/repr.py

@@ -11,9 +11,9 @@ from .utils import set_new_attribute
 
 def repr_fn(
         fields: ta.Sequence[dc.Field],
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> ta.Callable:
-    locals: dict[str, ta.Any] = {}
+    locals: dict[str, ta.Any] = {}  # noqa
     if any(get_field_extras(f).repr_fn is not None for f in fields):
         lst: list[str] = []
         for f in fields:
@@ -25,12 +25,12 @@ def repr_fn(
         src = [
             'l = []',
             *lst,
-            'return f"{self.__class__.__qualname__}({\", \".join(l)})"',
+            'return f"{self.__class__.__qualname__}({", ".join(l)})"',
         ]
     else:
         src = [
             'return f"{self.__class__.__qualname__}(' +
-            ', '.join([f"{f.name}={{self.{f.name}!r}}" for f in fields]) +
+            ', '.join([f'{f.name}={{self.{f.name}!r}}' for f in fields]) +
             ')"',
         ]
     fn = create_fn(

omlish/dataclasses/impl/utils.py

@@ -16,15 +16,15 @@ def create_fn(
         args: ta.Sequence[str],
         body: ta.Sequence[str],
         *,
-        globals: Namespace | None = None,
-        locals: Namespace | None = None,
+        globals: Namespace | None = None,  # noqa
+        locals: Namespace | None = None,  # noqa
         return_type: lang.Maybe[ta.Any] = lang.empty(),
 ) -> ta.Callable:
     check.not_isinstance(args, str)
     check.not_isinstance(body, str)
 
     if locals is None:
-        locals = {}
+        locals = {}  # noqa
     return_annotation = ''
     if return_type.present:
         locals['__dataclass_return_type__'] = return_type()
@@ -43,7 +43,7 @@ def create_fn(
 
 # TODO: https://github.com/python/cpython/commit/8945b7ff55b87d11c747af2dad0e3e4d631e62d6
 class FuncBuilder:
-    def __init__(self, globals: Namespace) -> None:
+    def __init__(self, globals: Namespace) -> None:  # noqa
         super().__init__()
 
         self.names: list[str] = []
@@ -59,7 +59,7 @@ class FuncBuilder:
             args: ta.Sequence[str],
             body: ta.Sequence[str],
             *,
-            locals: Namespace | None = None,
+            locals: Namespace | None = None,  # noqa
             return_type: lang.Maybe[ta.Any] = lang.empty(),
             overwrite_error: bool = False,
             unconditional_add: bool = False,
@@ -91,7 +91,7 @@ class FuncBuilder:
         body = textwrap.indent('\n'.join(body), '    ')
 
         # Compute the text of the entire function, add it to the text we're generating.
-        deco_str = "  {decorator}\n" if decorator else ""
+        deco_str = '  {decorator}\n' if decorator else ''
         self.src.append(f'{deco_str}  def {name}({args}){return_annotation}:\n{body}')
 
     def add_fns_to_class(self, cls: type) -> None:

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))