omlish 0.0.0.dev235__tar.gz → 0.0.0.dev237__tar.gz

{omlish-0.0.0.dev235/omlish.egg-info → omlish-0.0.0.dev237}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev235
+Version: 0.0.0.dev237
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev235'
-__revision__ = '4afeb0f0acadfd7890e6e6309be41fe7e65c3185'
+__version__ = '0.0.0.dev237'
+__revision__ = 'e8c58292f1ec88727fd832f6496545435d992e9d'
 
 
 #

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/argparse/all.py

@@ -4,6 +4,7 @@ import argparse
 from .cli import (  # noqa
     ArgparseArg as Arg,
     argparse_arg as arg,
+    argparse_arg_ as arg_,
 
     ArgparseCmdFn as CmdFn,
     ArgparseCmd as Cmd,

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/argparse/cli.py

@@ -1,6 +1,9 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 """
+FIXME:
+ - exit_on_error lol
+
 TODO:
  - default command
  - auto match all underscores to hyphens
@@ -44,6 +47,10 @@ def argparse_arg(*args, **kwargs) -> ArgparseArg:
     return ArgparseArg(args, kwargs)
 
 
+def argparse_arg_(*args, **kwargs) -> ta.Any:
+    return argparse_arg(*args, **kwargs)
+
+
 #
 
 

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/codecs/base.py

@@ -12,6 +12,7 @@ from .. import dataclasses as dc
 from .. import lang
 from .. import reflect as rfl
 from ..funcs import pairs as fps
+from ..manifests.base import ModAttrManifest
 
 
 I = ta.TypeVar('I')
@@ -87,9 +88,7 @@ class Codec:
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class LazyLoadedCodec:
-    mod_name: str
-    attr_name: str
+class LazyLoadedCodec(ModAttrManifest):
     name: str
     aliases: ta.Collection[str] | None = None
 

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/codecs/registry.py

@@ -1,5 +1,4 @@
 import contextlib
-import importlib
 import threading
 import typing as ta
 
@@ -74,8 +73,7 @@ class CodecRegistry:
             codec_or_lazy = self._by_name[name]
 
             if isinstance(codec_or_lazy, LazyLoadedCodec):
-                mod = importlib.import_module(codec_or_lazy.mod_name)
-                codec = check.isinstance(getattr(mod, codec_or_lazy.attr_name), Codec)
+                codec = check.isinstance(codec_or_lazy.load(), Codec)
                 self._by_name[name] = codec
                 self._post_load(codec)
             else:

omlish-0.0.0.dev237/omlish/configs/classes.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+ConfigurableConfigT = ta.TypeVar('ConfigurableConfigT', bound='Configurable.Config')
+
+
+class Configurable(ta.Generic[ConfigurableConfigT], lang.Abstract):
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Config:
+        """Does not use any dc metaclasses to preserve typechecking."""
+
+        configurable_cls: ta.ClassVar[type['Configurable']]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if not lang.is_abstract_class(cls):
+            check.in_('Config', cls.__dict__)
+            cfg_cls = check.issubclass(cls.Config, Configurable.Config)
+            check.not_in('configurable_cls', cfg_cls.__dict__)
+            check.state(dc.is_immediate_dataclass(cfg_cls))
+            cfg_cls.configurable_cls = cls
+
+    def __init__(self, config: ConfigurableConfigT) -> None:
+        super().__init__()
+
+        self._config: ConfigurableConfigT = check.isinstance(config, self.Config)  # type: ignore[assignment]

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/configs/processing/all.py

@@ -13,6 +13,10 @@ from .matching import (  # noqa
     matched_config_rewrite as matched_rewrite,
 )
 
+from .merging import (  # noqa
+    merge_configs as merge,
+)
+
 from .names import (  # noqa
     build_config_named_children as build_named_children,
 )

omlish-0.0.0.dev237/omlish/configs/processing/merging.py

@@ -0,0 +1,33 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - smarter merging than just dumb dict-squashing
+"""
+import typing as ta
+
+from ..types import ConfigMap
+
+
+##
+
+
+def merge_configs(*ms: ConfigMap) -> ConfigMap:
+    def rec(o, i):
+        for k, v in i.items():
+            try:
+                e = o[k]
+            except KeyError:
+                o[k] = v
+            else:
+                if isinstance(e, ta.Mapping) and isinstance(v, ta.Mapping):
+                    rec(e, v)  # noqa
+                else:
+                    if isinstance(v, ta.Mapping):
+                        v = dict(v)
+                    o[k] = v
+
+    o: dict = {}
+    for i in ms:
+        rec(o, i)
+    return o

omlish-0.0.0.dev237/omlish/configs/shadow.py

@@ -0,0 +1,92 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - cascading?
+ - caching?
+ - purging?
+ - wishlist: piecewise config parts, unmarshal, registered via manifests
+"""
+import abc
+import os.path
+import typing as ta
+
+from ..lite.check import check
+from ..os.mangle import mangle_path
+from .formats import DEFAULT_CONFIG_LOADERS
+from .formats import ConfigLoader
+
+
+ShadowConfig = ta.Mapping[str, ta.Any]  # ta.TypeAlias
+
+
+##
+
+
+class ShadowConfigs(abc.ABC):
+    @abc.abstractmethod
+    def get_shadow_config(self, path: str) -> ta.Optional[ShadowConfig]:
+        raise NotImplementedError
+
+
+class FileShadowConfigs(ShadowConfigs, abc.ABC):
+    @abc.abstractmethod
+    def get_shadow_config_file_path(self, path: str) -> str:
+        raise NotImplementedError
+
+
+##
+
+
+class NopShadowConfigs(ShadowConfigs):
+    def get_shadow_config(self, path: str) -> ta.Optional[ShadowConfig]:
+        return None
+
+
+##
+
+
+class MangledFilesShadowConfigs(FileShadowConfigs):
+    def __init__(
+            self,
+            path: str,
+            *,
+            create: bool = False,
+            ext: str = 'yml',
+            loader: ta.Optional[ConfigLoader] = None,
+    ) -> None:  # noqa
+        super().__init__()
+
+        check.arg(not ext.startswith('.'))
+        check.non_empty_str(ext)
+
+        if loader is None:
+            for dl in DEFAULT_CONFIG_LOADERS:
+                if dl.match_file(f'.{ext}'):
+                    loader = dl
+                    break
+            else:
+                raise KeyError(ext)
+
+        self._path = path
+        self._create = create
+        self._ext = ext
+        self._loader = loader
+
+    def get_shadow_config_file_path(self, path: str) -> str:
+        mangled = '.'.join([mangle_path(os.path.abspath(path)), self._ext])
+        return os.path.abspath(os.path.join(self._path, mangled))
+
+    def get_shadow_config(self, path: str) -> ta.Optional[ShadowConfig]:
+        file_path = self.get_shadow_config_file_path(path)
+
+        if self._create:
+            os.makedirs(self._path, exist_ok=True)
+
+        try:
+            with open(file_path) as f:
+                content = f.read()
+        except FileNotFoundError:
+            return None
+
+        return self._loader.load_str(content).as_map()

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/daemons/daemon.py

@@ -15,6 +15,7 @@ TODO:
  - timebomb
  - pickle protocol, revision / venv check, multiprocessing manager support
 """
+import itertools
 import logging
 import os.path
 import time
@@ -39,8 +40,7 @@ log = logging.getLogger(__name__)
 class Daemon:
     @dc.dataclass(frozen=True, kw_only=True)
     class Config:
-        target: Target
-        spawning: Spawning
+        spawning: Spawning | None = None
 
         #
 
@@ -63,11 +63,20 @@ class Daemon:
         def __post_init__(self) -> None:
             check.isinstance(self.pid_file, (str, None))
 
-    def __init__(self, config: Config) -> None:
+    def __init__(
+            self,
+            target: Target,
+            config: Config = Config(),
+    ) -> None:
         super().__init__()
 
+        self._target = target
         self._config = config
 
+    @property
+    def target(self) -> Target:
+        return self._target
+
     @property
     def config(self) -> Config:
         return self._config
@@ -85,7 +94,7 @@ class Daemon:
             inheritable=False,
         )
 
