omlish 0.0.0.dev2__tar.gz → 0.0.0.dev3__tar.gz

{omlish-0.0.0.dev2/omlish.egg-info → omlish-0.0.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev2
+Version: 0.0.0.dev3
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/__about__.py

@@ -1,7 +1,6 @@
-__name__ = 'omlish'
 __author__ = 'wrmsr'
 __url__ = 'https://github.com/wrmsr/omlish'
 __license__ = 'BSD-3-Clause'
 __requires_python__ = '>=3.12'
 
-__version__ = '0.0.0.dev2'
+__version__ = '0.0.0.dev3'

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/argparse.py

@@ -164,7 +164,7 @@ class _CliMeta(type):
         namespace['_parser'] = parser
 
         subparsers = parser.add_subparsers()
-        for name, obj in objs.items():
+        for att, obj in objs.items():
             if isinstance(obj, Command):
                 if obj.parent is not None:
                     raise NotImplementedError
@@ -174,14 +174,14 @@ class _CliMeta(type):
                 cparser.set_defaults(_cmd=obj)
 
             elif isinstance(obj, Arg):
-                if name in anns:
-                    akwargs = get_arg_ann_kwargs(anns[name])
+                if att in anns:
+                    akwargs = get_arg_ann_kwargs(anns[att])
                     obj.kwargs = {**akwargs, **obj.kwargs}
                 if not obj.dest:
                     if 'dest' in obj.kwargs:
                         obj.dest = obj.kwargs['dest']
                     else:
-                        obj.dest = obj.kwargs['dest'] = name  # type: ignore
+                        obj.dest = obj.kwargs['dest'] = att  # type: ignore
                 parser.add_argument(*obj.args, **obj.kwargs)
 
             else:

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/asyncs/__init__.py

@@ -8,8 +8,8 @@ from .asyncs import (  # noqa
 
 
 from .futures import (  # noqa
-    FutureException,
-    FutureTimeoutException,
+    FutureError,
+    FutureTimeoutError,
     ImmediateExecutor,
     new_thread_or_immediate_executor,
     wait_dependent_futures,

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/asyncs/anyio.py

@@ -39,11 +39,12 @@ def split_memory_object_streams(
 
 
 # FIXME: https://github.com/python/mypy/issues/15238
-# def create_memory_object_stream[T](max_buffer_size: float = 0) -> tuple[
-#     anyio.streams.memory.MemoryObjectSendStream[T],
-#     anyio.streams.memory.MemoryObjectReceiveStream[T],
-# ]:
-#     return anyio.create_memory_object_stream[T](max_buffer_size)
+# FIXME: https://youtrack.jetbrains.com/issues?q=tag:%20%7BPEP%20695%7D
+def create_memory_object_stream[T](max_buffer_size: float = 0) -> tuple[
+    anyio.streams.memory.MemoryObjectSendStream[T],
+    anyio.streams.memory.MemoryObjectReceiveStream[T],
+]:
+    return anyio.create_memory_object_stream[T](max_buffer_size)  # noqa
 
 
 def staple_memory_object_stream(
@@ -57,12 +58,13 @@ def staple_memory_object_stream(
 
 
 # FIXME: https://github.com/python/mypy/issues/15238
-# def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> anyio.streams.stapled.StapledObjectStream[T]:
-#     send, receive = anyio.create_memory_object_stream[T](max_buffer_size)
-#     return anyio.streams.stapled.StapledObjectStream(
-#         check.isinstance(send, anyio.streams.memory.MemoryObjectSendStream),  # type: ignore
-#         check.isinstance(receive, anyio.streams.memory.MemoryObjectReceiveStream),  # type: ignore
-#     )
+# FIXME: https://youtrack.jetbrains.com/issues?q=tag:%20%7BPEP%20695%7D
+def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> anyio.streams.stapled.StapledObjectStream[T]:
+    send, receive = anyio.create_memory_object_stream[T](max_buffer_size)
+    return anyio.streams.stapled.StapledObjectStream(
+        check.isinstance(send, anyio.streams.memory.MemoryObjectSendStream),  # type: ignore
+        check.isinstance(receive, anyio.streams.memory.MemoryObjectReceiveStream),  # type: ignore
+    )
 
 
 async def gather(*fns: ta.Callable[..., ta.Awaitable[T]], take_first: bool = False) -> list[lang.Maybe[T]]:

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/asyncs/asyncs.py

@@ -26,10 +26,8 @@ def sync_await(fn: ta.Callable[..., T], *args, **kwargs) -> T:
 
     cr = gate()
     with contextlib.closing(cr):
-        try:
+        with contextlib.suppress(StopIteration):
             cr.send(None)
-        except StopIteration:
-            pass
         if ret is missing or cr.cr_await is not None or cr.cr_running:
             raise TypeError('Not terminated')
 

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/asyncs/futures.py

@@ -5,12 +5,13 @@ import typing as ta
 
 
 T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
 
 
 ##
 
 
-class FutureException(Exception, ta.Generic[T]):
+class FutureError(Exception, ta.Generic[T]):
 
     def __init__(self, future: cf.Future, target: T | None = None) -> None:
         super().__init__()
@@ -37,7 +38,7 @@ class FutureException(Exception, ta.Generic[T]):
     __str__ = __repr__
 
 
-class FutureTimeoutException(Exception):
+class FutureTimeoutError(Exception):
     pass
 
 
@@ -61,14 +62,14 @@ def wait_futures(
                     if cancel_on_exception:
                         for cancel_fut in not_done:
                             cancel_fut.cancel()
-                    raise FutureException(fut) from fut.exception()
+                    raise FutureError(fut) from fut.exception()
 
         not_done -= done
         if not not_done:
             return True
 
         if time.time() >= (start + timeout_s):
-            raise FutureTimeoutException
+            raise FutureTimeoutError
         time.sleep(tick_interval_s)
 
     return False
@@ -91,7 +92,7 @@ def wait_dependent_futures(
             if fn in dependency_sets_by_fn[dep]:
                 raise Exception(f'Cyclic dependencies: {fn} <-> {dep}', fn, dep)
 
-    dependent_sets_by_fn: ta.Dict[ta.Callable, ta.Set[ta.Callable]] = {fn: set() for fn in dependency_sets_by_fn}
+    dependent_sets_by_fn: dict[ta.Callable, set[ta.Callable]] = {fn: set() for fn in dependency_sets_by_fn}
     for fn, deps in dependency_sets_by_fn.items():
         for dep in deps:
             dependent_sets_by_fn[dep].add(fn)
@@ -114,7 +115,7 @@ def wait_dependent_futures(
         for fut in done:
             if fut.exception():
                 cancel()
-                raise FutureException(fut) from fut.exception()
+                raise FutureError(fut) from fut.exception()
 
             fn = fns_by_fut[fut]
             for dependent_fn in dependent_sets_by_fn.get(fn, set()):
@@ -128,11 +129,11 @@ def wait_dependent_futures(
 
         if time.time() >= (start + timeout_s):
             cancel()
-            raise FutureTimeoutException
+            raise FutureTimeoutError
 
     remaining_fns = {fn: deps for fn, deps in remaining_dep_sets_by_fn.items() if deps}
     if remaining_fns:
-        raise Exception(f"Unfinished fns: {remaining_fns}", remaining_fns)
+        raise Exception(f'Unfinished fns: {remaining_fns}', remaining_fns)
 
     futs_by_fn = {fn: fut for fut, fn in fns_by_fut.items()}
     return futs_by_fn
@@ -147,7 +148,7 @@ class ImmediateExecutor(cf.Executor):
         super().__init__()
         self._immediate_exceptions = immediate_exceptions
 
-    def submit(self, fn, *args, **kwargs):
+    def submit(self, fn: ta.Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> cf.Future[T]:
         future: ta.Any = cf.Future()
         try:
             result = fn(*args, **kwargs)

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/c3.py

@@ -113,7 +113,7 @@ def mro(
     abstract_c3_mros = [mro(base, abcs=abcs, get_bases=get_bases, is_subclass=is_subclass) for base in abstract_bases]
     other_c3_mros = [mro(base, abcs=abcs, get_bases=get_bases, is_subclass=is_subclass) for base in other_bases]
     return merge(
-        [[cls]] +
+        [[cls]] +  # noqa
         explicit_c3_mros + abstract_c3_mros + other_c3_mros +
         [explicit_bases] + [abstract_bases] + [other_bases],
     )

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/check.py

@@ -9,7 +9,7 @@ import typing as ta
 T = ta.TypeVar('T')
 SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
 
-Message = ta.Union[str, ta.Callable[..., str | None], None]
+Message = str | ta.Callable[..., str | None] | None
 
 _NONE_TYPE = type(None)
 
@@ -52,7 +52,7 @@ def _unpack_isinstance_spec(spec: ta.Any) -> tuple:
     if not _isinstance(spec, tuple):
         spec = (spec,)
     if None in spec:
-        spec = tuple(filter(None, spec)) + (_NONE_TYPE,)
+        spec = tuple(filter(None, spec)) + (_NONE_TYPE,)  # noqa
     if ta.Any in spec:
         spec = (object,)
     return spec
@@ -206,7 +206,7 @@ def is_not(v: T, *os: ta.Any, msg: Message = None) -> T:
     return v
 
 
-def callable(v: T, msg: Message = None) -> T:
+def callable(v: T, msg: Message = None) -> T:  # noqa
     if not _callable(v):
         _raise(TypeError, 'Must be callable', msg, v)
     return v  # type: ignore

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/collections/_abc.py

@@ -1,3 +1,5 @@
+# ruff: noqa: ANN204
+
 class Hashable:
     def __hash__(self): ...
 

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/collections/_io_abc.py

@@ -1,3 +1,5 @@
+# ruff: noqa: ANN204
+
 class IOBase:
     def seek(self, pos, whence=0): ...
 
@@ -16,7 +18,7 @@ class IOBase:
     def writable(self): ...
 
     @property
-    def closed(self): ...
+    def closed(self): ...  # noqa
 
     def __enter__(self): ...
 
@@ -64,7 +66,7 @@ class TextIOBase(IOBase):
 
     def truncate(self, pos=None): ...
 
-    def readline(self): ...
+    def readline(self, size=-1): ...
 
     def detach(self): ...
 

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/collections/cache/__init__.py

@@ -8,4 +8,4 @@ from .impl import LRU  # noqa
 from .impl import new_cache  # noqa
 from .types import Cache  # noqa
 from .types import Eviction  # noqa
-from .types import OverweightException  # noqa
+from .types import OverweightError  # noqa

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/omlish/collections/cache/descriptor.py

@@ -26,7 +26,7 @@ class _HashedSeq(list):
 
     def __init__(
             self,
-            tup: ta.Tuple,
+            tup: tuple,
             hasher: ta.Callable[[ta.Any], int] = hash,
     ) -> None:
         super().__init__()
@@ -34,19 +34,19 @@ class _HashedSeq(list):
         self[:] = tup
         self.hash_value = hasher(tup)
 
-    def __hash__(self):
+    def __hash__(self) -> int:  # type: ignore
         return self.hash_value
 
 
 def _make_key(
-        args: ta.Tuple,
-        kwargs: ta.Dict[str, ta.Any],
+        args: tuple,
+        kwargs: dict[str, ta.Any],
         typed: bool,
         kwd_mark=(object(),),
         fasttypes=frozenset([int, str, frozenset, type(None)]),
-        tuple=tuple,
-        type=type,
-        len=len,
+        tuple=tuple,  # noqa
+        type=type,  # noqa
+        len=len,  # noqa
 ) -> ta.Any:
     key = args
     if kwargs:
@@ -109,7 +109,7 @@ class _CacheDescriptor:
     def _build(self, fn: ta.Callable, cache: Cache):
         def miss(key, result):
             if isinstance(result, Ignore):
-                return result._value
+                return result._value  # noqa
             else:
                 cache[key] = result
                 return result

{omlish-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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-0.0.0.dev2 → omlish-0.0.0.dev3}/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,