omlish 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

omlish/inject/elements.py

@@ -25,9 +25,9 @@ class Elements(lang.Final):
                 yield from c
 
 
-def as_elements(*args: ta.Union[Element, Elements]) -> Elements:
+def as_elements(*args: Element | Elements) -> Elements:
     es: set[Element] = set()
-    cs: set['Elements'] = set()
+    cs: set[Elements] = set()
     for a in args:
         if isinstance(a, Element):
             es.add(a)

omlish/inject/exceptions.py

@@ -9,25 +9,25 @@ from .types import Scope
 
 
 @dc.dataclass()
-class KeyException(Exception):
+class BaseKeyError(Exception):
     key: Key
 
     source: ta.Any = None
-    name: ta.Optional[str] = None
+    name: str | None = None
 
 
 @dc.dataclass()
-class UnboundKeyException(KeyException):
+class UnboundKeyError(KeyError):
     pass
 
 
 @dc.dataclass()
-class DuplicateKeyException(KeyException):
+class DuplicateKeyError(KeyError):
     pass
 
 
 @dc.dataclass()
-class CyclicDependencyException(KeyException):
+class CyclicDependencyError(KeyError):
     pass
 
 
@@ -35,15 +35,15 @@ class CyclicDependencyException(KeyException):
 
 
 @dc.dataclass()
-class ScopeException(Exception):
+class ScopeError(Exception):
     scope: Scope
 
 
 @dc.dataclass()
-class ScopeAlreadyOpenException(ScopeException):
+class ScopeAlreadyOpenError(ScopeError):
     pass
 
 
 @dc.dataclass()
-class ScopeNotOpenException(ScopeException):
+class ScopeNotOpenError(ScopeError):
     pass

omlish/inject/impl/elements.py

@@ -25,7 +25,7 @@ from ..bindings import Binding
 from ..eagers import Eager
 from ..elements import Element
 from ..elements import Elements
-from ..exceptions import DuplicateKeyException
+from ..exceptions import DuplicateKeyError
 from ..keys import Key
 from ..overrides import Overrides
 from ..private import Expose
@@ -51,7 +51,7 @@ class ElementCollection(lang.Final):
 
         self._es = check.isinstance(es, Elements)
 
-        self._private_infos: ta.MutableMapping[Private, 'private_.PrivateInfo'] | None = None
+        self._private_infos: ta.MutableMapping[Private, private_.PrivateInfo] | None = None
 
     ##
 
@@ -98,7 +98,7 @@ class ElementCollection(lang.Final):
                     try:
                         bs = ovr[k]
                     except KeyError:
-                        bs = src[k]
+                        bs = b
                     add(k, *bs)
 
             else:
@@ -139,7 +139,7 @@ class ElementCollection(lang.Final):
                 mm.setdefault(k, []).extend(bis)
             else:
                 if len(bis) > 1:
-                    raise DuplicateKeyException(k)
+                    raise DuplicateKeyError(k)
                 [pm[k]] = bis
 
         if mm:

omlish/inject/impl/injector.py

@@ -16,8 +16,8 @@ from ... import check
 from ... import lang
 from ..eagers import Eager
 from ..elements import Elements
-from ..exceptions import CyclicDependencyException
-from ..exceptions import UnboundKeyException
+from ..exceptions import CyclicDependencyError
+from ..exceptions import UnboundKeyError
 from ..injector import Injector
 from ..inspect import KwargsTarget
 from ..keys import Key
@@ -45,7 +45,7 @@ class InjectorImpl(Injector, lang.Final):
         super().__init__()
 
         self._ec = check.isinstance(ec, ElementCollection)
