omlish 0.0.0.dev1__py3-none-any.whl

omlish/collections/mappings.py

@@ -0,0 +1,127 @@
+import collections.abc
+import typing as ta
+import weakref
+
+
+T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+def multikey_dict(dct: ta.Mapping[ta.Union[ta.Iterable[K], K], V], *, deep: bool = False) -> dict[K, V]:
+    ret = {}
+    for k, v in dct.items():
+        if deep and isinstance(v, dict):
+            v = multikey_dict(v, deep=True)  # type: ignore
+        if isinstance(k, tuple):
+            for sk in k:
+                ret[sk] = v
+        else:
+            ret[k] = v
+    return ret
+
+
+def guarded_map_update(
+        dst: ta.MutableMapping[ta.Any, ta.Any],
+        *srcs: ta.Mapping[ta.Any, ta.Any]
+) -> ta.MutableMapping[ta.Any, ta.Any]:
+    for src in srcs:
+        for k, v in src.items():
+            if k in dst:
+                raise KeyError(k)
+            dst[k] = v
+    return dst
+
+
+def yield_dict_init(*args, **kwargs) -> ta.Iterable[tuple[ta.Any, ta.Any]]:
+    if len(args) > 1:
+        raise TypeError
+    if args:
+        [src] = args
+        if isinstance(src, collections.abc.Mapping):
+            for k in src:
+                yield (k, src[k])
+        else:
+            for k, v in src:
+                yield (k, v)
+    for k, v in kwargs.items():
+        yield (k, v)
+
+
+class TypeMap(ta.Generic[T]):
+
+    def __init__(self, items: ta.Iterable[T] = ()) -> None:
+        super().__init__()
+
+        self._items = list(items)
+        dct: dict[type, ta.Any] = {}
+        for item in items:
+            if (ty := type(item)) in dct:
+                raise ValueError(ty)
+            dct[ty] = item
+        self._dct = dct
+
+    @property
+    def items(self) -> ta.Sequence[T]:
+        return self._items
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __iter__(self) -> ta.Iterable[T]:
+        return iter(self._items)
+
+    def get(self, ty: type[T]) -> ta.Optional[T]:
+        return self._dct.get(ty)
+
+    def __getitem__(self, ty: type[T]) -> ta.Sequence[T]:
+        return self._dct[ty]
+
+
+class TypeMultiMap(ta.Generic[V]):
+
+    def __init__(self, items: ta.Iterable[V] = (), *, weak: bool = False) -> None:
+        super().__init__()
+
+        self._items = list(items)
+        self._weak = bool(weak)
+
+        self._cache: ta.MutableMapping[type, ta.Any] = weakref.WeakKeyDictionary()
+
+    @property
+    def items(self) -> ta.Sequence[V]:
+        return self._items
+
+    @property
+    def weak(self) -> bool:
+        return self._weak
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __iter__(self) -> ta.Iterable[V]:
+        return iter(self._items)
+
+    def __getitem__(self, ty: type[T]) -> ta.Sequence[T]:
+        try:
+            return self._cache[ty]
+        except KeyError:
+            ret = []
+            for item in self._items:
+                if isinstance(item, ty):
+                    ret.append(item)
+            self._cache[ty] = ret
+            return ret
+
+
+class MissingDict(dict[K, V]):
+
+    def __init__(self, missing_fn: ta.Callable[[K], V]) -> None:
+        if not callable(missing_fn):
+            raise TypeError(missing_fn)
+        super().__init__()
+        self._missing_fn = missing_fn
+
+    def __missing__(self, key):
+        v = self[key] = self._missing_fn(key)
+        return v

omlish/collections/ordered.py

@@ -0,0 +1,81 @@
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+class OrderedSet(ta.MutableSet[T]):
+
+    def __init__(self, iterable: ta.Optional[ta.Iterable[T]] = None) -> None:
+        super().__init__()
+        self._dct: dict[T, ta.Any] = {}
+        if iterable is not None:
+            self |= iterable  # type: ignore  # noqa
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __contains__(self, item: ta.Any) -> bool:
+        return item in self._dct
+
+    def add(self, item: T) -> None:
+        if item not in self._dct:
+            self._dct[item] = None
+
+    def update(self, items: ta.Iterable[T]) -> None:
+        for item in items:
+            if item not in self._dct:
+                self._dct[item] = None
+
+    def discard(self, item: T) -> None:
+        if item in self._dct:
+            del self._dct[item]
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return iter(self._dct.keys())
+
+    def __reversed__(self):
+        return reversed(self._dct.keys())
+
+    def pop(self, last=True):
+        if not self:
+            raise KeyError('set is empty')
+        item = next(reversed(self._dct.keys()))
+        self.discard(item)
+        return item
+
+    def __repr__(self):
+        if not self:
+            return '%s()' % (self.__class__.__name__,)
+        return '%s(%r)' % (self.__class__.__name__, list(self))
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, OrderedSet):
+            return len(self) == len(other) and list(self) == list(other)
+        return set(self) == set(other)
+
+
+class OrderedFrozenSet(ta.FrozenSet[T]):
+
+    _list: ta.Sequence[T]
+
+    def __new__(cls, items: ta.Iterable[T]) -> ta.FrozenSet[T]:  # type: ignore
+        item_set = set()
+        item_list = []
+        for item in items:
+            if item not in item_set:
+                item_set.add(item)
+                item_list.append(item)
+        obj = super(cls, OrderedFrozenSet).__new__(cls, item_set)
+        obj._list = item_list  # type: ignore  # noqa
+        return obj
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}([{", ".join(map(repr, self))}])'
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return iter(self._list)
+
+    def __sub__(self, other: ta.Iterable[T]) -> ta.FrozenSet[T]:
+        s = set(other)
+        return type(self)(i for i in self if i not in s)