-    def is_running(self) -> bool:
+    def is_pidfile_locked(self) -> bool:
         check.state(self.has_pidfile)
 
         if not os.path.isfile(check.non_empty_str(self._config.pid_file)):
@@ -96,22 +105,31 @@ class Daemon:
 
     #
 
-    def wait_sync(self, timeout: lang.TimeoutLike = lang.Timeout.Default) -> None:
+    def wait_sync(
+            self,
+            timeout: lang.TimeoutLike = lang.Timeout.Default,
+            *,
+            max_tries: int | None = None,
+    ) -> None:
         if self._config.wait is None:
             return
 
         timeout = lang.Timeout.of(timeout, self._config.wait_timeout)
         waiter = waiter_for(self._config.wait)
-        while not waiter.do_wait():
+        for i in itertools.count():
+            if max_tries is not None and i >= max_tries:
+                raise TimeoutError
             timeout()
+            if waiter.do_wait():
+                break
             time.sleep(self._config.wait_sleep_s or 0.)
 
     #
 
     def launch_no_wait(self) -> None:
         launcher = Launcher(
-            target=self._config.target,
-            spawning=self._config.spawning,
+            target=self._target,
+            spawning=check.not_none(self._config.spawning),
 
             pid_file=self._config.pid_file,
             reparent_process=self._config.reparent_process,

omlish-0.0.0.dev237/omlish/daemons/services.py

@@ -0,0 +1,34 @@
+import abc
+import typing as ta
+
+from .. import check
+from .. import lang
+from ..configs.classes import Configurable
+
+
+ServiceConfigT = ta.TypeVar('ServiceConfigT', bound='Service.Config')
+
+
+##
+
+
+class Service(Configurable[ServiceConfigT], lang.Abstract):
+    class Config(Configurable.Config, lang.Abstract):
+        pass
+
+    @classmethod
+    def from_config(cls, config: Config) -> 'Service':
+        return check.isinstance(config.configurable_cls(config), cls)
+
+    #
+
+    @abc.abstractmethod
+    def _run(self) -> None:
+        raise NotImplementedError
+
+    def run(self) -> None:
+        self._run()
+
+    @classmethod
+    def run_config(cls, config: Config) -> None:
+        return cls.from_config(config).run()

omlish-0.0.0.dev237/omlish/daemons/targets.py

@@ -0,0 +1,157 @@
+import abc
+import functools
+import os
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from .services import Service
+
+
+if ta.TYPE_CHECKING:
+    import runpy
+else:
+    runpy = lang.proxy_import('runpy')
+
+
+##
+
+
+class Target(dc.Case):
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'Target':
+        if isinstance(obj, Target):
+            return obj
+
+        elif isinstance(obj, str):
+            return NameTarget(obj)
+
+        elif callable(obj):
+            return FnTarget(obj)
+
+        elif isinstance(obj, Service.Config):
+            return ServiceConfigTarget(obj)
+
+        else:
+            raise TypeError(obj)
+
+
+class TargetRunner(abc.ABC):
+    @abc.abstractmethod
+    def run(self) -> None:
+        raise NotImplementedError
+
+
+@functools.singledispatch
+def target_runner_for(target: Target) -> TargetRunner:
+    raise TypeError(target)
+
+
+##
+
+
+class FnTarget(Target):
+    fn: ta.Callable[[], ta.Any]
+
+
+class FnTargetRunner(TargetRunner, dc.Frozen):
+    target: FnTarget
+
+    def run(self) -> None:
+        obj = self.target.fn()
+        if obj is not None:
+            tgt = Target.of(obj)
+            tr = target_runner_for(tgt)
+            tr.run()
+
+
+@target_runner_for.register
+def _(target: FnTarget) -> FnTargetRunner:
+    return FnTargetRunner(target)
+
+
+##
+
+
+class NameTarget(Target):
+    name: str
+
+    @classmethod
+    def for_obj(
+            cls,
+            obj: ta.Any,
+            *,
+            globals: ta.Mapping[str, ta.Any] | None = None,  # noqa
+            no_module_name_lookup: bool = False,
+    ) -> 'NameTarget':
+        if globals is None:
+            globals = obj.__globals__  # noqa
+        if not no_module_name_lookup:
+            mn = lang.get_real_module_name(globals)
+        else:
+            mn = globals['__name__']
+        qn = obj.__qualname__
+        return NameTarget('.'.join([mn, qn]))
+
+
+class NameTargetRunner(TargetRunner, dc.Frozen):
+    target: NameTarget
+
+    def run(self) -> None:
+        name = self.target.name
+        if lang.can_import(name):
+            runpy._run_module_as_main(name)  # type: ignore  # noqa
+        else:
+            obj = lang.import_attr(self.target.name)
+            tgt = Target.of(obj)
+            tr = target_runner_for(tgt)
+            tr.run()
+
+
+@target_runner_for.register
+def _(target: NameTarget) -> NameTargetRunner:
+    return NameTargetRunner(target)
+
+
+##
+
+
+class ExecTarget(Target):
+    cmd: ta.Sequence[str] = dc.xfield(coerce=check.of_not_isinstance(str))
+
+    cwd: str | None = None
+
+
+class ExecTargetRunner(TargetRunner, dc.Frozen):
+    target: ExecTarget
+
+    def run(self) -> None:
+        if (cwd := self.target.cwd) is not None:
+            os.chdir(os.path.expanduser(cwd))
+
+        os.execl(*self.target.cmd)
+
+
+@target_runner_for.register
+def _(target: ExecTarget) -> ExecTargetRunner:
+    return ExecTargetRunner(target)
+
+
+##
+
+
+class ServiceConfigTarget(Target):
+    cfg: Service.Config
+
+
+class ServiceConfigTargetRunner(TargetRunner, dc.Frozen):
+    target: ServiceConfigTarget
+
+    def run(self) -> None:
+        Service.run_config(self.target.cfg)
+
+
+@target_runner_for.register
+def _(target: ServiceConfigTarget) -> ServiceConfigTargetRunner:
+    return ServiceConfigTargetRunner(target)

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/lang/__init__.py

@@ -135,6 +135,7 @@ from .generators import (  # noqa
 
 from .imports import (  # noqa
     can_import,
+    get_real_module_name,
     import_all,
     import_attr,
     import_module,

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/lang/imports.py

@@ -384,3 +384,18 @@ def proxy_init(
             raise Exception(f'Wrong init name: {pi.name_package=} != {init_name_package=}')
 
     pi.add(package, attrs)
+
+
+##
+
+
+def get_real_module_name(globals: ta.Mapping[str, ta.Any]) -> str:  # noqa
+    module = sys.modules[globals['__name__']]
+
+    if module.__spec__ and module.__spec__.name:
+        return module.__spec__.name
+
+    if module.__package__:
+        return module.__package__
+
+    raise RuntimeError("Can't determine real module name")

omlish-0.0.0.dev237/omlish/manifests/base.py

@@ -0,0 +1,39 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import typing as ta
+
+
+NameAliasesManifestT = ta.TypeVar('NameAliasesManifestT', bound='NameAliasesManifest')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ModAttrManifest:
+    mod_name: str
+    attr_name: str
+
+    def load(self) -> ta.Any:
+        importlib = __import__('importlib')
+        mod = importlib.import_module(self.mod_name)
+        return getattr(mod, self.attr_name)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class NameAliasesManifest:
+    name: str
+    aliases: ta.Optional[ta.Collection[str]] = None
+
+    @classmethod
+    def build_name_dict(cls, objs: ta.Iterable[NameAliasesManifestT]) -> ta.Dict[str, NameAliasesManifestT]:
+        dct: ta.Dict[str, NameAliasesManifestT] = {}
+        for o in objs:
+            for n in (o.name, *(o.aliases or ())):
+                if n in dct:
+                    raise KeyError(n)
+                dct[n] = o
+        return dct

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/manifests/load.py

@@ -196,11 +196,11 @@ class ManifestLoader:
 
     def discover_pkgs(self) -> ta.Sequence[str]:
         # This is a fat dep so do it late.
-        import importlib.metadata
+        importlib_metadata = __import__('importlib.metadata').metadata
 
         return [
             ep.value
-            for ep in importlib.metadata.entry_points(group=self.ENTRY_POINT_GROUP)
+            for ep in importlib_metadata.entry_points(group=self.ENTRY_POINT_GROUP)
         ]
 
     def scan_pkg_root(self, root: str) -> ta.Sequence[str]:

{omlish-0.0.0.dev235 → omlish-0.0.0.dev237}/omlish/os/filemodes.py

@@ -77,6 +77,48 @@ class FileMode:
             )
         )
 
+    @classmethod
+    def from_flags(cls, i: int) -> 'FileMode':
+        if i & os.O_RDWR:
+            i &= ~os.O_RDWR
+            read = write = True
+        elif i & os.O_WRONLY:
+            i &= ~os.O_WRONLY
+            write = True
+            read = False
+        else:
+            read = True
+            write = False
+
+        create = False
+        if i & os.O_CREAT:
+            i &= ~os.O_CREAT
+            create = True
+
+        exists: str | None = None
+        if i & os.O_TRUNC:
+            i &= ~os.O_TRUNC
+            exists = check.replacing_none(exists, 'truncate')
+        if i & os.O_EXCL:
+            i &= ~os.O_EXCL
+            exists = check.replacing_none(exists, 'fail')
+        if i & os.O_APPEND:
+            i &= ~os.O_APPEND
+            exists = check.replacing_none(exists, 'append')
+        if exists is None:
+            exists = 'beginning'
+
+        if i:
+            raise ValueError(i)
+
+        return FileMode(
+            read=read,
+            write=write,
+            create=create,
+            exists=exists,  # type: ignore
+            binary=True,
+        )
+
     #
 
     def render(self) -> str:

omlish-0.0.0.dev237/omlish/os/mangle.py

@@ -0,0 +1,25 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+
+
+#
+
+
+def mangle_path(path: str) -> str:
+    if not path.startswith('/'):
+        raise ValueError('Only absolute Unix paths are supported')
+    return (
+        path
+        .replace('_', '__')
+        .replace('/', '_')
+    )
+
+
+def unmangle_path(mangled: str) -> str:
+    if '/' in mangled:
+        raise ValueError("Mangled paths should not contain '/'")
+    return (
+        mangled
+        .replace('_', '/')
+        .replace('//', '_')
+    )