omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/configs/types.py

@@ -3,7 +3,7 @@
 import typing as ta
 
 
-ConfigMap = ta.Mapping[str, ta.Any]
+ConfigMap = ta.Mapping[str, ta.Any]  # ta.TypeAlias
 
 
 ##

omlish/daemons/__init__.py

@@ -0,0 +1,70 @@
+from .. import lang as _lang  # noqa
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .daemon import (  # noqa
+        Daemon,
+    )
+
+    from .launching import (  # noqa
+        Launcher,
+    )
+
+    from .services import (  # noqa
+        Service,
+
+        ServiceTarget,
+        ServiceTargetRunner,
+
+        ServiceConfigTarget,
+        ServiceConfigTargetRunner,
+    )
+
+    from .spawning import (  # noqa
+        Spawning,
+        Spawn,
+        Spawner,
+        InProcessSpawner,
+        spawner_for,
+
+        MultiprocessingSpawning,
+        MultiprocessingSpawner,
+
+        ForkSpawning,
+        ForkSpawner,
+
+        ThreadSpawning,
+        ThreadSpawner,
+    )
+
+    from .targets import (  # noqa
+        Target,
+        TargetRunner,
+        target_runner_for,
+
+        FnTarget,
+        FnTargetRunner,
+
+        NameTarget,
+        NameTargetRunner,
+
+        ExecTarget,
+        ExecTargetRunner,
+    )
+
+    from .waiting import (  # noqa
+        Wait,
+        Waiter,
+        waiter_for,
+
+        SequentialWait,
+        SequentialWaiter,
+
+        FnWait,
+        FnWaiter,
+
+        ConnectWait,
+        ConnectWaiter,
+    )

omlish/daemons/daemon.py

@@ -16,13 +16,13 @@ TODO:
  - pickle protocol, revision / venv check, multiprocessing manager support
 """
 import itertools
-import logging
 import os.path
 import time
 
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from ..logs import all as logs
 from ..os.pidfiles.pidfile import Pidfile
 from .launching import Launcher
 from .spawning import Spawning
@@ -31,7 +31,7 @@ from .waiting import Wait
 from .waiting import waiter_for
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##

omlish/daemons/launching.py

@@ -5,12 +5,12 @@ TODO:
 """
 import contextlib
 import functools
-import logging
 import threading
 import typing as ta
 
 from .. import check
 from .. import lang
+from ..logs import all as logs
 from ..os.pidfiles.manager import open_inheritable_pidfile
 from ..os.pidfiles.pidfile import Pidfile
 from .reparent import reparent_process
@@ -23,7 +23,7 @@ from .targets import Target
 from .targets import target_runner_for
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##

omlish/daemons/reparent.py

@@ -10,13 +10,12 @@ def reparent_process(
         no_close_stdio: bool = False,
 ) -> None:
     if (pid := os.fork()):  # noqa
-        sys.exit(0)
-        raise RuntimeError('Unreachable')  # noqa
+        raise SystemExit(0)
 
     os.setsid()
 
     if (pid := os.fork()):  # noqa
-        sys.exit(0)
+        raise SystemExit(0)
 
     if not no_close_stdio:
         rn_fd = os.open('/dev/null', os.O_RDONLY)

omlish/daemons/spawning.py

@@ -2,7 +2,6 @@ import abc
 import enum
 import functools
 import os
-import sys
 import threading
 import typing as ta
 
@@ -166,9 +165,9 @@ class ForkSpawner(Spawner, dc.Frozen):
         try:
             spawn.fn()
         except BaseException:  # noqa
-            sys.exit(1)
+            raise SystemExit(1) from None
         else:
-            sys.exit(0)
+            raise SystemExit(0)
 
         raise RuntimeError('Unreachable')  # noqa
 

omlish/dataclasses/__init__.py

@@ -119,11 +119,6 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         ClassSpec,
     )
 