omlish/collections/persistent.py

@@ -0,0 +1,36 @@
+import abc
+import typing as ta
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+class PersistentMap(ta.Generic[K, V], abc.ABC):
+    @abc.abstractmethod
+    def __len__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __contains__(self, item: K) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __getitem__(self, item: K) -> V:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __iter__(self) -> ta.Iterator[tuple[K, V]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def with_(self, k: K, v: V) -> 'PersistentMap[K, V]':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def without(self, k: K) -> 'PersistentMap[K, V]':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def default(self, k: K, v: V) -> 'PersistentMap[K, V]':
+        raise NotImplementedError

omlish/collections/skiplist.py

@@ -0,0 +1,193 @@
+import random
+import typing as ta
+
+from .sorted import SortedCollection
+from .sorted import SortedListDict
+
+
+T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+class SkipList(SortedCollection[T]):
+    """https://gist.github.com/icejoywoo/3bf0c54983a725fa3917"""
+
+    class _Node:
+        __slots__ = [
+            'value',
+            'level',
+            'next',
+            'prev',
+        ]
+
+        next: list[ta.Optional['SkipList._Node']]
+        prev: ta.Optional['SkipList._Node']
+
+        def __init__(
+                self,
+                value: T,
+                level: int
+        ) -> None:
+            super().__init__()
+
+            if level <= 0:
+                raise TypeError('level must be > 0')
+
+            self.value = value
+            self.level = level
+            self.next = [None] * level
+            self.prev = None
+
+        def __repr__(self) -> str:
+            return f'{type(self).__name__}(value={self.value!r})'
+
+    def __init__(
+            self,
+            *,
+            max_height: int = 16,
+            comparator: ta.Optional[SortedCollection.Comparator[T]] = None,
+    ) -> None:
+        super().__init__()
+
+        if comparator is None:
+            comparator = SortedCollection.default_comparator
+        self._compare = comparator
+        self._max_height = max_height
+        self._head = SkipList._Node(None, self._max_height)
+        self._height = 1
+        self._head.next = [None] * self._max_height
+        self._length = 0
+
+    def __len__(self) -> int:
+        return self._length
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return iter(self.iter())
+
+    def __contains__(self, value: T) -> bool:  # type: ignore
+        return self.find(value) is not None
+
+    def _random_level(self) -> int:
+        result = 1
+        while random.uniform(0, 1) < 0.5 and result < self._max_height:
+            result += 1
+        return result
+
+    def add(self, value: T) -> bool:
+        if value is None:
+            raise TypeError(value)
+
+        node = SkipList._Node(value, self._random_level())
+        update = [None] * self._max_height  # noqa
+        cur = self._head
+
+        for i in range(self._height - 1, -1, -1):
+            while cur.next[i] is not None and self._compare(value, cur.next[i].value) > 0:  # type: ignore
+                cur = cur.next[i]  # type: ignore
+            update[i] = cur  # type: ignore
+
+        cur = cur.next[0]  # type: ignore
+        if cur is not None:
+            if self._compare(value, cur.value) == 0:  # type: ignore
+                return False
+            node.prev, cur.prev = cur.prev, node
+        else:
+            node.prev = update[0]  # type: ignore
+
+        if node.level > self._height:
+            for i in range(self._height, node.level):
+                update[i] = self._head  # type: ignore
+            self._height = node.level
+
+        for i in range(node.level):
+            cur = update[i]  # type: ignore
+            node.next[i] = cur.next[i]  # noqa
+            cur.next[i] = node  # noqa
+
+        self._length += 1
+        return True
+
+    def _find(self, value: T) -> ta.Optional[_Node]:
+        if value is None:
+            raise TypeError(value)
+
+        cur = self._head
+
+        for i in range(self._height - 1, -1, -1):
+            while cur.next[i] and self._compare(value, cur.next[i].value) > 0:  # type: ignore
+                cur = cur.next[i]  # type: ignore
+
+        return cur.next[0]
+
+    def find(self, value: T) -> ta.Optional[T]:
+        node = self._find(value)
+        if node is None:
+            return None
+        if node is None or self._compare(value, node.value) != 0:  # type: ignore
+            return None
+        return node.value  # type: ignore
+
+    def remove(self, value: T) -> bool:
+        if value is None:
+            raise TypeError(value)
+
+        update = [None] * self._max_height  # noqa
+        cur = self._head
+
+        for i in range(self._height - 1, -1, -1):
+            while cur.next[i] is not None and self._compare(value, cur.next[i].value) > 0:  # type: ignore
+                cur = cur.next[i]  # type: ignore
+            update[i] = cur  # type: ignore
+
+        cur = cur.next[0]  # type: ignore
+        if cur is None or self._compare(value, cur.value) != 0:  # type: ignore
+            return False
+        elif cur.next[0] is not None:
+            cur.next[0].prev = cur.prev
+
+        for i in range(self._height):
+            if update[i].next[i] is not cur:  # type: ignore
+                break
+            update[i].next[i] = cur.next[i]  # type: ignore
+
+        while self._height > 0 and self._head.next[self._height - 1] is None:
+            self._height -= 1
+
+        self._length -= 1
+        return True
+
+    def iter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+        if base is not None:
+            cur = self._find(base)
+            while cur is not None and self._compare(base, cur.value) > 0:  # type: ignore
+                cur = cur.next[0]
+        else:
+            cur = self._head.next[0]
+
+        while cur is not None:
+            yield cur.value  # type: ignore
+            cur = cur.next[0]
+
+    def riter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+        if base is not None:
+            cur = self._find(base)
+            while cur is not self._head and self._compare(base, cur.value) < 0:  # type: ignore
+                cur = cur.prev  # type: ignore
+        else:
+            cur = self._head.next[self._height - 1]
+            while True:
+                next = cur.next[cur.next.index(None) - 1 if None in cur.next else -1]  # type: ignore  # noqa
+                if next is None:
+                    break
+                cur = next
+
+        while cur is not self._head:
+            yield cur.value  # type: ignore
+            cur = cur.prev  # type: ignore
+
+
+class SkipListDict(SortedListDict[K, V]):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(SkipList(comparator=SortedListDict._item_comparator), *args, **kwargs)

omlish/collections/sorted.py

@@ -0,0 +1,126 @@
+import abc
+import typing as ta
+
+from .. import lang
+from .mappings import yield_dict_init
+
+
+T = ta.TypeVar('T')
+U = ta.TypeVar('U')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+class SortedCollection(lang.Abstract, ta.Collection[T]):
+
+    Comparator = ta.Callable[[U, U], int]
+
+    @staticmethod
+    def default_comparator(a: T, b: T) -> int:
+        """https://docs.python.org/3.0/whatsnew/3.0.html#ordering-comparisons"""
+
+        return (a > b) - (a < b)  # type: ignore
+
+    @abc.abstractmethod
+    def __len__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __iter__(self) -> ta.Iterator[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __contains__(self, value: T) -> bool:  # type: ignore
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def add(self, value: T) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def find(self, value: T) -> ta.Optional[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def remove(self, value: T) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def iter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def riter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+        raise NotImplementedError
+
+
+class SortedMapping(ta.Mapping[K, V]):
+
+    @abc.abstractmethod
+    def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def ritems(self) -> ta.Iterator[tuple[K, V]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def itemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def ritemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
+        raise NotImplementedError
+
+
+class SortedMutableMapping(ta.MutableMapping[K, V], SortedMapping[K, V]):
+    pass
+
+
+class SortedListDict(SortedMutableMapping[K, V]):
+
+    @staticmethod
+    def _item_comparator(a: tuple[K, V], b: tuple[K, V]) -> int:
+        return SortedCollection.default_comparator(a[0], b[0])
+
+    def __init__(self, impl: SortedCollection, *args, **kwargs) -> None:
+        super().__init__()
+        self._impl = impl
+        for k, v in yield_dict_init(*args, **kwargs):
+            self[k] = v
+
+    @property
+    def debug(self) -> ta.Mapping[K, V]:
+        return dict(self)
+
+    def __getitem__(self, key: K) -> V:
+        item = self._impl.find((key, None))
+        if item is None:
+            raise KeyError(key)
+        return item[1]
+
+    def __setitem__(self, key: K, value: V) -> None:
+        self._impl.remove((key, None))
+        self._impl.add((key, value))
+
+    def __delitem__(self, key: K) -> None:
+        self._impl.remove((key, None))
+
+    def __len__(self) -> int:
+        return len(self._impl)
+
+    def __iter__(self) -> ta.Iterator[K]:
+        for k, v in self._impl:
+            yield k
+
+    def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore
+        yield from self._impl.iter()
+
+    def ritems(self) -> ta.Iterator[tuple[K, V]]:
+        yield from self._impl.riter()
+
+    def itemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
+        yield from self._impl.iter((key, None))
+
+    def ritemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
+        yield from self._impl.riter((key, None))