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

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/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()
 
@@ -97,7 +99,7 @@ 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
@@ -138,7 +140,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 +184,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/lang/__init__.py

@@ -1,112 +1,167 @@
-from .cached import cached_function  # noqa
-from .cached import cached_property  # noqa
-from .classes import Abstract # noqa
-from .classes import Callable  # noqa
-from .classes import Descriptor  # noqa
-from .classes import Final  # noqa
-from .classes import FinalException  # noqa
-from .classes import LazySingleton  # noqa
-from .classes import Marker  # noqa
-from .classes import Namespace  # noqa
-from .classes import NoBool  # noqa
-from .classes import NotInstantiable  # noqa
-from .classes import NotPicklable  # noqa
-from .classes import PackageSealed  # noqa
-from .classes import Picklable  # noqa
-from .classes import Sealed  # noqa
-from .classes import SealedException  # noqa
-from .classes import SimpleMetaDict  # noqa
-from .classes import Singleton  # noqa
-from .classes import Virtual  # noqa
-from .classes import is_abstract # noqa
-from .classes import is_abstract_class # noqa
-from .classes import is_abstract_method # noqa
-from .classes import make_abstract  # noqa
-from .classes import no_bool  # noqa
-from .classes import virtual_check  # noqa
-from .clsdct import ClassDctFn  # noqa
-from .clsdct import cls_dct_fn  # noqa
-from .clsdct import get_caller_cls_dct  # noqa
-from .clsdct import is_possibly_cls_dct  # noqa
-from .cmp import Infinity  # noqa
-from .cmp import InfinityType  # noqa
-from .cmp import NegativeInfinity  # noqa
-from .cmp import NegativeInfinityType  # noqa
-from .cmp import cmp  # noqa
-from .contextmanagers import ContextManaged  # noqa
-from .contextmanagers import ContextWrapped  # noqa
-from .contextmanagers import DefaultLockable  # noqa
-from .contextmanagers import ExitStacked  # noqa
-from .contextmanagers import Lockable  # noqa
-from .contextmanagers import NOP_CONTEXT_MANAGED  # noqa
-from .contextmanagers import NOP_CONTEXT_MANAGER  # noqa
-from .contextmanagers import NopContextManaged  # noqa
-from .contextmanagers import NopContextManager  # noqa
-from .contextmanagers import a_defer  # noqa
-from .contextmanagers import attr_setting  # noqa
-from .contextmanagers import breakpoint_on_exception  # noqa
-from .contextmanagers import context_var_setting  # noqa
-from .contextmanagers import context_wrapped  # noqa
-from .contextmanagers import default_lock  # noqa
-from .contextmanagers import defer  # noqa
-from .contextmanagers import disposing  # noqa
-from .contextmanagers import maybe_managing  # noqa
-from .datetimes import months_ago  # noqa
-from .datetimes import parse_date  # noqa
-from .datetimes import parse_timedelta  # noqa
-from .datetimes import to_seconds  # noqa
-from .descriptors import AccessForbiddenException  # noqa
-from .descriptors import access_forbidden  # noqa
-from .descriptors import is_method_descriptor  # noqa
-from .descriptors import unwrap_method_descriptors  # noqa
-from .functions import VoidException  # noqa
-from .functions import constant  # noqa
-from .functions import identity  # noqa
-from .functions import is_lambda  # noqa
-from .functions import is_none  # noqa
-from .functions import is_not_none  # noqa
-from .functions import maybe_call  # noqa
-from .functions import raise_  # noqa
-from .functions import recurse  # noqa
-from .functions import ticking_timeout  # noqa
-from .functions import try_  # noqa
-from .functions import unwrap_func  # noqa
-from .functions import unwrap_func_with_partials  # noqa
-from .functions import void  # noqa
-from .imports import import_all  # noqa
-from .imports import import_module  # noqa
-from .imports import import_module_attr  # noqa
-from .imports import lazy_import  # noqa
-from .imports import proxy_import  # noqa
-from .imports import try_import  # noqa
-from .imports import yield_import_all  # noqa
-from .imports import yield_importable  # noqa
-from .iterables import BUILTIN_SCALAR_ITERABLE_TYPES  # noqa
-from .iterables import asrange  # noqa
-from .iterables import exhaust  # noqa
-from .iterables import ilen  # noqa
-from .iterables import peek  # noqa
-from .iterables import prodrange  # noqa
-from .iterables import take  # noqa
-from .maybes import Maybe  # noqa
-from .maybes import empty  # noqa
-from .maybes import just  # noqa
-from .maybes import maybe  # noqa
-from .objects import SimpleProxy  # noqa
-from .objects import arg_repr  # noqa
-from .objects import attr_repr  # noqa
-from .objects import new_type  # noqa
-from .objects import super_meta  # noqa
-from .strings import camel_case  # noqa
-from .strings import indent_lines  # noqa
-from .strings import is_dunder  # noqa
-from .strings import is_ident  # noqa
-from .strings import is_ident_cont  # noqa
-from .strings import is_ident_start  # noqa
-from .strings import is_sunder  # noqa
-from .strings import prefix_lines  # noqa
-from .strings import snake_case  # noqa
-from .typing import BytesLike  # noqa
-from .typing import protocol_check  # noqa
-from .typing import typed_lambda  # noqa
-from .typing import typed_partial  # noqa
+from .cached import (  # noqa
+    cached_function,
+    cached_property,
+)
+
+from .classes import (  # noqa
+    Abstract,
+    Callable,
+    Descriptor,
+    Final,
+    FinalException,
+    LazySingleton,
+    Marker,
+    Namespace,
+    NoBool,
+    NotInstantiable,
+    NotPicklable,
+    PackageSealed,
+    Picklable,
+    Sealed,
+    SealedException,
+    SimpleMetaDict,
+    Singleton,
+    Virtual,
+    is_abstract,
+    is_abstract_class,
+    is_abstract_method,
+    make_abstract,
+    no_bool,
+    virtual_check,
+)
+
+from .clsdct import (  # noqa
+    ClassDctFn,
+    cls_dct_fn,
+    get_caller_cls_dct,
+    is_possibly_cls_dct,
+)
+
+from .cmp import (  # noqa
+    Infinity,
+    InfinityType,
+    NegativeInfinity,
+    NegativeInfinityType,
+    cmp,
+)
+
+from .contextmanagers import (  # noqa
+    ContextManaged,
+    ContextWrapped,
+    DefaultLockable,
+    ExitStacked,
+    Lockable,
+    NOP_CONTEXT_MANAGED,
+    NOP_CONTEXT_MANAGER,
+    NopContextManaged,
+    NopContextManager,
+    a_defer,
+    attr_setting,
+    breakpoint_on_exception,
+    context_var_setting,
+    context_wrapped,
+    default_lock,
+    defer,
+    disposing,
+    maybe_managing,
+)
+
+from .datetimes import (  # noqa
+    months_ago,
+    parse_date,
+    parse_timedelta,
+    to_seconds,
+)
+
+from .descriptors import (  # noqa
+    AccessForbiddenException,
+    access_forbidden,
+    classonly,
+    is_method_descriptor,
+    unwrap_method_descriptors,
+)
+
+from .exceptions import (  # noqa
+    Unreachable,
+)
+
+from .functions import (  # noqa
+    Args,
+    VoidException,
+    constant,
+    identity,
+    is_lambda,
+    is_none,
+    is_not_none,
+    maybe_call,
+    periodically,
+    raise_,
+    recurse,
+    try_,
+    unwrap_func,
+    unwrap_func_with_partials,
+    void,
+)
+
+from .imports import (  # noqa
+    import_all,
+    import_module,
+    import_module_attr,
+    lazy_import,
+    proxy_import,
+    try_import,
+    yield_import_all,
+    yield_importable,
+)
+
+from .iterables import (  # noqa
+    BUILTIN_SCALAR_ITERABLE_TYPES,
+    asrange,
+    exhaust,
+    ilen,
+    peek,
+    prodrange,
+    take,
+)
+
+from .maybes import (  # noqa
+    Maybe,
+    empty,
+    just,
+    maybe,
+)
+
+from .objects import (  # noqa
+    SimpleProxy,
+    arg_repr,
+    attr_repr,
+    new_type,
+    super_meta,
+)
+
+from .strings import (  # noqa
+    camel_case,
+    indent_lines,
+    is_dunder,
+    is_ident,
+    is_ident_cont,
+    is_ident_start,
+    is_sunder,
+    prefix_lines,
+    snake_case,
+)
+
+from .timeouts import (  # noqa
+    DeadlineTimeout,
+    InfiniteTimeout,
+    Timeout,
+    TimeoutLike,
+    timeout,
+)
+
+from .typing import (  # noqa
+    BytesLike,
+    protocol_check,
+    typed_lambda,
+    typed_partial,
+)

