omlish 0.0.0.dev1__py3-none-any.whl

omlish/collections/cache/types.py

@@ -0,0 +1,37 @@
+import abc
+import typing as ta
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+class OverweightException(Exception):
+    pass
+
+
+Eviction: ta.TypeAlias = ta.Callable[['Cache'], None]
+
+
+class Cache(ta.MutableMapping[K, V]):
+    """
+    https://google.github.io/guava/releases/16.0/api/docs/com/google/common/cache/CacheBuilder.html
+    """
+
+    @abc.abstractmethod
+    def reap(self) -> None:
+        pass
+
+    class Stats(ta.NamedTuple):
+        seq: int
+        size: int
+        weight: float
+        hits: int
+        misses: int
+        max_size_ever: int
+        max_weight_ever: float
+
+    @property
+    @abc.abstractmethod
+    def stats(self) -> Stats:
+        raise NotImplementedError

omlish/collections/coerce.py

@@ -0,0 +1,337 @@
+import typing as ta
+
+from .. import check
+from .frozen import FrozenDict
+from .frozen import FrozenList
+
+
+T = ta.TypeVar('T')
+T2 = ta.TypeVar('T2')
+K = ta.TypeVar('K')
+K2 = ta.TypeVar('K2')
+V = ta.TypeVar('V')
+V2 = ta.TypeVar('V2')
+
+_map = map
+
+
+def _unpack_fn(fn):
+    if isinstance(fn, tuple):
+        return check.of_isinstance(fn)
+    elif isinstance(fn, type) or callable(fn):
+        return fn
+    else:
+        raise TypeError(fn)
+
+
+# region seq
+
+
+def seq(
+        it: ta.Iterable[T],
+) -> ta.Sequence[T]:
+    if isinstance(it, str):
+        raise TypeError(it)
+    elif isinstance(it, FrozenList):
+        return it
+    else:
+        return FrozenList(it)
+
+
+def opt_seq(
+        it: ta.Optional[ta.Iterable[T]],
+) -> ta.Optional[ta.Sequence[T]]:
+    if it is None:
+        return None
+    else:
+        return seq(it)
+
+
+def seq_or_none(
+        it: ta.Optional[ta.Iterable[T]],
+) -> ta.Optional[ta.Sequence[T]]:
+    ret = opt_seq(it)
+    if ret:
+        return ret
+    else:
+        return None
+
+
+def seq_of(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Iterable[T]], ta.Sequence[T2]]:
+    def inner(it):
+        return seq(fn(e) for e in it)  # type: ignore
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+def opt_seq_of(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.Sequence[T2]]]:
+    def inner(it):
+        if it is None:
+            return None
+        else:
+            return seq(fn(e) for e in it)  # type: ignore
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+def seq_of_or_none(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.Sequence[T2]]]:
+    def inner(it):
+        if it is None:
+            return None
+        else:
+            ret = seq(fn(e) for e in it)  # type: ignore
+            if ret:
+                return ret
+            else:
+                return None
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+# endregion
+
+
+# region abs_set
+
+
+def abs_set(
+        it: ta.Iterable[T],
+) -> ta.AbstractSet[T]:
+    if isinstance(it, str):
+        raise TypeError(it)
+    elif isinstance(it, frozenset):
+        return it
+    else:
+        return frozenset(it)
+
+
+def opt_abs_set(
+        it: ta.Optional[ta.Iterable[T]],
+) -> ta.Optional[ta.AbstractSet[T]]:
+    if it is None:
+        return None
+    else:
+        return abs_set(it)
+
+
+def abs_set_or_none(
+        it: ta.Optional[ta.Iterable[T]],
+) -> ta.Optional[ta.AbstractSet[T]]:
+    ret = opt_abs_set(it)
+    if ret:
+        return ret
+    else:
+        return None
+
+
+def abs_set_of(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Iterable[T]], ta.AbstractSet[T2]]:
+    def inner(it):
+        return abs_set(fn(e) for e in it)  # type: ignore
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+def opt_abs_set_of(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.AbstractSet[T2]]]:
+    def inner(it):
+        if it is None:
+            return None
+        else:
+            return abs_set(fn(e) for e in it)  # type: ignore
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+def abs_set_of_or_none(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.AbstractSet[T2]]]:
+    def inner(it):
+        if it is None:
+            return None
+        else:
+            ret = abs_set(fn(e) for e in it)  # type: ignore
+            if ret:
+                return ret
+            else:
+                return None
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+# endregion
+
+
+# region frozenset
+
+
+def frozenset_(
+        it: ta.Iterable[T],
+) -> frozenset[T]:
+    if isinstance(it, str):
+        raise TypeError(it)
+    elif isinstance(it, frozenset):
+        return it
+    else:
+        return frozenset(it)
+
+
+def opt_frozenset(
+        it: ta.Optional[ta.Iterable[T]],
+) -> ta.Optional[frozenset[T]]:
+    if it is None:
+        return None
+    else:
+        return frozenset_(it)
+
+
+def frozenset_or_none(
+        it: ta.Optional[ta.Iterable[T]],
+) -> ta.Optional[frozenset[T]]:
+    ret = opt_frozenset(it)
+    if ret:
+        return ret
+    else:
+        return None
+
+
+def frozenset_of(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Iterable[T]], frozenset[T2]]:
+    def inner(it):
+        return frozenset_(fn(e) for e in it)  # type: ignore
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+def opt_frozenset_of(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[frozenset[T2]]]:
+    def inner(it):
+        if it is None:
+            return None
+        else:
+            return frozenset_(fn(e) for e in it)  # type: ignore
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+def frozenset_of_or_none(
+        fn: ta.Union[ta.Callable[[T], T2], tuple],
+) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[frozenset[T2]]]:
+    def inner(it):
+        if it is None:
+            return None
+        else:
+            ret = frozenset_(fn(e) for e in it)  # type: ignore
+            if ret:
+                return ret
+            else:
+                return None
+
+    fn = _unpack_fn(fn)
+    return inner
+
+
+# endregion
+
+
+# region map
+
+
+def map(
+        src: ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]],
+) -> ta.Mapping[K, V]:
+    return FrozenDict(src)
+
+
+def opt_map(
+        src: ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
+) -> ta.Optional[ta.Mapping[K, V]]:
+    if src is None:
+        return None
+    else:
+        return map(src)
+
+
+def map_or_none(
+        src: ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
+) -> ta.Optional[ta.Mapping[K, V]]:
+    ret = opt_map(src)
+    if ret:
+        return ret
+    else:
+        return None
+
+
+def map_of(
+        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
+        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+) -> ta.Callable[
+    [ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
+    ta.Mapping[K2, V2],
+]:
+    def inner(src):
+        return map((key_fn(k), value_fn(v)) for k, v in dict(src).items())  # type: ignore
+
+    key_fn = _unpack_fn(key_fn)
+    value_fn = _unpack_fn(value_fn)
+    return inner
+
+
+def opt_map_of(
+        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
+        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+) -> ta.Callable[
+    [ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]]],
+    ta.Optional[ta.Mapping[K2, V2]],
+]:
+    def inner(src):
+        if src is None:
+            return None
+        else:
+            return map((key_fn(k), value_fn(v)) for k, v in dict(src).items())  # type: ignore
+
+    key_fn = _unpack_fn(key_fn)
+    value_fn = _unpack_fn(value_fn)
+    return inner
+
+
+def map_of_or_none(
+        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
+        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+) -> ta.Callable[
+    [ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]]],
+    ta.Optional[ta.Mapping[K2, V2]],
+]:
+    def inner(src):
+        if src is None:
+            return None
+        else:
+            ret = map((key_fn(k), value_fn(v)) for k, v in dict(src).items())  # type: ignore
+            if ret:
+                return ret
+            else:
+                return None
+
+    key_fn = _unpack_fn(key_fn)
+    value_fn = _unpack_fn(value_fn)
+    return inner
+
+# endregion

