omlish 0.0.0.dev6__py3-none-any.whl → 0.0.0.dev8__py3-none-any.whl

omlish/marshal/polymorphism.py

@@ -19,12 +19,29 @@ from .base import Unmarshaler
 from .base import UnmarshalerFactory
 from .naming import Naming
 from .naming import translate_name
+from .registries import RegistryItem
 from .values import Value
 
 
 ##
 
 
+class TypeTagging(RegistryItem, lang.Abstract, lang.Sealed):
+    pass
+
+
+class WrapperTypeTagging(TypeTagging, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class FieldTypeTagging(TypeTagging, lang.Final):
+    field: str
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class Impl:
     ty: type
@@ -33,7 +50,11 @@ class Impl:
 
 
 class Polymorphism:
-    def __init__(self, ty: type, impls: ta.Iterable[Impl]) -> None:
+    def __init__(
+            self,
+            ty: type,
+            impls: ta.Iterable[Impl],
+    ) -> None:
         super().__init__()
         self._ty = ty
         self._impls = list(impls)
@@ -72,7 +93,11 @@ class Polymorphism:
         return self._by_tag
 
 
-def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> Polymorphism:
+def polymorphism_from_subclasses(
+        ty: type,
+        *,
+        naming: Naming | None = None,
+) -> Polymorphism:
     dct: dict[str, Impl] = {}
     seen: set[type] = set()
     todo: list[type] = [ty]
@@ -97,7 +122,7 @@ def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> P
 
 
 @dc.dataclass(frozen=True)
-class DictKeyPolymorphismMarshaler(Marshaler):
+class WrapperPolymorphismMarshaler(Marshaler):
     m: ta.Mapping[type, tuple[str, Marshaler]]
 
     def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
@@ -105,24 +130,43 @@ class DictKeyPolymorphismMarshaler(Marshaler):
         return {tag: m.marshal(ctx, o)}
 
 
+@dc.dataclass(frozen=True)
+class FieldPolymorphismMarshaler(Marshaler):
+    m: ta.Mapping[type, tuple[str, Marshaler]]
+    tf: str
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        tag, m = self.m[type(o)]
+        return {self.tf: tag, **m.marshal(ctx, o)}  # type: ignore
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
+    tt: TypeTagging = WrapperTypeTagging()
 
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if rty is self.p.ty:
-            return DictKeyPolymorphismMarshaler({
-                i.ty: (i.tag, ctx.make(i.ty))
-                for i in self.p.impls
-            })
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        check.is_(rty, self.p.ty)
+        m = {
+            i.ty: (i.tag, ctx.make(i.ty))
+            for i in self.p.impls
+        }
+        if isinstance(self.tt, WrapperTypeTagging):
+            return WrapperPolymorphismMarshaler(m)
+        elif isinstance(self.tt, FieldTypeTagging):
+            return FieldPolymorphismMarshaler(m, self.tt.field)
+        else:
+            raise TypeError(self.tt)
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class DictKeyPolymorphismUnmarshaler(Unmarshaler):
+class WrapperPolymorphismUnmarshaler(Unmarshaler):
     m: ta.Mapping[str, Unmarshaler]
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
@@ -132,16 +176,37 @@ class DictKeyPolymorphismUnmarshaler(Unmarshaler):
         return u.unmarshal(ctx, iv)  # type: ignore
 
 
+@dc.dataclass(frozen=True)
+class FieldPolymorphismUnmarshaler(Unmarshaler):
+    m: ta.Mapping[str, Unmarshaler]
+    tf: str
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        ma = dict(check.isinstance(v, collections.abc.Mapping))
+        tag = ma.pop(self.tf)  # type: ignore
+        u = self.m[tag]  # type: ignore
+        return u.unmarshal(ctx, ma)
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
-
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if rty is self.p.ty:
-            return DictKeyPolymorphismUnmarshaler({
-                t: u
-                for i in self.p.impls
-                for u in [ctx.make(i.ty)]
-                for t in [i.tag, *i.alts]
-            })
-        return None
+    tt: TypeTagging = WrapperTypeTagging()
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        check.is_(rty, self.p.ty)
+        m = {
+            t: u
+            for i in self.p.impls
+            for u in [ctx.make(i.ty)]
+            for t in [i.tag, *i.alts]
+        }
+        if isinstance(self.tt, WrapperTypeTagging):
+            return WrapperPolymorphismUnmarshaler(m)
+        elif isinstance(self.tt, FieldTypeTagging):
+            return FieldPolymorphismUnmarshaler(m, self.tt.field)
+        else:
+            raise TypeError(self.tt)

omlish/marshal/primitives.py

@@ -2,11 +2,10 @@ import typing as ta
 
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .factories import TypeMapFactory
 from .values import Value
 
 
@@ -34,10 +33,10 @@ class PrimitiveMarshalerUnmarshaler(Marshaler, Unmarshaler):
 
 PRIMITIVE_MARSHALER_UNMARSHALER = PrimitiveMarshalerUnmarshaler()
 
-PRIMITIVE_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({  # noqa
+PRIMITIVE_MARSHALER_FACTORY = TypeMapMarshalerFactory({  # noqa
     t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
 })
 
-PRIMITIVE_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({  # noqa
+PRIMITIVE_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({  # noqa
     t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
 })

omlish/marshal/standard.py

@@ -1,8 +1,11 @@
+from .. import matchfns as mfs
 from .any import ANY_MARSHALER_FACTORY
 from .any import ANY_UNMARSHALER_FACTORY
 from .base import MarshalerFactory
 from .base import RecursiveMarshalerFactory
 from .base import RecursiveUnmarshalerFactory
+from .base import TypeCacheMarshalerFactory
+from .base import TypeCacheUnmarshalerFactory
 from .base import UnmarshalerFactory
 from .base64 import BASE64_MARSHALER_FACTORY
 from .base64 import BASE64_UNMARSHALER_FACTORY
@@ -12,12 +15,12 @@ from .datetimes import DATETIME_MARSHALER_FACTORY
 from .datetimes import DATETIME_UNMARSHALER_FACTORY
 from .enums import EnumMarshalerFactory
 from .enums import EnumUnmarshalerFactory
-from .factories import CompositeFactory
-from .factories import TypeCacheFactory
 from .iterables import IterableMarshalerFactory
 from .iterables import IterableUnmarshalerFactory
 from .mappings import MappingMarshalerFactory
 from .mappings import MappingUnmarshalerFactory
+from .numbers import NUMBERS_MARSHALER_FACTORY
+from .numbers import NUMBERS_UNMARSHALER_FACTORY
 from .optionals import OptionalMarshalerFactory
 from .optionals import OptionalUnmarshalerFactory
 from .primitives import PRIMITIVE_MARSHALER_FACTORY
@@ -34,6 +37,7 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     OptionalMarshalerFactory(),
     DataclassMarshalerFactory(),
     EnumMarshalerFactory(),
+    NUMBERS_MARSHALER_FACTORY,
     UUID_MARSHALER_FACTORY,
     BASE64_MARSHALER_FACTORY,
     DATETIME_MARSHALER_FACTORY,
@@ -44,10 +48,10 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
 
 
 def new_standard_marshaler_factory() -> MarshalerFactory:
-    return TypeCacheFactory(  # noqa
+    return TypeCacheMarshalerFactory(
         RecursiveMarshalerFactory(
-            CompositeFactory(
-                *STANDARD_MARSHALER_FACTORIES,
+            mfs.MultiMatchFn(
+                list(STANDARD_MARSHALER_FACTORIES),
             ),
         ),
     )
@@ -61,6 +65,7 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     OptionalUnmarshalerFactory(),
     DataclassUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
+    NUMBERS_UNMARSHALER_FACTORY,
     UUID_UNMARSHALER_FACTORY,
     BASE64_UNMARSHALER_FACTORY,
     DATETIME_UNMARSHALER_FACTORY,
@@ -71,10 +76,10 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
 
 
 def new_standard_unmarshaler_factory() -> UnmarshalerFactory:
-    return TypeCacheFactory(  # noqa
+    return TypeCacheUnmarshalerFactory(
         RecursiveUnmarshalerFactory(
-            CompositeFactory(
-                *STANDARD_UNMARSHALER_FACTORIES,
+            mfs.MultiMatchFn(
+                list(STANDARD_UNMARSHALER_FACTORIES),
             ),
         ),
     )

omlish/marshal/uuids.py

@@ -4,11 +4,10 @@ import uuid
 from .. import check
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .factories import TypeMapFactory
 from .values import Value
 
 
@@ -25,5 +24,5 @@ class UuidMarshalerUnmarshaler(Marshaler, Unmarshaler):
 
 UUID_MARSHALER_UNMARSHALER = UuidMarshalerUnmarshaler()
 
-UUID_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})
-UUID_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})
+UUID_MARSHALER_FACTORY = TypeMapMarshalerFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})
+UUID_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})

omlish/matchfns.py

@@ -0,0 +1,218 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from . import lang
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+class MatchGuardError(Exception):
+    pass
+
+
+class MatchFn(abc.ABC, ta.Generic[P, T]):
+    @abc.abstractmethod
+    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        raise NotImplementedError
+
+    def __get__(self, instance, owner=None):
+        return self
+
+    @ta.final
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        if not self.guard(*args, **kwargs):
+            raise MatchGuardError(*args, **kwargs)
+        return self.fn(*args, **kwargs)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SimpleMatchFn(MatchFn[P, T]):
+    _guard: ta.Callable[P, bool]
+    _fn: ta.Callable[P, T]
+
+    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
+        return self._guard(*args, **kwargs)
+
+    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self._fn(*args, **kwargs)
+
+    def __get__(self, instance, owner=None):
+        return self.__class__(
+            self._guard.__get__(instance, owner),  # noqa
+            self._fn.__get__(instance, owner),  # noqa
+        )
+
+
+@ta.overload
+def simple(guard: ta.Callable[..., bool], fn: ta.Callable[P, T]) -> SimpleMatchFn[P, T]:
+    ...
+
+
+@ta.overload
+def simple(guard: ta.Callable[..., bool]) -> ta.Callable[[ta.Callable[P, T]], SimpleMatchFn[P, T]]:
+    ...
+
+
+def simple(guard, fn=None):
+    def inner(fn):  # noqa
+        return SimpleMatchFn(guard, fn)
+    if fn is not None:
+        return inner(fn)
+    else:
+        return inner
+
+
+##
+
+
+class AmbiguousMatchesError(Exception):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class MultiMatchFn(MatchFn[P, T]):
+    children: ta.Sequence[MatchFn[P, T]]
+    strict: bool = False
+
+    def _match(self, *args: P.args, **kwargs: P.kwargs) -> MatchFn[P, T] | None:
+        matches = []
+        for cur in self.children:
+            if cur.guard(*args, **kwargs):
+                if self.strict:
+                    matches.append(cur)
+                else:
+                    return cur
+        if not matches:
+            return None
+        elif len(matches) > 1:
+            raise AmbiguousMatchesError
+        else:
+            return matches[0]
+
+    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
+        return self._match(*args, **kwargs) is not None
+
+    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        if (m := self._match(*args, **kwargs)) is None:
+            raise MatchGuardError(*args, **kwargs)
+        return m.fn(*args, **kwargs)
+
+    def __get__(self, instance, owner=None):
+        return self.__class__(
+            [c.__get__(instance, owner) for c in self.children],
+            strict=self.strict,
+        )
+
+
+def multi(*children: MatchFn[P, T], strict: bool = False):
+    return MultiMatchFn(children, strict=strict)  # noqa
+
+
+##
+
+
+class CachedMultiFn(MatchFn[P, T]):
+    @staticmethod
+    def _default_key(*args, **kwargs):
+        return (args, tuple(sorted(kwargs.items(), key=lambda t: t[0])))
+
+    def __init__(
+            self,
+            f: MatchFn[P, T],
+            *,
+            key: ta.Callable[P, ta.Any] = _default_key,
+            lock: lang.DefaultLockable = None,
+    ) -> None:
+        super().__init__()
+        self._f = f
+        self._key = key
+        self._lock = lock
+        self._lock_impl = lang.default_lock(lock)()
+        self._dct: dict[ta.Any, lang.Maybe[ta.Any]] = {}
+
+    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
+        with self._lock_impl:
+            k = self._key(*args, **kwargs)
+            try:
+                e = self._dct[k]
+            except KeyError:
+                if self._f.guard(*args, **kwargs):
+                    return True
+                else:
+                    self._dct[k] = lang.empty()
+                    return False
+            else:
+                return e.present
+
+    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        with self._lock_impl:
+            k = self._key(*args, **kwargs)
+            try:
+                e = self._dct[k]
+            except KeyError:
+                try:
+                    ret = self._f(*args, **kwargs)
+                except MatchGuardError:
+                    self._dct[k] = lang.empty()
+                    raise
+                else:
+                    self._dct[k] = lang.just(ret)
+                    return ret
+            else:
+                if e.present:
+                    return e.must()
+                else:
+                    raise MatchGuardError(*args, **kwargs)
+
+    def __get__(self, instance, owner=None):
+        return self.__class__(self._f.__get__(instance, owner), key=self._key)  # noqa
+
+
+cached = CachedMultiFn
+
+
+##
+
+
+class MatchFnClass(MatchFn[P, T]):
+    _cls_match_fn: ta.ClassVar[MultiMatchFn]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.__match_fn: MatchFn[P, T] | None = None
+
+    @property
+    def _match_fn(self) -> MatchFn[P, T]:
+        if (mf := self.__match_fn) is None:
+            mf = self.__match_fn = self._cls_match_fn.__get__(self)
+        return mf
+
+    def __init_subclass__(cls, strict: bool = False, **kwargs):
+        super().__init_subclass__()
+        if '_cls_match_fn' in cls.__dict__:
+            raise AttributeError('_cls_match_fn')
+        d = {}
+        for c in cls.__mro__:
+            for a, o in c.__dict__.items():
+                if isinstance(o, MatchFn) and a not in d:
+                    d[a] = o
+        cls._cls_match_fn = MultiMatchFn(list(d.values()), strict=strict)
+
+    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
+        return self._match_fn.guard(*args, **kwargs)
+
+    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self._match_fn.fn(*args, **kwargs)

omlish/os.py

@@ -1,6 +1,9 @@
 import contextlib
+import fcntl
+import os
 import resource
 import shutil
+import signal
 import tempfile
 import typing as ta
 
@@ -39,3 +42,64 @@ def tmp_file(
         finally:
             if cleanup:
                 shutil.rmtree(f.name, ignore_errors=True)
+
+
+class Pidfile:
+    def __init__(self, path: str) -> None:
+        super().__init__()
+        self._path = path
+
+    _f: ta.TextIO
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._path!r})'
+
+    def __enter__(self) -> ta.Self:
+        fd = os.open(self._path, os.O_RDWR | os.O_CREAT, 0o600)
+        try:
+            os.set_inheritable(fd, True)
+            f = os.fdopen(fd, 'r+')
+        except Exception:
+            try:
+                os.close(fd)
+            except Exception:  # noqa
+                pass
+            raise
+        self._f = f
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._f is not None:
+            self._f.close()
+            del self._f
+
+    def try_lock(self) -> bool:
+        try:
+            fcntl.flock(self._f, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return True
+        except OSError:
+            return False
+
+    def write(self, pid: int | None = None) -> None:
+        if not self.try_lock():
+            raise RuntimeError('Could not get lock')
+        if pid is None:
+            pid = os.getpid()
+        self._f.write(f'{pid}\n')
+        self._f.flush()
+
+    def clear(self) -> None:
+        if not self.try_lock():
+            raise RuntimeError('Could not get lock')
+        self._f.seek(0)
+        self._f.truncate()
+
+    def read(self) -> int:
+        if self.try_lock():
+            raise RuntimeError('Got lock')
+        self._f.seek(0)
+        return int(self._f.read())
+
+    def kill(self, sig: int = signal.SIGTERM) -> None:
+        pid = self.read()
+        os.kill(pid, sig)  # Still racy

omlish/reflect/__init__.py

@@ -0,0 +1,39 @@
+from .types import (  # noqa
+    ANY,
+    Annotated,
+    Any,
+    Generic,
+    NewType,
+    TYPES,
+    Type,
+    Union,
+    get_orig_class,
+    get_params,
+    is_type,
+    is_union_type,
+    type_,
+)
+
+from .ops import (  # noqa
+    get_concrete_type,
+    get_underlying,
+    strip_annotations,
+    strip_objs,
+    to_annotation,
+    types_equivalent,
+)
+
+from .isinstance import (  # noqa
+    KNOWN_ISINSTANCE_GENERICS,
+    isinstance_of,
+)
+
+from .subst import (  # noqa
+    ALIAS_UPDATING_GENERIC_SUBSTITUTION,
+    DEFAULT_GENERIC_SUBSTITUTION,
+    GenericSubstitution,
+    generic_mro,
+    get_generic_bases,
+    get_type_var_replacements,
+    replace_type_vars,
+)

omlish/reflect/isinstance.py

@@ -0,0 +1,38 @@
+import collections.abc
+import typing as ta
+
+from .ops import get_underlying
+from .types import Generic
+from .types import NewType
+from .types import Type
+from .types import Union
+
+
+KNOWN_ISINSTANCE_GENERICS: ta.AbstractSet[type] = frozenset([
+    collections.abc.Mapping,
+    collections.abc.Sequence,
+    collections.abc.Set,
+])
+
+
+def isinstance_of(rfl: Type) -> ta.Callable[[ta.Any], bool]:
+    if isinstance(rfl, type):
+        return lambda o: isinstance(o, rfl)
+
+    if isinstance(rfl, NewType):
+        return isinstance_of(get_underlying(rfl))
+
+    if isinstance(rfl, Union):
+        fns = [isinstance_of(a) for a in rfl.args]
+        return lambda o: any(fn(o) for fn in fns)
+
+    if isinstance(rfl, Generic):
+        if rfl.cls in (collections.abc.Sequence, collections.abc.Set):
+            [efn] = map(isinstance_of, rfl.args)
+            return lambda o: isinstance(o, rfl.cls) and all(efn(e) for e in o)  # type: ignore
+
+        if rfl.cls == collections.abc.Mapping:
+            kfn, vfn = map(isinstance_of, rfl.args)
+            return lambda o: isinstance(o, rfl.cls) and all(kfn(k) and vfn(v) for k, v in o.items())  # type: ignore
+
+    raise TypeError(rfl)