omlish 0.0.0.dev2__py3-none-any.whl → 0.0.0.dev4__py3-none-any.whl

omlish/collections/cache/impl.py

@@ -8,6 +8,7 @@ TODO:
  - further cythonize hot path?
 """
 import collections
+import contextlib
 import functools
 import logging
 import time
@@ -17,7 +18,7 @@ import weakref
 from ... import lang
 from .types import Cache
 from .types import Eviction
-from .types import OverweightException
+from .types import OverweightError
 
 
 K = ta.TypeVar('K')
@@ -33,15 +34,15 @@ class SKIP(lang.Marker):
     pass
 
 
-def LRU(cache: 'Cache') -> None:
+def LRU(cache: 'Cache') -> None:  # noqa
     cache._kill(cache._root.lru_next)  # type: ignore  # noqa
 
 
-def LRI(cache: 'Cache') -> None:
+def LRI(cache: 'Cache') -> None:  # noqa
     cache._kill(cache._root.ins_next)  # type: ignore  # noqa
 
 
-def LFU(cache: 'Cache') -> None:
+def LFU(cache: 'Cache') -> None:  # noqa
     cache._kill(cache._root.lfu_prev)  # type: ignore  # noqa
 
 
@@ -92,7 +93,7 @@ class CacheImpl(Cache[K, V]):
 
             def __repr__(self) -> str:
                 return (
-                    f'Link@{str(self.seq)}('
+                    f'Link@{self.seq!s}('
                     f'ins_prev={("@" + str(self.ins_prev.seq)) if self.ins_prev is not None else None}, '
                     f'ins_next={("@" + str(self.ins_next.seq)) if self.ins_next is not None else None}, '
                     f'lru_prev={("@" + str(self.lru_prev.seq)) if self.lru_prev is not None else None}, '
@@ -165,7 +166,7 @@ class CacheImpl(Cache[K, V]):
         if self._track_frequency:
             self._root.lfu_next = self._root.lfu_prev = self._root
 
-        weak_dead: ta.Deque[CacheImpl.Link] | None
+        weak_dead: collections.deque[CacheImpl.Link] | None
         if weak_keys or weak_values:
             weak_dead = collections.deque()
             weak_dead_ref = weakref.ref(weak_dead)
@@ -276,10 +277,8 @@ class CacheImpl(Cache[K, V]):
             raise Exception
 
         def fail():
-            try:
+            with contextlib.suppress(KeyError):
                 del self._cache[cache_key]
-            except KeyError:
-                pass
             self._unlink(link)
             raise KeyError(key)
 
@@ -309,7 +308,7 @@ class CacheImpl(Cache[K, V]):
                 link, value = self._get_link(key)
             except KeyError:
                 self._misses += 1
-                raise KeyError(key)
+                raise KeyError(key) from None
 
             if link.lru_next is not self._root:
                 link.lru_prev.lru_next = link.lru_next
@@ -340,7 +339,7 @@ class CacheImpl(Cache[K, V]):
             return value
 
     @staticmethod
-    def _weak_die(dead_ref: weakref.ref, link: Link, key_ref: weakref.ref) -> None:
+    def _weak_die(dead_ref: weakref.ref, link: Link, key_ref: weakref.ref) -> None:  # noqa
         dead = dead_ref()
         if dead is not None:
             dead.append(link)
@@ -372,7 +371,7 @@ class CacheImpl(Cache[K, V]):
 
             if self._max_weight is not None and weight > self._max_weight:
                 if self._raise_overweight:
-                    raise OverweightException
+                    raise OverweightError
                 else:
                     return
 
@@ -387,10 +386,18 @@ class CacheImpl(Cache[K, V]):
                 self._eviction(self)
 
             link = CacheImpl.Link()
+
             self._seq += 1
             link.seq = self._seq
-            link.key = weakref.ref(key, functools.partial(CacheImpl._weak_die, self._weak_dead_ref, link)) if self._weak_keys else key  # noqa
-            link.value = weakref.ref(value, functools.partial(CacheImpl._weak_die, self._weak_dead_ref, link)) if self._weak_values else value  # noqa
+
+            def make_ref(o, b):
+                if not b:
+                    return o
+                return weakref.ref(o, functools.partial(CacheImpl._weak_die, self._weak_dead_ref, link))  # type: ignore  # noqa
+
+            link.key = make_ref(key, self._weak_keys)
+            link.value = make_ref(value, self._weak_values)
+
             link.weight = weight
             link.written = link.accessed = self._clock()
             link.hits = 0
@@ -463,10 +470,10 @@ class CacheImpl(Cache[K, V]):
                 else:
                     yield key  # type: ignore
 
-                next = link.ins_prev
-                if next is link:
+                nxt = link.ins_prev
+                if nxt is link:
                     raise ValueError
-                link = next
+                link = nxt
 
     @property
     def stats(self) -> Cache.Stats:

omlish/collections/cache/types.py

@@ -6,7 +6,7 @@ K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
 
-class OverweightException(Exception):
+class OverweightError(Exception):
     pass
 
 

omlish/collections/coerce.py

@@ -255,7 +255,7 @@ def frozenset_of_or_none(
 # region map
 
 
-def map(
+def map(  # noqa
         src: ta.Mapping[K, V] | ta.Iterable[tuple[K, V]],
 ) -> ta.Mapping[K, V]:
     return FrozenDict(src)

omlish/collections/frozen.py

@@ -17,7 +17,7 @@ class Frozen(ta.Hashable, abc.ABC):
 
 class FrozenDict(ta.Mapping[K, V], Frozen):
 
-    def __new__(cls, *args, **kwargs) -> 'FrozenDict[K, V]':
+    def __new__(cls, *args: ta.Any, **kwargs: ta.Any) -> 'FrozenDict[K, V]':  # noqa
         if len(args) == 1 and Frozen in type(args[0]).__bases__:
             return args[0]
         return super().__new__(cls)
@@ -35,10 +35,10 @@ class FrozenDict(ta.Mapping[K, V], Frozen):
         return dict(self._dct)
 
     def __repr__(self) -> str:
-        return '(%r)' % (self._dct,)
+        return f'({self._dct!r})'
 
     def __eq__(self, other) -> bool:
-        return type(self) == type(other) and self._dct == other._dct
+        return type(self) is type(other) and self._dct == other._dct
 
     def __getitem__(self, key: K) -> V:
         return self._dct[key]
@@ -63,11 +63,11 @@ class FrozenDict(ta.Mapping[K, V], Frozen):
     def __setstate__(self, t):
         self.__init__(t)  # type: ignore
 
-    def drop(self, *keys):
+    def drop(self, *keys: T) -> 'FrozenDict[K, V]':
         ks = frozenset(keys)
         return type(self)((k, self[k]) for k in self if k not in ks)
 
-    def set(self, *args, **kwargs):
+    def set(self, *args: ta.Any, **kwargs: ta.Any) -> 'FrozenDict[K, V]':
         new = type(self)(*args, **kwargs)
         return type(self)(itertools.chain(self.items(), new.items()))
 
@@ -85,7 +85,7 @@ class FrozenList(ta.Sequence[T], Frozen):
         return list(self)
 
     def __repr__(self) -> str:
-        return '([%s])' % (', '.join(map(repr, self._tup)),)
+        return f'([{", ".join(map(repr, self._tup))}])'
 
     def __add__(self, o) -> 'FrozenList[T]':
         if isinstance(o, FrozenList):

omlish/collections/identity.py

@@ -1,3 +1,4 @@
+import contextlib
 import operator as op
 import typing as ta
 
@@ -63,7 +64,7 @@ class IdentityKeyDict(ta.MutableMapping[K, V]):
     def __iter__(self) -> ta.Iterator[K]:
         return iter(map(op.itemgetter(0), self._dict.values()))
 
-    def clear(self):
+    def clear(self) -> None:
         self._dict.clear()
 
 
@@ -87,10 +88,8 @@ class IdentitySet(ta.MutableSet[T]):
         self._dict[id(item)] = item
 
     def discard(self, item: T) -> None:
-        try:
+        with contextlib.suppress(KeyError):
             del self._dict[id(item)]
-        except KeyError:
-            pass
 
     def update(self, items: ta.Iterable[T]) -> None:
         for item in items:

omlish/collections/mappings.py

@@ -68,7 +68,7 @@ class TypeMap(ta.Generic[T]):
     def __len__(self) -> int:
         return len(self._items)
 
-    def __iter__(self) -> ta.Iterable[T]:
+    def __iter__(self) -> ta.Iterator[T]:
         return iter(self._items)
 
     def get(self, ty: type[T]) -> T | None:
@@ -99,7 +99,7 @@ class TypeMultiMap(ta.Generic[V]):
     def __len__(self) -> int:
         return len(self._items)
 
-    def __iter__(self) -> ta.Iterable[V]:
+    def __iter__(self) -> ta.Iterator[V]:
         return iter(self._items)
 
     def __getitem__(self, ty: type[T]) -> ta.Sequence[T]:

omlish/collections/ordered.py

@@ -37,17 +37,17 @@ class OrderedSet(ta.MutableSet[T]):
     def __reversed__(self):
         return reversed(self._dct.keys())
 
-    def pop(self, last=True):
+    def pop(self, last: bool = True) -> T:
         if not self:
             raise KeyError('set is empty')
         item = next(reversed(self._dct.keys()))
         self.discard(item)
         return item
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if not self:
-            return '%s()' % (self.__class__.__name__,)
-        return '%s(%r)' % (self.__class__.__name__, list(self))
+            return f'{self.__class__.__name__}()'
+        return f'{self.__class__.__name__}({list(self)!r})'
 
     def __eq__(self, other) -> bool:
         if isinstance(other, OrderedSet):
@@ -55,11 +55,11 @@ class OrderedSet(ta.MutableSet[T]):
         return set(self) == set(other)
 
 
-class OrderedFrozenSet(ta.FrozenSet[T]):
+class OrderedFrozenSet(ta.FrozenSet[T]):  # noqa
 
     _list: ta.Sequence[T]
 
-    def __new__(cls, items: ta.Iterable[T]) -> ta.FrozenSet[T]:  # type: ignore
+    def __new__(cls, items: ta.Iterable[T]) -> frozenset[T]:  # type: ignore
         item_set = set()
         item_list = []
         for item in items:
@@ -76,6 +76,6 @@ class OrderedFrozenSet(ta.FrozenSet[T]):
     def __iter__(self) -> ta.Iterator[T]:
         return iter(self._list)
 
-    def __sub__(self, other: ta.Iterable[T]) -> ta.FrozenSet[T]:
+    def __sub__(self, other: ta.Iterable[T]) -> frozenset[T]:
         s = set(other)
         return type(self)(i for i in self if i not in s)

omlish/collections/skiplist.py

@@ -190,4 +190,4 @@ class SkipList(SortedCollection[T]):
 class SkipListDict(SortedListDict[K, V]):
 
     def __init__(self, *args, **kwargs) -> None:
-        super().__init__(SkipList(comparator=SortedListDict._item_comparator), *args, **kwargs)
+        super().__init__(SkipList(comparator=SortedListDict._item_comparator), *args, **kwargs)  # noqa

omlish/collections/sorted.py

@@ -110,7 +110,7 @@ class SortedListDict(SortedMutableMapping[K, V]):
         return len(self._impl)
 
     def __iter__(self) -> ta.Iterator[K]:
-        for k, v in self._impl:
+        for k, _ in self._impl:
             yield k
 
     def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore

omlish/collections/treap.py

@@ -16,6 +16,8 @@ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEM
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 """
+# ruff: noqa: SLF001
+
 import typing as ta
 
 