omlish/collections/frozen.py

@@ -0,0 +1,148 @@
+import abc
+import collections.abc
+import itertools
+import typing as ta
+
+from .mappings import yield_dict_init
+
+
+T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+class Frozen(ta.Hashable, abc.ABC):
+    pass
+
+
+class FrozenDict(ta.Mapping[K, V], Frozen):
+
+    def __new__(cls, *args, **kwargs) -> 'FrozenDict[K, V]':
+        if len(args) == 1 and Frozen in type(args[0]).__bases__:
+            return args[0]
+        return super().__new__(cls)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self._hash = None
+        if len(args) > 1:
+            raise TypeError(args)
+        self._dct: dict[K, V] = {}
+        self._dct.update(yield_dict_init(*args, **kwargs))
+
+    @property
+    def debug(self) -> ta.Mapping[K, V]:
+        return dict(self._dct)
+
+    def __repr__(self) -> str:
+        return '(%r)' % (self._dct,)
+
+    def __eq__(self, other) -> bool:
+        return type(self) == type(other) and self._dct == other._dct
+
+    def __getitem__(self, key: K) -> V:
+        return self._dct[key]
+
+    def __getstate__(self):
+        return tuple(self.items())
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(tuple((k, self[k]) for k in sorted(self)))  # type: ignore
+        return self._hash
+
+    def __iter__(self) -> ta.Iterator[K]:
+        return iter(self._dct)
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __ne__(self, other) -> bool:
+        return not (self == other)
+
+    def __setstate__(self, t):
+        self.__init__(t)  # type: ignore
+
+    def drop(self, *keys):
+        ks = frozenset(keys)
+        return type(self)((k, self[k]) for k in self if k not in ks)
+
+    def set(self, *args, **kwargs):
+        new = type(self)(*args, **kwargs)
+        return type(self)(itertools.chain(self.items(), new.items()))
+
+
+class FrozenList(ta.Sequence[T], Frozen):
+
+    def __init__(self, it: ta.Optional[ta.Iterable[T]] = None) -> None:
+        super().__init__()
+
+        self._tup: tuple = tuple(it) if it is not None else ()
+        self._hash: ta.Optional[int] = None
+
+    @property
+    def debug(self) -> ta.Sequence[T]:
+        return list(self)
+
+    def __repr__(self) -> str:
+        return '([%s])' % (', '.join(map(repr, self._tup)),)
+
+    def __add__(self, o) -> 'FrozenList[T]':
+        if isinstance(o, FrozenList):
+            return FrozenList(self._tup + o._tup)
+        elif isinstance(o, collections.abc.Sequence):
+            return FrozenList(self._tup + tuple(o))
+        else:
+            return NotImplemented
+
+    def __contains__(self, x: object) -> bool:
+        return x in self._tup
+
+    def __eq__(self, o: object) -> bool:
+        if isinstance(o, FrozenList):
+            return self._tup == o._tup
+        elif isinstance(o, collections.abc.Sequence):
+            return len(self) == len(o) and all(l == r for l, r in zip(self, o))
+        else:
+            return False
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(self._tup)
+        return self._hash
+
+    def __getitem__(self, idx: ta.Union[int, slice]) -> 'FrozenList[T]':  # type: ignore
+        if isinstance(idx, int):
+            return self._tup[idx]
+        else:
+            return FrozenList(self._tup[idx])
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return iter(self._tup)
+
+    def __len__(self) -> int:
+        return len(self._tup)
+
+    def __ne__(self, o: object) -> bool:
+        return not self.__eq__(o)
+
+    def __radd__(self, o) -> 'FrozenList[T]':
+        if isinstance(o, FrozenList):
+            return FrozenList(o._tup + self._tup)
+        elif isinstance(o, collections.abc.Sequence):
+            return FrozenList(tuple(o) + self._tup)
+        else:
+            return NotImplemented
+
+    def __reversed__(self) -> ta.Iterator[T]:
+        return reversed(self._tup)
+
+    def count(self, x: ta.Any) -> int:
+        return super().count(x)
+
+    def index(self, x: ta.Any, *args, **kwargs) -> int:  # type: ignore
+        return self._tup.index(x, *args, **kwargs)
+
+
+frozendict = FrozenDict
+frozenlist = FrozenList