omlish/lang/cached.py

@@ -105,11 +105,11 @@ class _CachedFunction(ta.Generic[T]):
             opts: Opts = Opts(),
             keyer: ta.Callable[..., tuple] | None = None,
             values: ta.MutableMapping | None = None,
-            value_fn: ta.Optional[ta.Callable[P, T]] = None,
+            value_fn: ta.Callable[P, T] | None = None,
     ) -> None:
         super().__init__()
 
-        self._fn = fn
+        self._fn = (fn,)
         self._opts = opts
         self._keyer = keyer if keyer is not None else _make_cache_keyer(fn, simple=opts.simple_key)
 
@@ -118,6 +118,14 @@ class _CachedFunction(ta.Generic[T]):
         self._value_fn = value_fn if value_fn is not None else fn
         functools.update_wrapper(self, fn)
 
+    @property
+    def _fn(self):
+        return self.__fn
+
+    @_fn.setter
+    def _fn(self, x):
+        self.__fn = x
+
     def reset(self) -> None:
         self._values = {}
 
@@ -157,8 +165,8 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
             *,
             instance: ta.Any = None,
             owner: ta.Any = None,
-            name: ta.Optional[str] = None,
-            **kwargs
+            name: str | None = None,
+            **kwargs,
     ) -> None:
         super().__init__(fn, **kwargs)
 
