omlish 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__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
 
 
@@ -82,8 +83,8 @@ class CacheImpl(Cache[K, V]):
             lru_next: 'CacheImpl.Link'
             lfu_prev: 'CacheImpl.Link'
             lfu_next: 'CacheImpl.Link'
-            key: ta.Union[ta.Any, weakref.ref]
-            value: ta.Union[ta.Any, weakref.ref]
+            key: ta.Any | weakref.ref
+            value: ta.Any | weakref.ref
             weight: float
             written: float
             accessed: float
@@ -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}, '
@@ -120,7 +121,7 @@ class CacheImpl(Cache[K, V]):
             identity_keys: bool = False,
             expire_after_access: float | None = None,
             expire_after_write: float | None = None,
-            removal_listener: ta.Callable[[ta.Union[K, weakref.ref], ta.Union[V, weakref.ref]], None] | None = None,
+            removal_listener: ta.Callable[[K | weakref.ref, V | weakref.ref], None] | None = None,
             clock: ta.Callable[[], float] | None = None,
             weak_keys: bool = False,
             weak_values: bool = False,
@@ -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.Optional[ta.Deque[CacheImpl.Link]]
+        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

@@ -39,8 +39,8 @@ def seq(
 
 
 def opt_seq(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.Sequence[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.Sequence[T] | None:
     if it is None:
         return None
     else:
@@ -48,8 +48,8 @@ def opt_seq(
 
 
 def seq_or_none(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.Sequence[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.Sequence[T] | None:
     ret = opt_seq(it)
     if ret:
         return ret
@@ -58,7 +58,7 @@ def seq_or_none(
 
 
 def seq_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
+        fn: 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
@@ -68,8 +68,8 @@ def seq_of(
 
 
 def opt_seq_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.Sequence[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.Sequence[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -81,8 +81,8 @@ def opt_seq_of(
 
 
 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]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.Sequence[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -115,8 +115,8 @@ def abs_set(
 
 
 def opt_abs_set(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.AbstractSet[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.AbstractSet[T] | None:
     if it is None:
         return None
     else:
@@ -124,8 +124,8 @@ def opt_abs_set(
 
 
 def abs_set_or_none(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.AbstractSet[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.AbstractSet[T] | None:
     ret = opt_abs_set(it)
     if ret:
         return ret
@@ -134,7 +134,7 @@ def abs_set_or_none(
 
 
 def abs_set_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
+        fn: 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
@@ -144,8 +144,8 @@ def abs_set_of(
 
 
 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]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.AbstractSet[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -157,8 +157,8 @@ def opt_abs_set_of(
 
 
 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]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.AbstractSet[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -191,8 +191,8 @@ def frozenset_(
 
 
 def opt_frozenset(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[frozenset[T]]:
+        it: ta.Iterable[T] | None,
+) -> frozenset[T] | None:
     if it is None:
         return None
     else:
@@ -200,8 +200,8 @@ def opt_frozenset(
 
 
 def frozenset_or_none(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[frozenset[T]]:
+        it: ta.Iterable[T] | None,
+) -> frozenset[T] | None:
     ret = opt_frozenset(it)
     if ret:
         return ret
@@ -210,7 +210,7 @@ def frozenset_or_none(
 
 
 def frozenset_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
+        fn: 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
@@ -220,8 +220,8 @@ def frozenset_of(
 
 
 def opt_frozenset_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[frozenset[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], frozenset[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -233,8 +233,8 @@ def opt_frozenset_of(
 
 
 def frozenset_of_or_none(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[frozenset[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], frozenset[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -255,15 +255,15 @@ def frozenset_of_or_none(
 # region map
 
 
-def map(
-        src: ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]],
+def map(  # noqa
+        src: 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]]:
+        src: ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None,
+) -> ta.Mapping[K, V] | None:
     if src is None:
         return None
     else:
@@ -271,8 +271,8 @@ def opt_map(
 
 
 def map_or_none(
-        src: ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
-) -> ta.Optional[ta.Mapping[K, V]]:
+        src: ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None,
+) -> ta.Mapping[K, V] | None:
     ret = opt_map(src)
     if ret:
         return ret
@@ -281,10 +281,10 @@ def map_or_none(
 
 
 def map_of(
-        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
-        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+        key_fn: ta.Callable[[K], K2] | tuple,
+        value_fn: ta.Callable[[V], V2] | tuple,
 ) -> ta.Callable[
-    [ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
+    [ta.Mapping[K, V] | ta.Iterable[tuple[K, V]]],
     ta.Mapping[K2, V2],
 ]:
     def inner(src):
@@ -296,11 +296,11 @@ def map_of(
 
 
 def opt_map_of(
-        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
-        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+        key_fn: ta.Callable[[K], K2] | tuple,
+        value_fn: 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]],
+    [ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None],
+    ta.Mapping[K2, V2] | None,
 ]:
     def inner(src):
         if src is None:
@@ -314,11 +314,11 @@ def opt_map_of(
 
 
 def map_of_or_none(
-        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
-        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+        key_fn: ta.Callable[[K], K2] | tuple,
+        value_fn: 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]],
+    [ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None],
+    ta.Mapping[K2, V2] | None,
 ]:
     def inner(src):
         if src is None:

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,29 +63,29 @@ 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()))
 
 
 class FrozenList(ta.Sequence[T], Frozen):
 
-    def __init__(self, it: ta.Optional[ta.Iterable[T]] = None) -> None:
+    def __init__(self, it: ta.Iterable[T] | None = None) -> None:
         super().__init__()
 
         self._tup: tuple = tuple(it) if it is not None else ()
-        self._hash: ta.Optional[int] = None
+        self._hash: int | None = None
 
     @property
     def debug(self) -> ta.Sequence[T]:
         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):
@@ -111,7 +111,7 @@ class FrozenList(ta.Sequence[T], Frozen):
             self._hash = hash(self._tup)
         return self._hash
 
-    def __getitem__(self, idx: ta.Union[int, slice]) -> 'FrozenList[T]':  # type: ignore
+    def __getitem__(self, idx: int | slice) -> 'FrozenList[T]':  # type: ignore
         if isinstance(idx, int):
             return self._tup[idx]
         else:

omlish/collections/identity.py

@@ -1,3 +1,4 @@
+import contextlib
 import operator as op
 import typing as ta
 
@@ -63,13 +64,13 @@ 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()
 
 
 class IdentitySet(ta.MutableSet[T]):
 
-    def __init__(self, init: ta.Optional[ta.Iterable[T]] = None) -> None:
+    def __init__(self, init: ta.Iterable[T] | None = None) -> None:
         super().__init__()
         self._dict: dict[int, T] = {}
         if init is not None:
@@ -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

@@ -8,7 +8,7 @@ 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]:
+def multikey_dict(dct: ta.Mapping[ta.Iterable[K] | K, V], *, deep: bool = False) -> dict[K, V]:
     ret = {}
     for k, v in dct.items():
         if deep and isinstance(v, dict):
@@ -23,7 +23,7 @@ def multikey_dict(dct: ta.Mapping[ta.Union[ta.Iterable[K], K], V], *, deep: bool
 
 def guarded_map_update(
         dst: ta.MutableMapping[ta.Any, ta.Any],
-        *srcs: ta.Mapping[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():
@@ -68,10 +68,10 @@ 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]) -> ta.Optional[T]:
+    def get(self, ty: type[T]) -> T | None:
         return self._dct.get(ty)
 
     def __getitem__(self, ty: type[T]) -> ta.Sequence[T]:
@@ -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

@@ -6,7 +6,7 @@ T = ta.TypeVar('T')
 
 class OrderedSet(ta.MutableSet[T]):
 
-    def __init__(self, iterable: ta.Optional[ta.Iterable[T]] = None) -> None:
+    def __init__(self, iterable: ta.Iterable[T] | None = None) -> None:
         super().__init__()
         self._dct: dict[T, ta.Any] = {}
         if iterable is not None:
@@ -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

@@ -27,7 +27,7 @@ class SkipList(SortedCollection[T]):
         def __init__(
                 self,
                 value: T,
-                level: int
+                level: int,
         ) -> None:
             super().__init__()
 
@@ -46,7 +46,7 @@ class SkipList(SortedCollection[T]):
             self,
             *,
             max_height: int = 16,
-            comparator: ta.Optional[SortedCollection.Comparator[T]] = None,
+            comparator: SortedCollection.Comparator[T] | None = None,
     ) -> None:
         super().__init__()
 
@@ -108,7 +108,7 @@ class SkipList(SortedCollection[T]):
         self._length += 1
         return True
 
-    def _find(self, value: T) -> ta.Optional[_Node]:
+    def _find(self, value: T) -> _Node | None:
         if value is None:
             raise TypeError(value)
 
@@ -120,7 +120,7 @@ class SkipList(SortedCollection[T]):
 
         return cur.next[0]
 
-    def find(self, value: T) -> ta.Optional[T]:
+    def find(self, value: T) -> T | None:
         node = self._find(value)
         if node is None:
             return None
@@ -157,7 +157,7 @@ class SkipList(SortedCollection[T]):
         self._length -= 1
         return True
 
-    def iter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def iter(self, base: T | None = 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
@@ -169,7 +169,7 @@ class SkipList(SortedCollection[T]):
             yield cur.value  # type: ignore
             cur = cur.next[0]
 
-    def riter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def riter(self, base: T | None = 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
@@ -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

@@ -38,7 +38,7 @@ class SortedCollection(lang.Abstract, ta.Collection[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def find(self, value: T) -> ta.Optional[T]:
+    def find(self, value: T) -> T | None:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -46,11 +46,11 @@ class SortedCollection(lang.Abstract, ta.Collection[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def iter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def iter(self, base: T | None = None) -> ta.Iterable[T]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def riter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def riter(self, base: T | None = None) -> ta.Iterable[T]:
         raise NotImplementedError
 
 
@@ -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