omlish/collections/identity.py

@@ -0,0 +1,106 @@
+import operator as op
+import typing as ta
+
+from .. import lang
+from .mappings import yield_dict_init
+
+
+T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+class IdentityWrapper(ta.Generic[T]):
+
+    def __init__(self, value: T) -> None:
+        super().__init__()
+        self._value = value
+
+    def __repr__(self) -> str:
+        return lang.attr_repr(self, 'value')
+
+    @property
+    def value(self) -> T:
+        return self._value
+
+    def __eq__(self, other):
+        return isinstance(other, IdentityWrapper) and other._value is self._value
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        return id(self._value)
+
+
+class IdentityKeyDict(ta.MutableMapping[K, V]):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__()
+        self._dict: dict[int, tuple[K, V]] = {}
+        for k, v in yield_dict_init(*args, **kwargs):
+            self[k] = v
+
+    @property
+    def debug(self) -> ta.Sequence[tuple[K, V]]:
+        return list(self.items())
+
+    def __repr__(self) -> str:
+        return lang.attr_repr(self, '_dict')
+
+    def __setitem__(self, k: K, v: V) -> None:
+        self._dict[id(k)] = (k, v)
+
+    def __delitem__(self, k: K) -> None:
+        del self._dict[id(k)]
+
+    def __getitem__(self, k: K) -> V:
+        return self._dict[id(k)][1]
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __iter__(self) -> ta.Iterator[K]:
+        return iter(map(op.itemgetter(0), self._dict.values()))
+
+    def clear(self):
+        self._dict.clear()
+
+
+class IdentitySet(ta.MutableSet[T]):
+
+    def __init__(self, init: ta.Optional[ta.Iterable[T]] = None) -> None:
+        super().__init__()
+        self._dict: dict[int, T] = {}
+        if init is not None:
+            for item in init:
+                self.add(item)
+
+    @property
+    def debug(self) -> ta.Sequence[T]:
+        return list(self)
+
+    def __repr__(self) -> str:
+        return lang.attr_repr(self, '_dict')
+
+    def add(self, item: T) -> None:
+        self._dict[id(item)] = item
+
+    def discard(self, item: T) -> None:
+        try:
+            del self._dict[id(item)]
+        except KeyError:
+            pass
+
+    def update(self, items: ta.Iterable[T]) -> None:
+        for item in items:
+            self.add(item)
+
+    def __contains__(self, item: T) -> bool:  # type: ignore
+        return id(item) in self._dict
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return iter(self._dict.values())

