ominfra 0.0.0.dev424__py3-none-any.whl → 0.0.0.dev426__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -112,8 +112,10 @@ TomlParseFloat = ta.Callable[[str], ta.Any]  # ta.TypeAlias
 TomlKey = ta.Tuple[str, ...]  # ta.TypeAlias
 TomlPos = int  # ta.TypeAlias
 
-# ../../omlish/lite/cached.py
+# ../../omlish/lite/attrops.py
 T = ta.TypeVar('T')
+
+# ../../omlish/lite/cached.py
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../omlish/lite/check.py
@@ -1830,6 +1832,335 @@ class Abstract:
             update_abstracts(cls, force=True)
 
 
+########################################
+# ../../../omlish/lite/attrops.py
+"""
+TODO:
+ - dotted paths!
+ - per-attr repr transform / filter
+ - __ne__ ? cases where it still matters
+ - ordering ?
+"""
+
+
+##
+
+
+@ta.final
+class AttrOps(ta.Generic[T]):
+    @ta.final
+    class Attr:
+        def __init__(
+                self,
+                name: str,
+                *,
+                display: ta.Optional[str] = None,
+
+                repr: bool = True,  # noqa
+                hash: bool = True,  # noqa
+                eq: bool = True,
+        ) -> None:
+            if '.' in name:
+                raise NotImplementedError('Dotted paths not yet supported')
+            if not name.isidentifier() or name.startswith('__'):
+                raise AttributeError(f'Invalid attr: {name!r}')
+            self._name = name
+
+            if display is None:
+                display = name[1:] if name.startswith('_') and len(name) > 1 else name
+            self._display = display
+
+            self._repr = repr
+            self._hash = hash
+            self._eq = eq
+
+        @classmethod
+        def of(
+                cls,
+                o: ta.Union[
+                    str,
+                    ta.Tuple[str, str],
+                    'AttrOps.Attr',
+                ],
+        ) -> 'AttrOps.Attr':
+            if isinstance(o, AttrOps.Attr):
+                return o
+            elif isinstance(o, str):
+                return cls(o)
+            else:
+                name, disp = o
+                return cls(
+                    name,
+                    display=disp,
+                )
+
+        @property
+        def name(self) -> str:
+            return self._name
+
+        @property
+        def display(self) -> str:
+            return self._display
+
+        @property
+        def hash(self) -> bool:
+            return self._hash
+
+        @property
+        def eq(self) -> bool:
+            return self._eq
+
+    @ta.overload
+    def __init__(
+            self,
+            *attrs: ta.Sequence[ta.Union[
+                str,
+                ta.Tuple[str, str],
+                Attr,
+            ]],
+            with_module: bool = False,
+            use_qualname: bool = False,
+            with_id: bool = False,
+            repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
+            recursive: bool = False,
+            subtypes_eq: bool = False,
+    ) -> None:
+        ...
+
+    @ta.overload
+    def __init__(
+            self,
+            attrs_fn: ta.Callable[[T], ta.Tuple[ta.Union[
+                ta.Any,
+                ta.Tuple[str, ta.Any],
+                Attr,
+            ], ...]],
+            /,
+            *,
+            with_module: bool = False,
+            use_qualname: bool = False,
+            with_id: bool = False,
+            repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
+            recursive: bool = False,
+            subtypes_eq: bool = False,
+    ) -> None:
+        ...
+
+    def __init__(
+            self,
+            *args,
+            with_module=False,
+            use_qualname=False,
+            with_id=False,
+            repr_filter=None,
+            recursive=False,
+            subtypes_eq=False,
+    ) -> None:
+        if args and len(args) == 1 and callable(args[0]):
+            self._attrs: ta.Sequence[AttrOps.Attr] = self._capture_attrs(args[0])
+        else:
+            self._attrs = list(map(AttrOps.Attr.of, args))
+
+        self._with_module: bool = with_module
+        self._use_qualname: bool = use_qualname
+        self._with_id: bool = with_id
+        self._repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = repr_filter
+        self._recursive: bool = recursive
+        self._subtypes_eq: bool = subtypes_eq
+
+    @property
+    def attrs(self) -> ta.Sequence[Attr]:
+        return self._attrs
+
+    #
+
+    @ta.final
+    class _AttrCapturer:
+        def __init__(self, fn):
+            self.__fn = fn
+
+        def __getattr__(self, attr):
+            return self.__fn(self, attr)
+
+    @classmethod
+    def _capture_attrs(cls, fn: ta.Callable) -> ta.Sequence[Attr]:
+        def access(parent, attr):
+            dct[(ret := cls._AttrCapturer(access))] = (parent, attr)
+            return ret
+
+        dct: dict = {}
+        raw = fn(root := cls._AttrCapturer(access))
+
+        def rec(cap):  # noqa
+            if cap is root:
+                return
+            parent, attr = dct[cap]
+            yield from rec(parent)
+            yield attr
+
+        attrs: ta.List[AttrOps.Attr] = []
+        for o in raw:
+            if isinstance(o, AttrOps.Attr):
+                attrs.append(o)
+                continue
+
+            if isinstance(o, tuple):
+                disp, cap, = o
+            else:
+                disp, cap = None, o
+
+            path = tuple(rec(cap))
+
+            attrs.append(AttrOps.Attr(
+                '.'.join(path),
+                display=disp,
+            ))
+
+        return attrs
+
+    #
+
+    _repr: ta.Callable[[T], str]
+
+    @property
+    def repr(self) -> ta.Callable[[T], str]:
+        try:
+            return self._repr
+        except AttributeError:
+            pass
+
+        def _repr(o: T) -> str:
+            vs = ', '.join(
+                f'{a._display}={v!r}'  # noqa
+                for a in self._attrs
+                if a._repr  # noqa
+                for v in [getattr(o, a._name)]  # noqa
+                if self._repr_filter is None or self._repr_filter(v)
+            )
+
+            return (
+                f'{o.__class__.__module__ + "." if self._with_module else ""}'
+                f'{o.__class__.__qualname__ if self._use_qualname else o.__class__.__name__}'
+                f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'
+                f'({vs})'
+            )
+
+        if self._recursive:
+            _repr = self._reprlib().recursive_repr()(_repr)
+
+        self._repr = _repr
+        return _repr
+
+    _reprlib_: ta.ClassVar[ta.Any]
+
+    @classmethod
+    def _reprlib(cls) -> ta.Any:
+        try:
+            return cls._reprlib_
+        except AttributeError:
+            pass
+
+        import reprlib  # noqa
+
+        cls._reprlib_ = reprlib
+        return reprlib
+
+    #
+
+    _hash: ta.Callable[[T], int]
+
+    @property
+    def hash(self) -> ta.Callable[[T], int]:
+        try:
+            return self._hash
+        except AttributeError:
+            pass
+
+        def _hash(o: T) -> int:
+            return hash(tuple(
+                getattr(o, a._name)  # noqa
+                for a in self._attrs
+                if a._hash  # noqa
+            ))
+
+        self._hash = _hash
+        return _hash
+
+    #
+
+    _eq: ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']]
+
+    @property
+    def eq(self) -> ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']]:
+        try:
+            return self._eq
+        except AttributeError:
+            pass
+
+        def _eq(o: T, x: ta.Any) -> 'ta.Union[bool, types.NotImplementedType]':
+            if self._subtypes_eq:
+                if not isinstance(x, type(o)):
+                    return NotImplemented
+            else:
+                if type(x) is not type(o):
+                    return NotImplemented
+
+            return all(
+                getattr(o, a._name) == getattr(x, a._name)  # noqa
+                for a in self._attrs
+                if a._eq  # noqa
+            )
+
+        self._eq = _eq
+        return _eq
+
+    #
+
+    @property
+    def hash_eq(self) -> ta.Tuple[
+        ta.Callable[[T], int],
+        ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']],
+    ]:
+        return (self.hash, self.eq)
+
+    @property
+    def repr_hash_eq(self) -> ta.Tuple[
+        ta.Callable[[T], str],
+        ta.Callable[[T], int],
+        ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']],
+    ]:
+        return (self.repr, self.hash, self.eq)
+
+    #
+
+    def install(
+            self,
+            locals_dct: ta.MutableMapping[str, ta.Any],
+            *,
+            all: bool = False,  # noqa
+            repr: bool = False,  # noqa
+            hash: bool = False,  # noqa
+            eq: bool = False,
+    ) -> 'AttrOps[T]':
+        if repr or all:
+            locals_dct.update(__repr__=self.repr)
+        if hash or all:
+            locals_dct.update(__hash__=self.hash)
+        if eq or all:
+            locals_dct.update(__eq__=self.eq)
+        return self
+
+
+attr_ops = AttrOps[ta.Any]
+
+
+##
+
+
+def attr_repr(obj: ta.Any, *attrs: str, **kwargs: ta.Any) -> str:
+    return AttrOps(*attrs, **kwargs).repr(obj)
+
+
 ########################################
 # ../../../omlish/lite/cached.py
 