-    from .tools.as_ import (  # noqa
-        shallow_asdict,
-        shallow_astuple,
-    )
-
     from .tools.iter import (  # noqa
         fields_dict,
 
@@ -158,9 +153,14 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
     # lite imports
 
     from ..lite.dataclasses import (  # noqa
+        dataclass_shallow_asdict as shallow_asdict,
+        dataclass_shallow_astuple as shallow_astuple,
+
         is_immediate_dataclass,
 
         dataclass_maybe_post_init as maybe_post_init,
+
+        dataclass_descriptor_method as descriptor_method,
     )
 
 

omlish/dataclasses/errors.py

@@ -6,7 +6,7 @@ import typing as ta
 
 
 def _hands_off_repr(obj: ta.Any) -> str:
-    return f'{obj.__class__.__qualname__}@{hex(id(obj))[2:]}'
+    return f'{obj.__class__.__qualname__}@{id(obj):x}'
 
 
 def _fn_repr(fn: ta.Callable) -> str:

omlish/dataclasses/impl/api/classes/decorator.py

@@ -10,6 +10,7 @@ from ..... import lang
 from ...._internals import STD_FIELDS_ATTR
 from ...._internals import STD_PARAMS_ATTR
 from ....specs import ClassSpec
+from ....specs import ReprFn
 from ...processing.driving import drive_cls_processing
 from ...utils import class_decorator
 from ..fields.building import build_cls_std_fields
@@ -53,6 +54,7 @@ def dataclass(
 
         repr_id: bool | None = None,
         terse_repr: bool | None = None,
+        default_repr_fn: ReprFn | None = None,
 
         allow_redundant_decorator: bool | None = None,
 
@@ -158,6 +160,7 @@ def dataclass(
 
                 repr_id=repr_id,
                 terse_repr=terse_repr,
+                default_repr_fn=default_repr_fn,
 
                 allow_redundant_decorator=allow_redundant_decorator,
             ),

omlish/dataclasses/impl/api/classes/make.py

@@ -4,6 +4,7 @@ import sys
 import types
 import typing as ta
 
+from ....specs import ReprFn
 from .decorator import dataclass
 
 
@@ -53,6 +54,7 @@ def make_dataclass(  # noqa
 
         repr_id: bool | None = None,
         terse_repr: bool | None = None,
+        default_repr_fn: ReprFn | None = None,
 
         allow_redundant_decorator: bool | None = None,
 
@@ -142,7 +144,7 @@ def make_dataclass(  # noqa
 
     if module is None:
         try:
-            module = sys._getframemodulename(_frame_offset) or '__main__'  # type: ignore  # noqa
+            module = sys._getframemodulename(_frame_offset) or '__main__'  # noqa
         except AttributeError:
             with contextlib.suppress(AttributeError, ValueError):
                 module = sys._getframe(_frame_offset).f_globals.get('__name__', '__main__')  # noqa
@@ -174,6 +176,7 @@ def make_dataclass(  # noqa
 
         repr_id=repr_id,
         terse_repr=terse_repr,
+        default_repr_fn=default_repr_fn,
 
         allow_redundant_decorator=allow_redundant_decorator,
     )

omlish/dataclasses/impl/concerns/doc.py

@@ -36,7 +36,7 @@ def _build_cls_doc(cls: type) -> str:
 
 
 class _LazyClsDocDescriptor:
-    def __get__(self, instance, owner):
+    def __get__(self, instance, owner=None):
         if instance is not None:
             owner = instance.__class__
         if not owner:

omlish/dataclasses/impl/concerns/repr.py

@@ -32,6 +32,7 @@ class ReprPlan(Plan):
 
     id: bool = False
     terse: bool = False
+    default_fn: OpRef[ReprFn] | None = None
 
 
 @register_generator_type(ReprPlan)
@@ -66,11 +67,17 @@ class ReprGenerator(Generator[ReprPlan]):
                 fn=fnr,
             ))
 
+        drf: OpRef | None = None
+        if ctx.cs.default_repr_fn is not None:
+            drf = OpRef(f'repr.default_fn')
+            orm[drf] = ctx.cs.default_repr_fn
+
         return PlanResult(
             ReprPlan(
                 fields=tuple(rfs),
                 id=ctx.cs.repr_id,
                 terse=ctx.cs.terse_repr,
+                default_fn=drf,
             ),
             orm,
         )
@@ -85,10 +92,16 @@ class ReprGenerator(Generator[ReprPlan]):
             if not (pl.terse and not f.kw_only):
                 pfx = f'{f.name}='
 
+            fn: OpRef[ReprFn] | None = None
             if f.fn is not None:
-                ors.add(f.fn)
+                fn = f.fn
+            elif pl.default_fn is not None:
+                fn = pl.default_fn
+
+            if fn is not None:
+                ors.add(fn)
                 part_lines.extend([
-                    f'    if (s := {f.fn.ident()}(self.{f.name})) is not None:',
+                    f'    if (s := {fn.ident()}(self.{f.name})) is not None:',
                     f'        parts.append(f"{pfx}{{s}}")',
                 ])
             else:

omlish/dataclasses/impl/configs.py

@@ -1,6 +1,14 @@
+"""
+TODO:
+ - better support anonymous / weakref'd / unlaoded modules / etc.
+  - anonymous=False on class spec?
+"""
 import dataclasses as dc
+import threading
 import typing as ta
 
+from ... import check
+
 
 ##
 
@@ -19,51 +27,104 @@ DEFAULT_PACKAGE_CONFIG = PackageConfig()
 ##
 
 
-def init_package(
-        init_globals: ta.MutableMapping[str, ta.Any],
-        *,
-        codegen: bool = False,
-) -> None:
-    pass
+@dc.dataclass(frozen=True)
+class NamedPackageConfig:
+    pkg: str | None
+    cfg: PackageConfig
+
+
+DEFAULT_NAMED_PACKAGE_CONFIG = NamedPackageConfig(None, DEFAULT_PACKAGE_CONFIG)
 
 
 ##
 
 
+@ta.final
 class PackageConfigCache:
     def __init__(self) -> None:
         super().__init__()
 
-        self._dct: dict[str, PackageConfig | None] = {}
-
-    @ta.overload
-    def get(self, pkg: str, default: PackageConfig) -> PackageConfig:
-        ...
-
-    @ta.overload
-    def get(self, pkg: str, default: PackageConfig | None = None) -> PackageConfig | None:
-        ...
-
-    def get(self, pkg, default=None):
-        # try:
-        #     return self._dct[pkg]
-        # except KeyError:
-        #     pass
-        #
-        # try:
-        #     s = importlib.resources.read_text(pkg, PACKAGE_CONFIG_FILE_NAME)
-        # except FileNotFoundError:
-        #     self._dct[pkg] = None
-        # else:
-        #     c = PackageConfig.loads(s)
-        #     self._dct[pkg] = c
-        #     return c
-        #
-        # if '.' not in pkg:
-        #     return default
-        #
-        # return self.get(pkg.rpartition('.')[0], default)
-        return None
+        self._lock = threading.Lock()
+        self._root = PackageConfigCache._Node('', None)
+        self._nodes: dict[str, PackageConfigCache._Node] = {}
+
+    @ta.final
+    class _Node:
+        def __init__(self, pkg: str, n_cfg: NamedPackageConfig | None) -> None:
+            self.pkg = pkg
+            self.n_cfg = n_cfg
+
+            self.children: dict[str, PackageConfigCache._Node] = {}
+
+        def __repr__(self) -> str:
+            return f'{self.__class__.__name__}(pkg={self.pkg!r}, n_cfg={self.n_cfg!r})'
+
+    def _navigate(self, *parts: str) -> _Node:
+        node = self._root
+        for i, p in enumerate(parts):
+            if (child := node.children.get(p)) is None:
+                child_pkg = '.'.join(parts[:i + 1])
+                check.not_in(child_pkg, self._nodes)
+                child = node.children[p] = self._nodes[child_pkg] = PackageConfigCache._Node(child_pkg, node.n_cfg)
+            node = child
+        return node
+
+    def put(self, pkg: str, cfg: PackageConfig) -> None:
+        n_cfg = NamedPackageConfig(pkg, cfg)
+        check.non_empty_str(pkg)
+        with self._lock:
+            check.not_in(pkg, self._nodes)
+            parts = pkg.split('.')
+            parent = self._navigate(*parts[:-1])
+            check.not_in(parts[-1], parent.children)
+            parent.children[parts[-1]] = self._nodes[pkg] = PackageConfigCache._Node(pkg, n_cfg)
+
+    def get(self, pkg: str) -> NamedPackageConfig | None:
+        if not pkg:
+            return None
+
+        try:
+            node = self._nodes[pkg]
+        except KeyError:
+            pass
+        else:
+            return node.n_cfg
+
+        # Flimsy - if no config anywhere for root package then don't cache. Want to support unlimited anonymous modules
+        # which may be unloaded without polluting cache forever.
+        parts = pkg.split('.')
+        if parts[0] not in self._root.children:
+            return None
+
+        with self._lock:
+            try:
+                node = self._nodes[pkg]
+            except KeyError:
+                pass
+            else:
+                return node.n_cfg
+
+            node = self._navigate(*pkg.split('.'))
+            return node.n_cfg
 
 
 PACKAGE_CONFIG_CACHE = PackageConfigCache()
+
+
+##
+
+
+def init_package(
+        init_globals: ta.MutableMapping[str, ta.Any],
+        *,
+        codegen: bool = False,
+) -> None:
+    pkg = check.non_empty_str(init_globals['__package__'])
+    if init_globals['__name__'] not in (pkg, '__main__'):
+        raise NameError('Must call dataclasses.init_package from __init__')
+
+    pkg_cfg = PackageConfig(
+        codegen=codegen,
+    )
+
+    PACKAGE_CONFIG_CACHE.put(pkg, pkg_cfg)

omlish/dataclasses/impl/generation/compilation.py

@@ -64,7 +64,6 @@ class OpCompiler:
                     f'import {i}'
                     for i in FN_GLOBAL_IMPORTS
                 ],
-                '\n',
             ]
 
         def globals_ns(self) -> ta.Mapping[str, ta.Any]:
