omlish 0.0.0.dev133__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/manifests/load.py

@@ -0,0 +1,209 @@
+# ruff: noqa: UP006 UP007
+"""
+Should be kept somewhat lightweight - used in cli entrypoints.
+
+TODO:
+ - persisted caching support - {pkg_name: manifests}
+"""
+import dataclasses as dc
+import importlib.machinery
+import importlib.resources
+import json
+import threading
+import typing as ta
+
+from .types import Manifest
+
+
+##
+
+
+class ManifestLoader:
+    def __init__(
+            self,
+            *,
+            module_remap: ta.Optional[ta.Mapping[str, str]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._lock = threading.RLock()
+
+        self._module_remap = module_remap or {}
+        self._module_reverse_remap = {v: k for k, v in self._module_remap.items()}
+
+        self._cls_cache: ta.Dict[str, type] = {}
+        self._raw_cache: ta.Dict[str, ta.Optional[ta.Sequence[Manifest]]] = {}
+
+    #
+
+    @classmethod
+    def from_entry_point(
+            cls,
+            globals: ta.Mapping[str, ta.Any],  # noqa
+            *,
+            module_remap: ta.Optional[ta.Mapping[str, str]] = None,
+            **kwargs: ta.Any,
+    ) -> 'ManifestLoader':
+        rm: ta.Dict[str, str] = {}
+
+        if module_remap:
+            rm.update(module_remap)
+
+        if '__name__' in globals and '__spec__' in globals:
+            name: str = globals['__name__']
+            spec: importlib.machinery.ModuleSpec = globals['__spec__']
+            if '__main__' not in rm and name == '__main__':
+                rm[spec.name] = '__main__'
+
+        return cls(module_remap=rm, **kwargs)
+
+    #
+
+    def _load_cls(self, key: str) -> type:
+        try:
+            return self._cls_cache[key]
+        except KeyError:
+            pass
+
+        if not key.startswith('$'):
+            raise Exception(f'Bad key: {key}')
+
+        parts = key[1:].split('.')
+        pos = next(i for i, p in enumerate(parts) if p[0].isupper())
+
+        mod_name = '.'.join(parts[:pos])
+        mod_name = self._module_remap.get(mod_name, mod_name)
+        mod = importlib.import_module(mod_name)
+
+        obj: ta.Any = mod
+        for ca in parts[pos:]:
+            obj = getattr(obj, ca)
+
+        cls = obj
+        if not isinstance(cls, type):
+            raise TypeError(cls)
+
+        self._cls_cache[key] = cls
+        return cls
+
+    def load_cls(self, key: str) -> type:
+        with self._lock:
+            return self._load_cls(key)
+
+    #
+
+    def _load_contents(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
+        if not isinstance(obj, (list, tuple)):
+            raise TypeError(obj)
+
+        lst: ta.List[Manifest] = []
+        for e in obj:
+            m = Manifest(**e)
+
+            m = dc.replace(m, module=pkg_name + m.module)
+
+            [(key, value_dct)] = m.value.items()
+            if not key.startswith('$'):
+                raise Exception(f'Bad key: {key}')
+            if key.startswith('$.'):
+                key = f'${pkg_name}{key[1:]}'
+                m = dc.replace(m, value={key: value_dct})
+
+            lst.append(m)
+
+        return lst
+
+    def load_contents(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
+        with self._lock:
+            return self.load_contents(obj, pkg_name)
+
+    #
+
+    def _load_raw(self, pkg_name: str) -> ta.Optional[ta.Sequence[Manifest]]:
+        try:
+            return self._raw_cache[pkg_name]
+        except KeyError:
+            pass
+
+        t = importlib.resources.files(pkg_name).joinpath('.manifests.json')
+        if not t.is_file():
+            self._raw_cache[pkg_name] = None
+            return None
+
+        src = t.read_text('utf-8')
+        obj = json.loads(src)
+        if not isinstance(obj, (list, tuple)):
+            raise TypeError(obj)
+
+        lst = self._load_contents(obj, pkg_name)
+
+        self._raw_cache[pkg_name] = lst
+        return lst
+
+    def load_raw(self, pkg_name: str) -> ta.Optional[ta.Sequence[Manifest]]:
+        with self._lock:
+            return self._load_raw(pkg_name)
+
+    #
+
+    def _load(
+            self,
+            *pkg_names: str,
+            only: ta.Optional[ta.Iterable[type]] = None,
+    ) -> ta.Sequence[Manifest]:
+        only_keys: ta.Optional[ta.Set]
+        if only is not None:
+            only_keys = set()
+            for cls in only:
+                if not (isinstance(cls, type) and dc.is_dataclass(cls)):
+                    raise TypeError(cls)
+                mod_name = cls.__module__
+                mod_name = self._module_reverse_remap.get(mod_name, mod_name)
+                only_keys.add(f'${mod_name}.{cls.__qualname__}')
+        else:
+            only_keys = None
+
+        lst: ta.List[Manifest] = []
+        for pn in pkg_names:
+            for manifest in (self.load_raw(pn) or []):
+                [(key, value_dct)] = manifest.value.items()
+                if only_keys is not None and key not in only_keys:
+                    continue
+
+                cls = self._load_cls(key)
+                value = cls(**value_dct)
+
+                manifest = dc.replace(manifest, value=value)
+                lst.append(manifest)
+
+        return lst
+
+    def load(
+            self,
+            *pkg_names: str,
+            only: ta.Optional[ta.Iterable[type]] = None,
+    ) -> ta.Sequence[Manifest]:
+        with self._lock:
+            return self._load(
+                *pkg_names,
+                only=only,
+            )
+
+    #
+
+    ENTRY_POINT_GROUP = 'omlish.manifests'
+
+    def discover(self) -> ta.Sequence[str]:
+        # This is a fat dep so do it late.
+        import importlib.metadata
+
+        return [
+            ep.value
+            for ep in importlib.metadata.entry_points(group=self.ENTRY_POINT_GROUP)
+        ]
+
+
+##
+
+
+MANIFEST_LOADER = ManifestLoader()

omlish/manifests/types.py

@@ -0,0 +1,17 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class ManifestOrigin:
+    module: str
+    attr: str
+
+    file: str
+    line: int
+
+
+@dc.dataclass(frozen=True)
+class Manifest(ManifestOrigin):
+    value: ta.Any

omlish/marshal/base.py

@@ -89,8 +89,8 @@ from .. import check
 from .. import collections as col
 from .. import dataclasses as dc
 from .. import lang
-from .. import matchfns as mfs
 from .. import reflect as rfl
+from ..funcs import match as mfs
 from .exceptions import UnhandledTypeError
 from .factories import RecursiveTypeFactory
 from .factories import TypeCacheFactory

omlish/marshal/factories.py

@@ -3,8 +3,8 @@ import threading
 import typing as ta
 
 from .. import check
-from .. import matchfns as mfs
 from .. import reflect as rfl
+from ..funcs import match as mfs
 
 
 R = ta.TypeVar('R')

omlish/marshal/forbidden.py

@@ -1,8 +1,8 @@
 import dataclasses as dc
 import typing as ta
 
-from .. import matchfns as mfs
 from .. import reflect as rfl
+from ..funcs import match as mfs
 from .base import MarshalContext
 from .base import Marshaler
 from .base import UnmarshalContext

omlish/marshal/iterables.py

@@ -8,8 +8,8 @@ import functools
 import typing as ta
 
 from .. import check
-from .. import matchfns as mfs
 from .. import reflect as rfl
+from ..funcs import match as mfs
 from .base import MarshalContext
 from .base import Marshaler
 from .base import MarshalerFactoryMatchClass

omlish/marshal/literals.py

@@ -0,0 +1,50 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import MarshalerFactory
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .values import Value
+
+
+@dc.dataclass(frozen=True)
+class LiteralMarshaler(Marshaler):
+    e: Marshaler
+    vs: frozenset
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        return self.e.marshal(ctx, check.in_(o, self.vs))
+
+
+class LiteralMarshalerFactory(MarshalerFactory):
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Literal)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        lty = check.isinstance(rty, rfl.Literal)
+        ety = check.single(set(map(type, lty.args)))
+        return LiteralMarshaler(ctx.make(ety), frozenset(lty.args))
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnmarshaler(Unmarshaler):
+    e: Unmarshaler
+    vs: frozenset
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        return check.in_(self.e.unmarshal(ctx, v), self.vs)
+
+
+class LiteralUnmarshalerFactory(UnmarshalerFactory):
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Literal)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        lty = check.isinstance(rty, rfl.Literal)
+        ety = check.single(set(map(type, lty.args)))
+        return LiteralUnmarshaler(ctx.make(ety), frozenset(lty.args))

omlish/marshal/mappings.py

@@ -3,8 +3,8 @@ import dataclasses as dc
 import typing as ta
 
 from .. import check
-from .. import matchfns as mfs
 from .. import reflect as rfl
+from ..funcs import match as mfs
 from .base import MarshalContext
 from .base import Marshaler
 from .base import MarshalerFactoryMatchClass

omlish/marshal/maybes.py

@@ -7,8 +7,8 @@ import typing as ta
 
 from .. import check
 from .. import lang
-from .. import matchfns as mfs
 from .. import reflect as rfl
+from ..funcs import match as mfs
 from .base import MarshalContext
 from .base import Marshaler
 from .base import MarshalerFactoryMatchClass

omlish/marshal/standard.py

@@ -1,4 +1,4 @@
-from .. import matchfns as mfs
+from ..funcs import match as mfs
 from .any import ANY_MARSHALER_FACTORY
 from .any import ANY_UNMARSHALER_FACTORY
 from .base import MarshalerFactory
@@ -17,6 +17,8 @@ from .enums import EnumMarshalerFactory
 from .enums import EnumUnmarshalerFactory
 from .iterables import IterableMarshalerFactory
 from .iterables import IterableUnmarshalerFactory
+from .literals import LiteralMarshalerFactory
+from .literals import LiteralUnmarshalerFactory
 from .mappings import MappingMarshalerFactory
 from .mappings import MappingUnmarshalerFactory
 from .maybes import MaybeMarshalerFactory
@@ -48,6 +50,7 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     DataclassMarshalerFactory(),
     NamedtupleMarshalerFactory(),
     EnumMarshalerFactory(),
+    LiteralMarshalerFactory(),
     NUMBERS_MARSHALER_FACTORY,
     UUID_MARSHALER_FACTORY,
     BASE64_MARSHALER_FACTORY,
@@ -80,6 +83,7 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     DataclassUnmarshalerFactory(),
     NamedtupleUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
+    LiteralUnmarshalerFactory(),
     NUMBERS_UNMARSHALER_FACTORY,
     UUID_UNMARSHALER_FACTORY,
     BASE64_UNMARSHALER_FACTORY,

omlish/marshal/unions.py

@@ -4,8 +4,8 @@ from .. import cached
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
-from .. import matchfns as mfs
 from .. import reflect as rfl
+from ..funcs import match as mfs
 from .base import MarshalContext
 from .base import Marshaler
 from .base import MarshalerFactory

omlish/os/atomics.py

@@ -0,0 +1,205 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import abc
+import os
+import shutil
+import tempfile
+import typing as ta
+
+from omlish.lite.check import check
+from omlish.lite.strings import attr_repr
+
+
+AtomicPathSwapKind = ta.Literal['dir', 'file']
+AtomicPathSwapState = ta.Literal['open', 'committed', 'aborted']  # ta.TypeAlias
+
+
+##
+
+
+class AtomicPathSwap(abc.ABC):
+    def __init__(
+            self,
+            kind: AtomicPathSwapKind,
+            dst_path: str,
+            *,
+            auto_commit: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._kind = kind
+        self._dst_path = dst_path
+        self._auto_commit = auto_commit
+
+        self._state: AtomicPathSwapState = 'open'
+
+    def __repr__(self) -> str:
+        return attr_repr(self, 'kind', 'dst_path', 'tmp_path')
+
+    @property
+    def kind(self) -> AtomicPathSwapKind:
+        return self._kind
+
+    @property
+    def dst_path(self) -> str:
+        return self._dst_path
+
+    @property
+    @abc.abstractmethod
+    def tmp_path(self) -> str:
+        raise NotImplementedError
+
+    #
+
+    @property
+    def state(self) -> AtomicPathSwapState:
+        return self._state
+
+    def _check_state(self, *states: AtomicPathSwapState) -> None:
+        if self._state not in states:
+            raise RuntimeError(f'Atomic path swap not in correct state: {self._state}, {states}')
+
+    #
+
+    @abc.abstractmethod
+    def _commit(self) -> None:
+        raise NotImplementedError
+
+    def commit(self) -> None:
+        if self._state == 'committed':
+            return
+        self._check_state('open')
+        try:
+            self._commit()
+        except Exception:  # noqa
+            self._abort()
+            raise
+        else:
+            self._state = 'committed'
+
+    #
+
+    @abc.abstractmethod
+    def _abort(self) -> None:
+        raise NotImplementedError
+
+    def abort(self) -> None:
+        if self._state == 'aborted':
+            return
+        self._abort()
+        self._state = 'aborted'
+
+    #
+
+    def __enter__(self) -> 'AtomicPathSwap':
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (
+                exc_type is None and
+                self._auto_commit and
+                self._state == 'open'
+        ):
+            self.commit()
+        else:
+            self.abort()
+
+
+class AtomicPathSwapping(abc.ABC):
+    @abc.abstractmethod
+    def begin_atomic_path_swap(
+            self,
+            kind: AtomicPathSwapKind,
+            dst_path: str,
+            *,
+            name_hint: ta.Optional[str] = None,
+            make_dirs: bool = False,
+            **kwargs: ta.Any,
+    ) -> AtomicPathSwap:
+        raise NotImplementedError
+
+
+##
+
+
+class OsReplaceAtomicPathSwap(AtomicPathSwap):
+    def __init__(
+            self,
+            kind: AtomicPathSwapKind,
+            dst_path: str,
+            tmp_path: str,
+            **kwargs: ta.Any,
+    ) -> None:
+        if kind == 'dir':
+            check.state(os.path.isdir(tmp_path))
+        elif kind == 'file':
+            check.state(os.path.isfile(tmp_path))
+        else:
+            raise TypeError(kind)
+
+        super().__init__(
+            kind,
+            dst_path,
+            **kwargs,
+        )
+
+        self._tmp_path = tmp_path
+
+    @property
+    def tmp_path(self) -> str:
+        return self._tmp_path
+
+    def _commit(self) -> None:
+        os.replace(self._tmp_path, self._dst_path)
+
+    def _abort(self) -> None:
+        shutil.rmtree(self._tmp_path, ignore_errors=True)
+
+
+class TempDirAtomicPathSwapping(AtomicPathSwapping):
+    def __init__(
+            self,
+            *,
+            temp_dir: ta.Optional[str] = None,
+            root_dir: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        if root_dir is not None:
+            root_dir = os.path.abspath(root_dir)
+        self._root_dir = root_dir
+        self._temp_dir = temp_dir
+
+    def begin_atomic_path_swap(
+            self,
+            kind: AtomicPathSwapKind,
+            dst_path: str,
+            *,
+            name_hint: ta.Optional[str] = None,
+            make_dirs: bool = False,
+            **kwargs: ta.Any,
+    ) -> AtomicPathSwap:
+        dst_path = os.path.abspath(dst_path)
+        if self._root_dir is not None and not dst_path.startswith(check.non_empty_str(self._root_dir)):
+            raise RuntimeError(f'Atomic path swap dst must be in root dir: {dst_path}, {self._root_dir}')
+
+        dst_dir = os.path.dirname(dst_path)
+        if make_dirs:
+            os.makedirs(dst_dir, exist_ok=True)
+        if not os.path.isdir(dst_dir):
+            raise RuntimeError(f'Atomic path swap dst dir does not exist: {dst_dir}')
+
+        if kind == 'dir':
+            tmp_path = tempfile.mkdtemp(prefix=name_hint, dir=self._temp_dir)
+        elif kind == 'file':
+            fd, tmp_path = tempfile.mkstemp(prefix=name_hint, dir=self._temp_dir)
+            os.close(fd)
+        else:
+            raise TypeError(kind)
+
+        return OsReplaceAtomicPathSwap(
+            kind,
+            dst_path,
+            tmp_path,
+            **kwargs,
+        )

omlish/os/deathsig.py

@@ -0,0 +1,23 @@
+# @omlish-lite
+import ctypes as ct
+import sys
+
+
+LINUX_PR_SET_PDEATHSIG = 1  # Second arg is a signal
+LINUX_PR_GET_PDEATHSIG = 2  # Second arg is a ptr to return the signal
+
+
+def set_process_deathsig(sig: int) -> bool:
+    if sys.platform == 'linux':
+        libc = ct.CDLL('libc.so.6')
+
+        # int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
+        libc.prctl.restype = ct.c_int
+        libc.prctl.argtypes = [ct.c_int, ct.c_ulong, ct.c_ulong, ct.c_ulong, ct.c_ulong]
+
+        libc.prctl(LINUX_PR_SET_PDEATHSIG, sig, 0, 0, 0, 0)
+
+        return True
+
+    else:
+        return False

omlish/{os.py → os/files.py}

@@ -1,19 +1,10 @@
 import contextlib
 import os
-import resource
 import shutil
 import tempfile
 import typing as ta
 
 
-PAGE_SIZE = resource.getpagesize()
-
-
-def round_to_page_size(sz: int) -> int:
-    sz += PAGE_SIZE - 1
-    return sz - (sz % PAGE_SIZE)
-
-
 @contextlib.contextmanager
 def tmp_dir(
         root_dir: str | None = None,

omlish/{lite → os}/journald.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP007 UP012
+# @omlish-lite
 import ctypes as ct
 import logging
 import sys
@@ -6,7 +7,7 @@ import syslog
 import threading
 import typing as ta
 
-from .cached import cached_nullary
+from ..lite.cached import cached_nullary
 
 
 ##