@@ -1848,7 +2179,7 @@ class _AbstractCachedNullary:
     def __call__(self, *args, **kwargs):  # noqa
         raise TypeError
 
-    def __get__(self, instance, owner):  # noqa
+    def __get__(self, instance, owner=None):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
@@ -2409,13 +2740,6 @@ json_dump_compact: ta.Callable[..., None] = functools.partial(json.dump, **JSON_
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
 
 
-########################################
-# ../../../omlish/lite/logs.py
-
-
-log = logging.getLogger(__name__)
-
-
 ########################################
 # ../../../omlish/lite/objects.py
 
@@ -2661,13 +2985,6 @@ def split_keep_delimiter(s, d):
 ##
 
 
-def attr_repr(obj: ta.Any, *attrs: str) -> str:
-    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
-
-
-##
-
-
 FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
 
 
@@ -2742,13 +3059,24 @@ def typing_annotations_attr() -> str:
 
 
 ########################################
-# ../../../omlish/logs/filters.py
+# ../../../omlish/logs/modules.py
 
 
 ##
 
 
-class TidLogFilter(logging.Filter):
+def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
+    return logging.getLogger(mod_globals.get('__name__'))
+
+
+########################################
+# ../../../omlish/logs/std/filters.py
+
+
+##
+
+
+class TidLoggingFilter(logging.Filter):
     def filter(self, record):
         # FIXME: handle better - missing from wasm and cosmos
         if hasattr(threading, 'get_native_id'):
@@ -2759,13 +3087,13 @@ class TidLogFilter(logging.Filter):
 
 
 ########################################
-# ../../../omlish/logs/proxy.py
+# ../../../omlish/logs/std/proxy.py
 
 
 ##
 
 
-class ProxyLogFilterer(logging.Filterer):
+class ProxyLoggingFilterer(logging.Filterer):
     def __init__(self, underlying: logging.Filterer) -> None:  # noqa
         self._underlying = underlying
 
@@ -2791,9 +3119,9 @@ class ProxyLogFilterer(logging.Filterer):
         return self._underlying.filter(record)
 
 
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+class ProxyLoggingHandler(ProxyLoggingFilterer, logging.Handler):
     def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
+        ProxyLoggingFilterer.__init__(self, underlying)
 
     _underlying: logging.Handler
 
@@ -5643,6 +5971,7 @@ class _Maybe(Maybe[T], Abstract):
             return op and not sp
 
 
+@ta.final
 class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
@@ -5680,6 +6009,7 @@ class _JustMaybe(_Maybe[T]):
         )
 
 