-        self._p: ta.Optional[InjectorImpl] = check.isinstance(p, (InjectorImpl, None))
+        self._p: InjectorImpl | None = check.isinstance(p, (InjectorImpl, None))
 
         self._internal_consts: dict[Key, ta.Any] = {
             Key(Injector): self,
@@ -54,7 +54,7 @@ class InjectorImpl(Injector, lang.Final):
         self._bim = ec.binding_impl_map()
 
         self._cs: weakref.WeakSet[InjectorImpl] | None = None
-        self._root: InjectorImpl = p._root if p is not None else self
+        self._root: InjectorImpl = p._root if p is not None else self  # noqa
 
         self.__cur_req: InjectorImpl._Request | None = None
 
@@ -97,7 +97,7 @@ class InjectorImpl(Injector, lang.Final):
             except KeyError:
                 pass
             if key in self._seen_keys:
-                raise CyclicDependencyException(key)
+                raise CyclicDependencyError(key)
             self._seen_keys.add(key)
             return lang.empty()
 
@@ -154,7 +154,7 @@ class InjectorImpl(Injector, lang.Final):
         v = self.try_provide(key)
         if v.present:
             return v.must()
-        raise UnboundKeyException(key)
+        raise UnboundKeyError(key)
 
     def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
         ret: dict[str, ta.Any] = {}

omlish/inject/impl/inspect.py

@@ -11,7 +11,7 @@ import typing as ta
 import weakref
 
 from ... import reflect as rfl
-from ..exceptions import DuplicateKeyException
+from ..exceptions import DuplicateKeyError
 from ..inspect import Kwarg
 from ..inspect import KwargsTarget
 from ..keys import Key
@@ -52,7 +52,7 @@ def build_kwargs_target(
         obj: ta.Any,
         *,
         skip_args: int = 0,
-        skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+        skip_kwargs: ta.Iterable[ta.Any] | None = None,
         raw_optional: bool = False,
 ) -> KwargsTarget:
     sig = signature(obj)
@@ -83,7 +83,7 @@ def build_kwargs_target(
             k = tag(k, pt)
 
         if k in seen:
-            raise DuplicateKeyException(k)
+            raise DuplicateKeyError(k)
         seen.add(k)
 
         kws.append(Kwarg(

omlish/inject/impl/scopes.py

@@ -9,8 +9,8 @@ from ... import lang
 from ..bindings import Binding
 from ..elements import Elements
 from ..elements import as_elements
-from ..exceptions import ScopeAlreadyOpenException
-from ..exceptions import ScopeNotOpenException
+from ..exceptions import ScopeAlreadyOpenError
+from ..exceptions import ScopeNotOpenError
 from ..injector import Injector
 from ..keys import Key
 from ..providers import Provider
@@ -134,7 +134,7 @@ class SeededScopeImpl(ScopeImpl):
 
     def must_state(self) -> 'SeededScopeImpl.State':
         if (st := self._st) is None:
-            raise ScopeNotOpenException(self._ss)
+            raise ScopeNotOpenError(self._ss)
         return st
 
     class Manager(SeededScope.Manager, lang.Final):
@@ -147,14 +147,14 @@ class SeededScopeImpl(ScopeImpl):
         @contextlib.contextmanager
         def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.Generator[None, None, None]:
             try:
-                if self._ssi._st is not None:
-                    raise ScopeAlreadyOpenException(self._ss)
-                self._ssi._st = SeededScopeImpl.State(dict(seeds))
+                if self._ssi._st is not None:  # noqa
+                    raise ScopeAlreadyOpenError(self._ss)
+                self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
                 yield
             finally:
-                if self._ssi._st is None:
-                    raise ScopeNotOpenException(self._ss)
-                self._ssi._st = None
+                if self._ssi._st is None:  # noqa
+                    raise ScopeNotOpenError(self._ss)
+                self._ssi._st = None  # noqa
 
     def auto_elements(self) -> Elements:
         return as_elements(

omlish/inject/injector.py

@@ -31,7 +31,7 @@ class Injector(lang.Abstract):
 
     def __getitem__(
             self,
-            target: ta.Union[Key[T], type[T]],
+            target: Key[T] | type[T],
     ) -> T:
         return self.provide(target)
 

omlish/inject/providers.py

@@ -53,7 +53,7 @@ class FnProvider(Provider):
         return self.cls
 
 
-def fn(fn: ta.Any, cls: ta.Optional[Cls] = _Missing) -> Provider:
+def fn(fn: ta.Any, cls: Cls | None = _Missing) -> Provider:
     check.not_isinstance(fn, type)
     check.callable(fn)
     if cls is _Missing:
@@ -90,7 +90,7 @@ class ConstProvider(Provider):
         return self.cls
 
 
-def const(v: ta.Any, cls: ta.Optional[Cls] = _Missing) -> Provider:
+def const(v: ta.Any, cls: Cls | None = _Missing) -> Provider:
     if cls is _Missing:
         cls = type(v)
     return ConstProvider(v, cls)

omlish/inject/proxy.py

@@ -22,7 +22,7 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
         def __init__(self, cls):
             super().__init__(_CyclicDependencyPlaceholder(cls))
             if isinstance(cls, type):
-                self._self__class__ = cls
+                self._self__class__ = cls  # noqa
 
         def __repr__(self) -> str:
             return f'_CyclicDependencyProxy({self.__wrapped__!r})'
@@ -35,14 +35,14 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
                     pass
             return object.__getattribute__(self, att)  # noqa
 
-    def set(prox, obj):
+    def set_obj(prox, obj):
         check.state(type(prox) is _CyclicDependencyProxy)
         check.not_isinstance(obj, _CyclicDependencyPlaceholder)
         check.isinstance(prox.__wrapped__, _CyclicDependencyPlaceholder)
         if hasattr(prox, '_self__class__'):
-            check.issubclass(type(obj), prox._self__class__)
+            check.issubclass(type(obj), prox._self__class__)  # noqa
         prox.__wrapped__ = obj
         if hasattr(prox, '_self__class__'):
-            del prox._self__class__
+            del prox._self__class__  # noqa
 
-    return (_CyclicDependencyProxy, set)  # noqa
+    return (_CyclicDependencyProxy, set_obj)  # noqa

omlish/iterators.py

@@ -1,10 +1,12 @@
 import collections
 import functools
+import heapq
 import itertools
 import typing as ta
 
 
 T = ta.TypeVar('T')
+U = ta.TypeVar('U')
 
 _MISSING = object()
 
@@ -20,66 +22,61 @@ class PeekIterator(ta.Iterator[T]):
 
     _item: T
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     @property
     def done(self) -> bool:
         try:
             self.peek()
-            return False
         except StopIteration:
             return True
+        else:
+            return False
 
     def __next__(self) -> T:
         if self._next_item is not _MISSING:
             self._item = ta.cast(T, self._next_item)
             self._next_item = _MISSING
         else:
-            try:
-                self._item = next(self._it)
-            except StopIteration:
-                raise
+            self._item = next(self._it)
         self._pos += 1
         return self._item
 
     def peek(self) -> T:
         if self._next_item is not _MISSING:
             return ta.cast(T, self._next_item)
-        try:
-            self._next_item = next(self._it)
-        except StopIteration:
-            raise
+        self._next_item = next(self._it)
         return self._next_item
 
     def next_peek(self) -> T:
         next(self)
         return self.peek()
 
-    def takewhile(self, fn):
+    def takewhile(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
         while fn(self.peek()):
             yield next(self)
 
-    def skipwhile(self, fn):
+    def skipwhile(self, fn: ta.Callable[[T], bool]) -> None:
         while fn(self.peek()):
             next(self)
 
-    def takeuntil(self, fn):
+    def takeuntil(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
         return self.takewhile(lambda e: not fn(e))
 
-    def skipuntil(self, fn):
+    def skipuntil(self, fn: ta.Callable[[T], bool]) -> None:
         self.skipwhile(lambda e: not fn(e))
 
-    def takethrough(self, pos):
+    def takethrough(self, pos: int) -> ta.Iterator[T]:
         return self.takewhile(lambda _: self._pos < pos)
 
-    def skipthrough(self, pos):
+    def skipthrough(self, pos: int) -> None:
         self.skipwhile(lambda _: self._pos < pos)
 
-    def taketo(self, pos):
+    def taketo(self, pos: int) -> ta.Iterator[T]:
         return self.takethrough(pos - 1)
 
-    def skipto(self, pos):
+    def skipto(self, pos: int) -> None:
         self.skipthrough(pos - 1)
 
 
@@ -88,7 +85,7 @@ class ProxyIterator(ta.Iterator[T]):
     def __init__(self, fn: ta.Callable[[], T]) -> None:
         self._fn = fn
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def __next__(self) -> T:
@@ -97,13 +94,13 @@ class ProxyIterator(ta.Iterator[T]):
 
 class PrefetchIterator(ta.Iterator[T]):
 
-    def __init__(self, fn: ta.Optional[ta.Callable[[], T]] = None) -> None:
+    def __init__(self, fn: ta.Callable[[], T] | None = None) -> None:
         super().__init__()
 
         self._fn = fn
-        self._deque: ta.Deque[T] = collections.deque()
+        self._deque: collections.deque[T] = collections.deque()
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def push(self, item) -> None:
@@ -114,7 +111,7 @@ class PrefetchIterator(ta.Iterator[T]):
             return self._deque.popleft()
         except IndexError:
             if self._fn is None:
-                raise StopIteration
+                raise StopIteration from None
         return self._fn()
 
 
@@ -124,9 +121,9 @@ class RetainIterator(ta.Iterator[T]):
         super().__init__()
 
         self._fn = fn
-        self._deque: ta.Deque[T] = collections.deque()
+        self._deque: collections.deque[T] = collections.deque()
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def pop(self) -> None:
@@ -138,7 +135,7 @@ class RetainIterator(ta.Iterator[T]):
         return item
 
 
-def unzip(it: ta.Iterable[T], width: ta.Optional[int] = None) -> list:
+def unzip(it: ta.Iterable[T], width: int | None = None) -> list:
     if width is None:
         if not isinstance(it, PeekIterator):
             it = PeekIterator(iter(it))
@@ -182,3 +179,42 @@ def chunk(n: int, iterable: ta.Iterable[T], strict: bool = False) -> ta.Iterator
         return iter(ret())
     else:
         return iterator
+
+
+def merge_on(
+        function: ta.Callable[[T], U],
+        *its: ta.Iterable[T],
+) -> ta.Iterator[tuple[U, list[tuple[int, T]]]]:
+    indexed_its = [
+        (
+            (function(item), it_idx, item)
+            for it_idx, item in zip(itertools.repeat(it_idx), it)
+        )
+        for it_idx, it in enumerate(its)
+    ]
+
+    grouped_indexed_its = itertools.groupby(
+        heapq.merge(*indexed_its),
+        key=lambda item_tuple: item_tuple[0],
+    )
+
+    return (
+        (fn_item, [(it_idx, item) for _, it_idx, item in grp])
+        for fn_item, grp in grouped_indexed_its
+    )
+
+
+def expand_indexed_pairs(
+        seq: ta.Iterable[tuple[int, T]],
+        default: T,
+        *,
+        width: int | None = None,
+) -> list[T]:
+    width_ = width
+    if width_ is None:
+        width_ = (max(idx for idx, _ in seq) + 1) if seq else 0
+    result = [default] * width_
+    for idx, value in seq:
+        if idx < width_:
+            result[idx] = value
+    return result

omlish/json.py

@@ -1,5 +1,6 @@
 import functools
 import json as _json
+import typing as ta
 
 
 dump = _json.dump
@@ -15,25 +16,25 @@ loads = _json.loads
 
 PRETTY_INDENT = 2
 
-PRETTY_KWARGS = dict(
+PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=PRETTY_INDENT,
 )
 
-dump_pretty = functools.partial(dump, **PRETTY_KWARGS)
-dumps_pretty = functools.partial(dumps, **PRETTY_KWARGS)
+dump_pretty: ta.Callable[..., bytes] = functools.partial(dump, **PRETTY_KWARGS)  # type: ignore
+dumps_pretty: ta.Callable[..., str] = functools.partial(dumps, **PRETTY_KWARGS)
 
 ##
 
 
 COMPACT_SEPARATORS = (',', ':')
 
-COMPACT_KWARGS = dict(
+COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=0,
     separators=COMPACT_SEPARATORS,
 )
 
-dump_compact = functools.partial(dump, **COMPACT_KWARGS)
-dumps_compact = functools.partial(dumps, **COMPACT_KWARGS)
+dump_compact: ta.Callable[..., bytes] = functools.partial(dump, **COMPACT_KWARGS)  # type: ignore
+dumps_compact: ta.Callable[..., str] = functools.partial(dumps, **COMPACT_KWARGS)
 
 
 ##