@@ -41,6 +43,9 @@ class TreapNode(ta.Generic[T]):
         self._left = _left
         self._right = _right
 
+    def __repr__(self) -> str:
+        return f'TreapNode(value={self._value!r}, priority={self._priority!r})'
+
     @property
     def value(self) -> T:
         return self._value
@@ -78,6 +83,26 @@ def find(n: TreapNode[T] | None, v: T, c: Comparer[T]) -> TreapNode[T] | None:
             n = n._left  # noqa
 
 
+def place(n: TreapNode[T] | None, v: T, c: Comparer[T], *, desc: bool = False) -> list[TreapNode[T]]:
+    ret: list[TreapNode[T]] = []
+    while True:
+        if n is None:
+            break
+        diff = c(n._value, v)  # noqa
+        if diff == 0:
+            ret.append(n)
+            break
+        elif diff < 0:
+            if desc:
+                ret.append(n)
+            n = n._right  # noqa
+        else:
+            if not desc:
+                ret.append(n)
+            n = n._left  # noqa
+    return ret
+
+
 def union(
         n: TreapNode[T] | None,
         other: TreapNode[T] | None,

omlish/collections/treapmap.py

@@ -16,6 +16,7 @@ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEM
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 """
+import abc
 import random
 import typing as ta
 
@@ -74,13 +75,38 @@ class TreapMap(PersistentMap[K, V]):
         i = TreapMapIterator(
             _st=[],
             _n=self._n,
-            _b=False,
         )
         while (n := i._n) is not None and n.left is not None:  # noqa
             i._st.append(n)  # noqa
             i._n = n.left  # noqa
         return i
 
+    def iterate_from(self, k: K) -> 'TreapMapIterator[K, V]':
+        lst = treap.place(self._n, (k, None), self._c)  # type: ignore
+        i = TreapMapIterator(
+            _st=lst,
+            _n=lst.pop(),
+        )
+        return i
+
+    def reverse_iterate(self) -> 'TreapMapReverseIterator[K, V]':
+        i = TreapMapReverseIterator(
+            _st=[],
+            _n=self._n,
+        )
+        while (n := i._n) is not None and n.right is not None:  # noqa
+            i._st.append(n)  # noqa
+            i._n = n.right  # noqa
+        return i
+
+    def reverse_iterate_from(self, k: K) -> 'TreapMapReverseIterator[K, V]':
+        lst = treap.place(self._n, (k, None), self._c, desc=True)  # type: ignore
+        i = TreapMapReverseIterator(
+            _st=lst,
+            _n=lst.pop(),
+        )
+        return i
+
     def with_(self, k: K, v: V) -> 'TreapMap[K, V]':
         node = treap.TreapNode(
             _value=(k, v),
@@ -108,25 +134,31 @@ def new_treap_map(cmp: ta.Callable[[tuple[K, V], tuple[K, V]], int]) -> Persiste
     return TreapMap(_n=None, _c=cmp)
 
 
-class TreapMapIterator(ta.Generic[K, V]):
-    __slots__ = ('_st', '_n', '_b')
+class BaseTreapMapIterator(abc.ABC, ta.Generic[K, V]):
+    __slots__ = ('_st', '_n')
 
     def __init__(
             self,
             *,
             _st: list[treap.TreapNode[tuple[K, V]]],
             _n: treap.TreapNode[tuple[K, V]] | None,
-            _b: bool,
     ) -> None:
         super().__init__()
 
         self._st = _st
         self._n = _n
-        self._b = _b
 
     def has_next(self) -> bool:
         return self._n is not None
 
+    @abc.abstractmethod
+    def next(self) -> tuple[K, V]:
+        raise NotImplementedError
+
+
+class TreapMapIterator(BaseTreapMapIterator[K, V]):
+    __slots__ = BaseTreapMapIterator.__slots__
+
     def next(self) -> tuple[K, V]:
         n = self._n
         if n is None:
@@ -142,3 +174,23 @@ class TreapMapIterator(ta.Generic[K, V]):
         else:
             self._n = None
         return n.value
+
+
+class TreapMapReverseIterator(BaseTreapMapIterator[K, V]):
+    __slots__ = BaseTreapMapIterator.__slots__
+
+    def next(self) -> tuple[K, V]:
+        n = self._n
+        if n is None:
+            raise StopIteration
+        if n.left is not None:
+            self._n = n.left
+            while self._n.right is not None:
+                self._st.append(self._n)
+                self._n = self._n.right
+        elif len(self._st) > 0:
+            self._n = self._st[-1]
+            self._st.pop()
+        else:
+            self._n = None
+        return n.value

omlish/collections/unmodifiable.py

@@ -22,12 +22,12 @@ class UnmodifiableSequence(ta.Sequence[T], Unmodifiable, lang.Final):
         self._target = target
 
     def __repr__(self) -> str:
-        return '%s(%r)' % (type(self).__name__, self._target)
+        return f'{type(self).__name__}({self._target!r})'
 
     def __contains__(self, x: ta.Any) -> bool:
         return x in self._target
 
-    def __eq__(self, o: ta.Any) -> bool:
+    def __eq__(self, o: object) -> bool:
         return self._target == o
 
     def __ge__(self, other: ta.Any) -> bool:
@@ -51,7 +51,7 @@ class UnmodifiableSequence(ta.Sequence[T], Unmodifiable, lang.Final):
     def __lt__(self, other: ta.Any) -> bool:
         return self._target < other
 
-    def __ne__(self, o: ta.Any) -> bool:
+    def __ne__(self, o: object) -> bool:
         return self._target != o
 
     def __reversed__(self) -> ta.Iterator[T]:
@@ -74,7 +74,7 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
         self._target = target
 
     def __repr__(self) -> str:
-        return '%s(%r)' % (type(self).__name__, self._target)
+        return f'{type(self).__name__}({self._target!r})'
 
     def __and__(self, s: ta.AbstractSet[ta.Any]) -> ta.AbstractSet[T]:
         return self._target & s
@@ -82,7 +82,7 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
     def __contains__(self, x: ta.Any) -> bool:
         return x in self._target
 
-    def __eq__(self, o: ta.Any) -> bool:
+    def __eq__(self, o: object) -> bool:
         return self._target == o
 
     def __ge__(self, s: ta.AbstractSet[ta.Any]) -> bool:
@@ -103,7 +103,7 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
     def __lt__(self, s: ta.AbstractSet[ta.Any]) -> bool:
         return self._target > s
 
-    def __ne__(self, o: ta.Any) -> bool:
+    def __ne__(self, o: object) -> bool:
         return self._target != o
 
     def __or__(self, s: ta.AbstractSet[T]) -> ta.AbstractSet[T]:  # type: ignore
@@ -130,12 +130,12 @@ class UnmodifiableMapping(ta.Mapping[K, V], Unmodifiable, lang.Final):
         self._target = target
 
     def __repr__(self) -> str:
-        return '%s(%r)' % (type(self).__name__, self._target)
+        return f'{type(self).__name__}({self._target!r})'
 
     def __contains__(self, o: ta.Any) -> bool:
         return o in self._target
 
-    def __eq__(self, o: ta.Any) -> bool:
+    def __eq__(self, o: object) -> bool:
         return self._target == o
 
     def __ge__(self, other: ta.Any) -> bool:
@@ -159,7 +159,7 @@ class UnmodifiableMapping(ta.Mapping[K, V], Unmodifiable, lang.Final):
     def __lt__(self, other: ta.Any) -> bool:
         return self._target < other
 
-    def __ne__(self, o: ta.Any) -> bool:
+    def __ne__(self, o: object) -> bool:
         return self._target != o
 
     def get(self, k: K, default=None) -> V | None:  # type: ignore

omlish/collections/utils.py

@@ -18,7 +18,7 @@ def mut_toposort(data: dict[T, set[T]]) -> ta.Iterator[set[T]]:
     extra_items_in_deps = functools.reduce(set.union, data.values()) - set(data.keys())
     data.update({item: set() for item in extra_items_in_deps})
     while True:
-        ordered = set(item for item, dep in data.items() if not dep)
+        ordered = {item for item, dep in data.items() if not dep}
         if not ordered:
             break
         yield ordered

omlish/configs/flattening.py

@@ -1,4 +1,5 @@
 import abc
+import itertools
 import typing as ta
 
 from .. import check
@@ -34,10 +35,10 @@ class Flattening:
         self._index_close = check.not_empty(index_close)
 
     def flatten(self, unflattened: StrMap) -> StrMap:
-        def rec(prefix: ta.List[str], value: ta.Any) -> None:
+        def rec(prefix: list[str], value: ta.Any) -> None:
             if isinstance(value, dict):
                 for k, v in value.items():
-                    rec(prefix + [k], v)
+                    rec([*prefix, k], v)
             elif isinstance(value, list):
                 check.not_empty(prefix)
                 for i, v in enumerate(value):
@@ -48,7 +49,7 @@ class Flattening:
                     raise KeyError(k)
                 ret[k] = value
 
-        ret: ta.Dict[str, ta.Any] = {}
+        ret: dict[str, ta.Any] = {}
         rec([], unflattened)
         return ret
 
@@ -83,7 +84,7 @@ class Flattening:
         def __init__(self) -> None:
             super().__init__()
 
-            self._dict: ta.Dict[str, ta.Any] = {}
+            self._dict: dict[str, ta.Any] = {}
 
         def get(self, key: str) -> ta.Any:
             return self._dict.get(key, _MISSING)
@@ -100,7 +101,7 @@ class Flattening:
         def __init__(self) -> None:
             super().__init__()
 
-            self._list: ta.List[ta.Any] = []
+            self._list: list[ta.Any] = []
 
         def get(self, key: int) -> ta.Any:
             check.arg(key >= 0)
@@ -135,7 +136,7 @@ class Flattening:
         for fk, v in flattened.items():
             node: Flattening.UnflattenNode = root
             fks = list(split_keys(fk))
-            for key, nkey in zip(fks, fks[1:]):
+            for key, nkey in itertools.pairwise(fks):
                 if isinstance(nkey, str):
                     node = node.setdefault(key, Flattening.UnflattenDict)
                 elif isinstance(nkey, int):

omlish/configs/props.py

@@ -19,8 +19,8 @@ def escape(token: str) -> str:
     return _ESCAPE_PATTERN.sub(r'\\\1', token)
 
 
-def parse_line(line: str) -> ta.Tuple[str, str] | None:
-    if line and not (line.startswith('#') or line.startswith('!')):
+def parse_line(line: str) -> tuple[str, str] | None:
+    if line and not line.startswith(('#', '!')):
         match = _SEPARATOR_PATTERN.search(line)
         if match:
             return normalize(line[:match.start()]), normalize(line[match.end():])
@@ -54,7 +54,7 @@ def coalesce_lines(lines: ta.Iterable[str]) -> ta.Generator[str, None, None]:
         pass
 
 
-def parse_lines(lines: ta.Iterable[str]) -> ta.Dict[str, str]:
+def parse_lines(lines: ta.Iterable[str]) -> dict[str, str]:
     props = {}
     for line in coalesce_lines(lines):
         kv_pair = parse_line(line)

omlish/dataclasses/__init__.py

@@ -54,7 +54,7 @@ globals()['make_dataclass'] = xmake_dataclass
 
 
 from .impl.exceptions import (  # noqa
-    CheckException,
+    CheckError,
 )
 
 from .impl.metaclass import (  # noqa

omlish/dataclasses/impl/__init__.py

@@ -4,5 +4,21 @@ TODO:
   - cleanup confer
  - descriptors - check_type/validators don't handle setters lol
  - deep_frozen?
- - repr='redact', 'if_not_none', 'if_truthy', dc.if_(lambda v: ...)? just a lambda returning str | None?
+ - field:
+  - frozen
+  - pickle/transient
+  - mangled
+  - doc
+  - derive
+  - check_type
+ - class
+  - strict_eq
+  - allow_setattr
+  - mangler
+ - observable
+ - c/py gen
+ - iterable
+ - proto/jsonschema gen
+ - enums
+ - nodal
 """