omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev7__py3-none-any.whl

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)

omlish/reflect/ops.py

@@ -0,0 +1,84 @@
+import typing as ta
+
+from .types import Annotated
+from .types import Any
+from .types import Generic
+from .types import NewType
+from .types import Type
+from .types import Union
+from .types import type_
+
+
+def strip_objs(ty: Type) -> Type:
+    if isinstance(ty, (type, ta.TypeVar, NewType, Any)):
+        return ty
+
+    if isinstance(ty, Union):
+        return Union(frozenset(map(strip_objs, ty.args)))
+
+    if isinstance(ty, Generic):
+        return Generic(ty.cls, tuple(map(strip_objs, ty.args)), ty.params, None)
+
+    if isinstance(ty, Annotated):
+        return Annotated(strip_objs(ty.ty), ty.md, None)
+
+    raise TypeError(ty)
+
+
+def strip_annotations(ty: Type) -> Type:
+    if isinstance(ty, (type, ta.TypeVar, NewType, Any)):
+        return ty
+
+    if isinstance(ty, Union):
+        return Union(frozenset(map(strip_annotations, ty.args)))
+
+    if isinstance(ty, Generic):
+        return Generic(ty.cls, tuple(map(strip_annotations, ty.args)), ty.params, ty.obj)
+
+    if isinstance(ty, Annotated):
+        return strip_annotations(ty.ty)
+
+    raise TypeError(ty)
+
+
+def types_equivalent(l: Type, r: Type) -> bool:
+    if isinstance(l, Generic) and isinstance(r, Generic):
+        return l.cls == r.cls and l.args == r.args
+
+    return l == r
+
+
+def get_underlying(nt: NewType) -> Type:
+    return type_(nt.obj.__supertype__)  # noqa
+
+
+def get_concrete_type(ty: Type) -> type | None:
+    if isinstance(ty, type):
+        return ty
+
+    if isinstance(ty, Generic):
+        return ty.cls
+
+    if isinstance(ty, NewType):
+        return get_concrete_type(get_underlying(ty))
+
+    if isinstance(ty, (Union, ta.TypeVar, Any)):
+        return None
+
+    raise TypeError(ty)
+
+
+def to_annotation(ty: Type) -> ta.Any:
+    if isinstance(ty, Generic):
+        return ty.obj if ty.obj is not None else ty.cls
+
+    if isinstance(ty, Union):
+        return ta.Union[*tuple(to_annotation(e) for e in ty.args)]
+
+    if isinstance(ty, (type, ta.TypeVar, NewType)):
+        return ty
+
+    if isinstance(ty, Any):
+        return ta.Any
+
+    raise TypeError(ty)

omlish/reflect/subst.py

@@ -0,0 +1,110 @@
+import dataclasses as dc
+import types
+import typing as ta
+
+from .. import c3
+from .. import lang
+from .ops import get_concrete_type
+from .ops import to_annotation
+from .types import Any
+from .types import Generic
+from .types import NewType
+from .types import Type
+from .types import Union
+from .types import get_params
+from .types import type_
+
+
+if ta.TYPE_CHECKING:
+    from ..collections import cache
+else:
+    cache = lang.proxy_import('.collections.cache', __package__)
+
+
+def get_type_var_replacements(ty: Type) -> ta.Mapping[ta.TypeVar, Type]:
+    if isinstance(ty, Generic):
+        return dict(zip(ty.params, ty.args))
+
+    return {}
+
+
+def replace_type_vars(
+        ty: Type,
+        rpl: ta.Mapping[ta.TypeVar, Type],
+        *,
+        update_aliases: bool = False,
+) -> Type:
+    def rec(cur):
+        if isinstance(cur, (type, NewType, Any)):
+            return cur
+
+        if isinstance(cur, Generic):
+            args = tuple(rec(a) for a in cur.args)
+            if update_aliases:
+                obj = cur.obj
+                if (ops := get_params(obj)):
+                    nargs = [to_annotation(rpl[p]) for p in ops]
+                    if ta.get_origin(obj) is ta.Generic:
+                        # FIXME: None? filter_typing_generic in get_generic_bases?
+                        pass
+                    else:
+                        obj = cur.obj[*nargs]
+            else:
+                obj = None
+            return dc.replace(cur, args=args, obj=obj)
+
+        if isinstance(cur, Union):
+            return Union(frozenset(rec(e) for e in cur.args))
+
+        if isinstance(cur, ta.TypeVar):
+            return rpl[cur]
+
+        raise TypeError(cur)
+
+    return rec(ty)
+
+
+class GenericSubstitution:
+    def __init__(
+            self,
+            *,
+            update_aliases: bool = False,
+            cache_size: int = 0,  # FIXME: ta.Generic isn't weakrefable..
+    ) -> None:
+        super().__init__()
+
+        self._update_aliases = update_aliases
+
+        if cache_size > 0:
+            self.get_generic_bases = cache.cache(weak_keys=True, max_size=cache_size)(self.get_generic_bases)  # type: ignore  # noqa
+            self.generic_mro = cache.cache(weak_keys=True, max_size=cache_size)(self.generic_mro)  # type: ignore
+
+    def get_generic_bases(self, ty: Type) -> tuple[Type, ...]:
+        if (cty := get_concrete_type(ty)) is not None:
+            rpl = get_type_var_replacements(ty)
+            ret: list[Type] = []
+            for b in types.get_original_bases(cty):
+                bty = type_(b)
+                if isinstance(bty, Generic) and isinstance(b, type):
+                    # FIXME: throws away relative types, but can't use original vars as they're class-contextual
+                    bty = type_(b[*((ta.Any,) * len(bty.params))])  # type: ignore
+                rty = replace_type_vars(bty, rpl, update_aliases=self._update_aliases)
+                ret.append(rty)
+            return tuple(ret)
+        return ()
+
+    def generic_mro(self, obj: ta.Any) -> list[Type]:
+        mro = c3.mro(
+            type_(obj),
+            get_bases=lambda t: self.get_generic_bases(t),
+            is_subclass=lambda l, r: issubclass(get_concrete_type(l), get_concrete_type(r)),  # type: ignore
+        )
+        return [ty for ty in mro if get_concrete_type(ty) is not ta.Generic]
+
+
+DEFAULT_GENERIC_SUBSTITUTION = GenericSubstitution()
+
+get_generic_bases = DEFAULT_GENERIC_SUBSTITUTION.get_generic_bases
+generic_mro = DEFAULT_GENERIC_SUBSTITUTION.generic_mro
+
+ALIAS_UPDATING_GENERIC_SUBSTITUTION = GenericSubstitution(update_aliases=True)