@@ -173,7 +181,7 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
         if owner is self._owner and (instance is self._instance or scope is classmethod):
             return self
 
-        fn = self._fn
+        fn, = self._fn
         name = self._name
         bound_fn = fn.__get__(instance, owner)
         if self._bound_keyer is None:

omlish/lang/classes/__init__.py

@@ -1,24 +1,35 @@
-from .abstract import Abstract # noqa
-from .abstract import is_abstract # noqa
-from .abstract import is_abstract_class # noqa
-from .abstract import is_abstract_method # noqa
-from .abstract import make_abstract  # noqa
-from .restrict import Final  # noqa
-from .restrict import FinalException  # noqa
-from .restrict import NoBool  # noqa
-from .restrict import NotInstantiable  # noqa
-from .restrict import NotPicklable  # noqa
-from .restrict import PackageSealed  # noqa
-from .restrict import Sealed  # noqa
-from .restrict import SealedException  # noqa
-from .restrict import no_bool  # noqa
-from .simple import LazySingleton  # noqa
-from .simple import Marker  # noqa
-from .simple import Namespace  # noqa
-from .simple import SimpleMetaDict  # noqa
-from .simple import Singleton  # noqa
-from .virtual import Callable  # noqa
-from .virtual import Descriptor  # noqa
-from .virtual import Picklable  # noqa
-from .virtual import Virtual  # noqa
-from .virtual import virtual_check  # noqa
+from .abstract import (  # noqa
+    Abstract,
+    is_abstract,
+    is_abstract_class,
+    is_abstract_method,
+    make_abstract,
+)
+
+from .restrict import (  # noqa
+    Final,
+    FinalException,
+    NoBool,
+    NotInstantiable,
+    NotPicklable,
+    PackageSealed,
+    Sealed,
+    SealedException,
+    no_bool,
+)
+
+from .simple import (  # noqa
+    LazySingleton,
+    Marker,
+    Namespace,
+    SimpleMetaDict,
+    Singleton,
+)
+
+from .virtual import (  # noqa
+    Callable,
+    Descriptor,
+    Picklable,
+    Virtual,
+    virtual_check,
+)