@@ -84,11 +83,14 @@ class OpCompiler:
     def style(self) -> Style:
         return self._style
 
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class CompileResult:
         fn_name: str
-        params: ta.Sequence[str]
-        src: str
+        fn_params: ta.Sequence[str]
+
+        hdr_lines: ta.Sequence[str]
+        fn_lines: ta.Sequence[str]
+
         refs: frozenset[Ref]
 
     @dc.dataclass(frozen=True)
@@ -137,7 +139,10 @@ class OpCompiler:
     ) -> CompileResult:
         body_lines: list[str] = []
 
-        for op in ops:
+        for i, op in enumerate(ops):
+            if i:
+                body_lines.append('')
+
             if isinstance(op, SetAttrOp):
                 if isinstance(v := op.value, OpRef):
                     vs = v.ident()
@@ -202,8 +207,6 @@ class OpCompiler:
             else:
                 raise TypeError(op)
 
-            body_lines.append('')
-
         #
 
         refs = frozenset.union(*[get_op_refs(o) for o in ops])
@@ -226,14 +229,12 @@ class OpCompiler:
                 src=f'{k.ident}={v.src}' if not v.src.startswith('.') else k.ident,
                 noqa=k.ident != k.ident.lower() or not v.src.startswith('.'),
             )
-            for k, v in FN_GLOBALS.items()
+            for k, v in sorted(FN_GLOBALS.items(), key=lambda t: t[0])
         ])
 