omlish/collections/indexed.py

@@ -0,0 +1,75 @@
+import typing as ta
+
+from .identity import IdentitySet
+from .identity import IdentityKeyDict
+
+
+T = ta.TypeVar('T')
+
+
+class IndexedSeq(ta.Sequence[T]):
+
+    def __init__(self, it: ta.Iterable[T], *, identity: bool = False) -> None:
+        super().__init__()
+
+        self._lst = list(it)
+        self._idxs = (IdentityKeyDict if identity else dict)(map(reversed, enumerate(self._lst)))
+        if len(self._idxs) != len(self._lst):
+            raise ValueError(f'{len(self._idxs)} != {len(self._lst)}')
+
+    @property
+    def debug(self) -> ta.Sequence[T]:
+        return self._lst
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return iter(self._lst)
+
+    def __getitem__(self, idx: int) -> T:  # type: ignore
+        return self._lst[idx]
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    def __contains__(self, obj: T) -> bool:  # type: ignore
+        return obj in self._idxs
+
+    @property
+    def idxs(self) -> ta.Mapping[T, int]:
+        return self._idxs
+
+    def idx(self, obj: T) -> int:
+        return self._idxs[obj]
+
+
+class IndexedSetSeq(ta.Sequence[ta.AbstractSet[T]]):
+
+    def __init__(self, it: ta.Iterable[ta.Iterable[T]], *, identity: bool = False) -> None:
+        super().__init__()
+
+        self._lst = [(IdentitySet if identity else set)(e) for e in it]
+        self._idxs = (IdentityKeyDict if identity else dict)((e, i) for i, es in enumerate(self._lst) for e in es)
+        if len(self._idxs) != sum(map(len, self._lst)):
+            raise ValueError(f'{len(self._idxs)} != {sum(map(len, self._lst))}')
+
+    @property
+    def debug(self) -> ta.Sequence[ta.AbstractSet[T]]:
+        return self._lst
+
+    def __iter__(self) -> ta.Iterator[ta.AbstractSet[T]]:
+        return iter(self._lst)
+
+    def __getitem__(self, idx: int) -> ta.AbstractSet[T]:  # type: ignore
+        return self._lst[idx]
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    def __contains__(self, obj: T) -> bool:  # type: ignore
+        return obj in self._idxs
+
+    @property
+    def idxs(self) -> ta.Mapping[T, int]:
+        return self._idxs
+
+    def idx(self, obj: T) -> int:
+        return self._idxs[obj]