omlish/lang/classes/abstract.py

@@ -48,7 +48,7 @@ class Abstract(abc.ABC):
             if ams:
                 raise TypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods'
-                    f'{", ".join(map(str, sorted(ams)))}'
+                    f'{", ".join(map(str, sorted(ams)))}',
                 )
 
 

omlish/lang/classes/simple.py

@@ -26,7 +26,7 @@ Namespace: type = _Namespace()  # type: ignore
 ##
 
 
-_MARKER_NAMESPACE_KEYS: ta.Optional[set[str]] = None
+_MARKER_NAMESPACE_KEYS: set[str] | None = None
 
 
 class _MarkerMeta(abc.ABCMeta):

omlish/lang/clsdct.py

@@ -37,7 +37,7 @@ def get_caller_cls_dct(offset: int = 0) -> ta.MutableMapping[str, ta.Any]:
 
 class ClassDctFn:
 
-    def __init__(self, fn: ta.Callable, offset: ta.Optional[int] = None, *, wrap=True) -> None:
+    def __init__(self, fn: ta.Callable, offset: int | None = None, *, wrap=True) -> None:
         super().__init__()
 
         self._fn = fn

omlish/lang/contextmanagers.py

@@ -19,10 +19,10 @@ class ContextManaged:
 
     def __exit__(
             self,
-            exc_type: ta.Optional[ta.Type[Exception]],
-            exc_val: ta.Optional[Exception],
-            exc_tb: ta.Optional[types.TracebackType]
-    ) -> ta.Optional[bool]:
+            exc_type: ta.Type[Exception] | None,
+            exc_val: Exception | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
         return None
 
 
@@ -51,7 +51,7 @@ NOP_CONTEXT_MANAGER = NopContextManager()
 
 
 @contextlib.contextmanager
-def defer(fn: ta.Callable) -> ta.Iterator[ta.Callable]:
+def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
     try:
         yield fn
     finally:
@@ -59,7 +59,7 @@ def defer(fn: ta.Callable) -> ta.Iterator[ta.Callable]:
 
 
 @contextlib.asynccontextmanager
-async def a_defer(fn: ta.Awaitable) -> ta.AsyncIterator[ta.Awaitable]:
+async def a_defer(fn: ta.Awaitable) -> ta.AsyncGenerator[ta.Awaitable, None]:
     try:
         yield fn
     finally:
@@ -146,10 +146,10 @@ class ExitStacked:
 
     def __exit__(
             self,
-            exc_type: ta.Optional[ta.Type[Exception]],
-            exc_val: ta.Optional[Exception],
-            exc_tb: ta.Optional[types.TracebackType]
-    ) -> ta.Optional[bool]:
+            exc_type: ta.Type[Exception] | None,
+            exc_val: Exception | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
         self._exit_stack.__exit__(exc_type, exc_val, exc_tb)
         try:
             superfn = super().__exit__  # type: ignore
@@ -162,20 +162,28 @@ class ExitStacked:
 ##
 
 