-        lines: list[str] = []
-
-        lines.extend(self._style.header_lines())
+        #
 
-        lines.extend([
+        fn_lines = [
             f'def {fn_name}(',
             f'    *,',
             *[
@@ -245,15 +246,16 @@ class OpCompiler:
                 f'    {l}'
                 for l in body_lines
             ],
-        ])
+        ]
 
         #
 
-        src = '\n'.join(lines)
-
         return self.CompileResult(
-            fn_name,
-            [p.name for p in params],
-            src,
-            refs,
+            fn_name=fn_name,
+            fn_params=[p.name for p in params],
+
+            hdr_lines=self._style.header_lines(),
+            fn_lines=fn_lines,
+
+            refs=refs,
         )

omlish/dataclasses/impl/generation/globals.py

@@ -12,6 +12,7 @@ from .idents import IDENT_PREFIX
 ##
 
 
+@ta.final
 class FnGlobal(ta.NamedTuple):
     ident: str
 

omlish/dataclasses/impl/generation/ops.py

@@ -16,6 +16,7 @@ class _OpRef(ta.NamedTuple, ta.Generic[T]):
     name: str
 
 
+@ta.final
 class OpRef(_OpRef[T]):
     def __repr__(self) -> str:
         return f'OpRef(name={self.name!r})'