+@ta.final
 class _EmptyMaybe(_Maybe[T]):
     __slots__ = ()
 
@@ -5726,7 +6056,7 @@ def check_lite_runtime_version() -> None:
 
 
 ########################################
-# ../../../omlish/logs/json.py
+# ../../../omlish/logs/std/json.py
 """
 TODO:
  - translate json keys
@@ -5736,7 +6066,7 @@ TODO:
 ##
 
 
-class JsonLogFormatter(logging.Formatter):
+class JsonLoggingFormatter(logging.Formatter):
     KEYS: ta.Mapping[str, bool] = {
         'name': False,
         'msg': False,
@@ -5855,7 +6185,7 @@ SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
 }
 
 
-class JournaldLogHandler(logging.Handler):
+class JournaldLoggingHandler(logging.Handler):
     """
     TODO:
      - fallback handler for when this barfs
@@ -5924,7 +6254,7 @@ class JournaldLogHandler(logging.Handler):
             self.handleError(record)
 
 
-def journald_log_handler_factory(
+def journald_logging_handler_factory(
         *,
         no_tty_check: bool = False,
         no_fallback: bool = False,
@@ -5934,7 +6264,7 @@ def journald_log_handler_factory(
             (no_tty_check or not sys.stderr.isatty()) and
             (no_fallback or sd_try_libsystemd() is not None)
     ):
-        return JournaldLogHandler()
+        return JournaldLoggingHandler()
 
     return logging.StreamHandler()
 
@@ -7735,6 +8065,7 @@ inj = InjectionApi()
 # ../../../omlish/logs/standard.py
 """
 TODO:
+ - !! move to std !!
  - structured
  - prefixed
  - debug
@@ -7756,7 +8087,7 @@ STANDARD_LOG_FORMAT_PARTS = [
 ]
 
 
-class StandardLogFormatter(logging.Formatter):
+class StandardLoggingFormatter(logging.Formatter):
     @staticmethod
     def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
         return ' '.join(v for k, v in parts)
@@ -7775,7 +8106,7 @@ class StandardLogFormatter(logging.Formatter):
 ##
 
 
-class StandardConfiguredLogHandler(ProxyLogHandler):
+class StandardConfiguredLoggingHandler(ProxyLoggingHandler):
     def __init_subclass__(cls, **kwargs):
         raise TypeError('This class serves only as a marker and should not be subclassed.')
 
@@ -7808,7 +8139,7 @@ def configure_standard_logging(
         target: ta.Optional[logging.Logger] = None,
         force: bool = False,
         handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardConfiguredLogHandler]:
+) -> ta.Optional[StandardConfiguredLoggingHandler]:
     with _locking_logging_module_lock():
         if target is None:
             target = logging.root
@@ -7816,7 +8147,7 @@ def configure_standard_logging(
         #
 
         if not force:
-            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
+            if any(isinstance(h, StandardConfiguredLoggingHandler) for h in list(target.handlers)):
                 return None
 
         #
@@ -7830,14 +8161,14 @@ def configure_standard_logging(
 
         formatter: logging.Formatter
         if json:
-            formatter = JsonLogFormatter()
+            formatter = JsonLoggingFormatter()
         else:
-            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+            formatter = StandardLoggingFormatter(StandardLoggingFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
         handler.setFormatter(formatter)
 
         #
 
-        handler.addFilter(TidLogFilter())
+        handler.addFilter(TidLoggingFilter())
 
         #
 
@@ -7850,7 +8181,7 @@ def configure_standard_logging(
 
         #
 
-        return StandardConfiguredLogHandler(handler)
+        return StandardConfiguredLoggingHandler(handler)
 
 
 ########################################
@@ -8639,6 +8970,9 @@ class Dispatchers(KeyedCollection[Fd, FdioHandler]):
 # ../dispatchersimpl.py
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 
@@ -9066,6 +9400,9 @@ class PidHistory(ta.Dict[Pid, Process]):
 # ../setupimpl.py
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 
@@ -9540,6 +9877,9 @@ class ProcessGroupManager(
 # ../io.py
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 
@@ -9788,6 +10128,9 @@ class ProcessSpawningFactory(Func1[Process, ProcessSpawning]):
     pass
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 
@@ -10264,6 +10607,9 @@ class ProcessImpl(Process):
 # ../signals.py
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 
@@ -10636,6 +10982,9 @@ def check_execv_args(
 # ../supervisor.py
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 
@@ -11023,7 +11372,7 @@ def main(
     if not no_logging:
         configure_standard_logging(
             'INFO',
-            handler_factory=journald_log_handler_factory if not (args.no_journald or is_debugger_attached()) else None,
+            handler_factory=journald_logging_handler_factory if not (args.no_journald or is_debugger_attached()) else None,  # noqa
         )
 
     #

ominfra/supervisor/dispatchersimpl.py

@@ -5,7 +5,7 @@ import os
 import typing as ta
 
 from omlish.lite.abstract import Abstract
-from omlish.lite.logs import log
+from omlish.logs.modules import get_module_logger
 
 from .configs import ProcessConfig
 from .configs import ServerConfig
@@ -26,6 +26,9 @@ from .utils.strings import find_prefix_at_end
 from .utils.strings import strip_escapes
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 

ominfra/supervisor/io.py

@@ -2,7 +2,7 @@
 import typing as ta
 
 from omlish.io.fdio.pollers import FdioPoller
-from omlish.lite.logs import log
+from omlish.logs.modules import get_module_logger
 
 from .dispatchers import Dispatchers
 from .types import ExitNow
@@ -10,6 +10,9 @@ from .types import HasDispatchers
 from .utils.ostypes import Fd
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 

ominfra/supervisor/main.py

@@ -42,7 +42,7 @@ from omlish.lite.configs import load_config_file_obj
 from omlish.lite.inject import inj
 from omlish.lite.runtime import is_debugger_attached
 from omlish.logs.standard import configure_standard_logging
-from omlish.os.journald import journald_log_handler_factory
+from omlish.os.journald import journald_logging_handler_factory
 
 from .configs import ServerConfig
 from .configs import prepare_server_config
@@ -83,7 +83,7 @@ def main(
     if not no_logging:
         configure_standard_logging(
             'INFO',
-            handler_factory=journald_log_handler_factory if not (args.no_journald or is_debugger_attached()) else None,
+            handler_factory=journald_logging_handler_factory if not (args.no_journald or is_debugger_attached()) else None,  # noqa
         )
 
     #

ominfra/supervisor/processimpl.py

@@ -7,8 +7,8 @@ import traceback
 import typing as ta
 
 from omlish.lite.check import check
-from omlish.lite.logs import log
 from omlish.lite.typing import Func1
+from omlish.logs.modules import get_module_logger
 
 from .configs import ProcessConfig
 from .configs import RestartUnconditionally
@@ -36,6 +36,9 @@ class ProcessSpawningFactory(Func1[Process, ProcessSpawning]):
     pass
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##