-ContextWrappable: ta.TypeAlias = ta.Union[ta.ContextManager, str, ta.Callable[..., ta.ContextManager]]
+ContextWrappable: ta.TypeAlias = ta.ContextManager | str | ta.Callable[..., ta.ContextManager]
 
 
 class ContextWrapped:
 
-    def __init__(self, fn: ta.Callable, cm: ta.Union[str, ContextWrappable]) -> None:
+    def __init__(self, fn: ta.Callable, cm: str | ContextWrappable) -> None:
         super().__init__()
 
-        self._fn = fn
+        self._fn = (fn,)
         self._cm = cm
         self._name: str | None = None
 
         functools.update_wrapper(self, fn)
 
+    @property
+    def _fn(self):
+        return self.__fn
+
+    @_fn.setter
+    def _fn(self, x):
+        self.__fn = x
+
     def __set_name__(self, owner, name):
         if name is not None:
             if self._name is not None:
@@ -187,7 +195,7 @@ class ContextWrapped:
     def __get__(self, instance, owner=None):
         if instance is None and owner is None:
             return self
-        fn = self._fn.__get__(instance, owner)  # noqa
+        fn = self._fn[0].__get__(instance, owner)  # noqa
         cm: ta.Any = self._cm
         if isinstance(self._cm, str):
             if instance is not None:
@@ -217,7 +225,7 @@ class ContextWrapped:
         if not hasattr(cm, '__enter__') and callable(cm):
             cm = cm(*args, **kwargs)
         with cm:  # type: ignore
-            return self._fn(*args, **kwargs)
+            return self._fn[0](*args, **kwargs)
 
 
 def context_wrapped(cm):  # ContextWrappable -> ta.Callable[[CallableT], CallableT]:

omlish/lang/datetimes.py

@@ -62,6 +62,6 @@ def parse_timedelta(s: str) -> datetime.timedelta:
         for k, v in match.groupdict().items()
         if k != 'negative' and v is not None}
     if not timedelta_kwargs:
-        raise ValueError()
+        raise ValueError
     sign = -1 if match.groupdict().get('negative') else 1
     return sign * datetime.timedelta(**timedelta_kwargs)

omlish/lang/descriptors.py

@@ -1,6 +1,10 @@
+import functools
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
+
 ##
 
 
@@ -26,14 +30,14 @@ def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
 
 class AccessForbiddenException(Exception):
 
-    def __init__(self, name: ta.Optional[str] = None, *args: ta.Any, **kwargs: ta.Any) -> None:
+    def __init__(self, name: str | None = None, *args: ta.Any, **kwargs: ta.Any) -> None:
         super().__init__(*((name,) if name is not None else ()), *args, **kwargs)  # noqa
         self.name = name
 
 
 class AccessForbiddenDescriptor:
 
-    def __init__(self, name: ta.Optional[str] = None) -> None:
+    def __init__(self, name: str | None = None) -> None:
         super().__init__()
 
         self._name = name
@@ -50,3 +54,32 @@ class AccessForbiddenDescriptor:
 
 def access_forbidden():
     return AccessForbiddenDescriptor()
+
+
+##
+
+
+class _ClassOnly:
+    def __init__(self, mth):
+        if not isinstance(mth, classmethod):
+            raise TypeError(f'must be classmethod: {mth}')
+        super().__init__()
+        self._mth = (mth,)
+        functools.update_wrapper(self, mth)  # type: ignore
+
+    @property
+    def _mth(self):
+        return self.__mth
+
+    @_mth.setter
+    def _mth(self, x):
+        self.__mth = x
+
+    def __get__(self, instance, owner):
+        if instance is not None:
+            raise TypeError(f'method must not be used on instance: {self._mth}')
+        return self._mth[0].__get__(instance, owner)
+
+
+def classonly(obj: T) -> T:  # noqa
+    return _ClassOnly(obj)  # type: ignore

omlish/lang/exceptions.py

@@ -0,0 +1,2 @@
+class Unreachable(Exception):
+    pass