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

omlish/__about__.py

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

omlish/argparse.py

@@ -48,7 +48,7 @@ ArgumentParser = argparse.ArgumentParser
 class Arg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
-    dest: ta.Optional[str] = None
+    dest: str | None = None
 
     def __get__(self, instance, owner=None):
         if instance is None:
@@ -92,8 +92,8 @@ class Command:
 
 def command(
         *args: Arg,
-        name: ta.Optional[str] = None,
-        parent: ta.Optional[Command] = None,
+        name: str | None = None,
+        parent: Command | None = None,
 ) -> ta.Any:  # ta.Callable[[CommandFn], Command]:  # FIXME
     for arg in args:
         check.isinstance(arg, Arg)
@@ -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:
@@ -192,7 +192,7 @@ class _CliMeta(type):
 
 class Cli(metaclass=_CliMeta):
 
-    def __init__(self, argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+    def __init__(self, argv: ta.Sequence[str] | None = None) -> None:
         super().__init__()
 
         self._argv = argv if argv is not None else sys.argv[1:]

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/asyncs/anyio.py

@@ -7,10 +7,15 @@ lookit:
  - https://github.com/M-o-a-T/asyncscope
  - https://github.com/M-o-a-T/aevent
  - https://github.com/florimondmanca/aiometer
+ - https://github.com/sanitizers/octomachinery/blob/b36c3d3d49da813ac46e361424132955a4e99ac8/octomachinery/utils/asynctools.py
 """  # noqa
 import typing as ta
 
-import anyio
+import anyio.streams.memory
+import anyio.streams.stapled
+
+from .. import check
+from .. import lang
 
 
 T = ta.TypeVar('T')
@@ -21,3 +26,61 @@ async def anyio_eof_to_empty(fn: ta.Callable[..., ta.Awaitable[T]], *args: ta.An
         return await fn(*args, **kwargs)
     except anyio.EndOfStream:
         return b''
+
+
+def split_memory_object_streams(
+        *args: anyio.create_memory_object_stream[T],
+) -> tuple[
+    anyio.streams.memory.MemoryObjectSendStream[T],
+    anyio.streams.memory.MemoryObjectReceiveStream[T],
+]:
+    [tup] = args
+    return tup
+
+
+# FIXME: https://github.com/python/mypy/issues/15238
+# 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(
+        *args: anyio.create_memory_object_stream[T],
+) -> anyio.streams.stapled.StapledObjectStream[T]:
+    send, receive = args
+    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://github.com/python/mypy/issues/15238
+# 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]]:
+    results: list[lang.Maybe[T]] = [lang.empty()] * len(fns)
+
+    async def inner(fn, i):
+        results[i] = lang.just(await fn())
+        if take_first:
+            tg.cancel_scope.cancel()
+
+    async with anyio.create_task_group() as tg:
+        for i, fn in enumerate(fns):
+            tg.start_soon(inner, fn, i)
+
+    return results
+
+
+async def first(*fns: ta.Callable[..., ta.Awaitable[T]], **kwargs: ta.Any) -> list[lang.Maybe[T]]:
+    return await gather(*fns, take_first=True, **kwargs)

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/asyncs/futures.py

@@ -5,14 +5,15 @@ 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: ta.Optional[T] = None) -> None:
+    def __init__(self, future: cf.Future, target: T | None = None) -> None:
         super().__init__()
 
         self._future = future
@@ -23,7 +24,7 @@ class FutureException(Exception, ta.Generic[T]):
         return self._future
 
     @property
-    def target(self) -> ta.Optional[T]:
+    def target(self) -> T | None:
         return self._target
 
     def __repr__(self) -> str:
@@ -37,15 +38,15 @@ class FutureException(Exception, ta.Generic[T]):
     __str__ = __repr__
 
 
-class FutureTimeoutException(Exception):
+class FutureTimeoutError(Exception):
     pass
 
 
 def wait_futures(
         futures: ta.Sequence[cf.Future],
         *,
-        timeout_s: ta.Union[int, float] = 60,
-        tick_interval_s: ta.Union[int, float] = 0.5,
+        timeout_s: float = 60,
+        tick_interval_s: float = .5,
         tick_fn: ta.Callable[..., bool] = lambda: True,
         raise_exceptions: bool = False,
         cancel_on_exception: bool = False,
@@ -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
@@ -78,8 +79,8 @@ def wait_dependent_futures(
         executor: cf.Executor,
         dependency_sets_by_fn: ta.Mapping[ta.Callable, ta.AbstractSet[ta.Callable]],
         *,
-        timeout_s: ta.Union[int, float] = 60,
-        tick_interval_s: ta.Union[int, float] = 0.5,
+        timeout_s: float = 60,
+        tick_interval_s: float = .5,
         tick_fn: ta.Callable[..., bool] = lambda: True,
 ) -> ta.Mapping[ta.Callable, cf.Future]:
     for fn, deps in dependency_sets_by_fn.items():
@@ -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/c3.py

@@ -49,7 +49,7 @@ def merge(seqs: ta.MutableSequence[list[T]]) -> list[T]:
     """
 
     result: list[T] = []
-    candidate: ta.Optional[T] = None
+    candidate: T | None = None
     while True:
         seqs = [s for s in seqs if s]  # purge empty sequences
         if not seqs:
@@ -73,7 +73,7 @@ def merge(seqs: ta.MutableSequence[list[T]]) -> list[T]:
 
 def mro(
         cls: T,
-        abcs: ta.Optional[ta.Sequence[T]] = None,
+        abcs: ta.Sequence[T] | None = None,
         *,
         get_bases: ta.Callable[[T], ta.Sequence[T]] = operator.attrgetter('__bases__'),
         is_subclass: ta.Callable[[T, T], bool] = issubclass,  # type: ignore
@@ -113,9 +113,9 @@ 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]
+        [explicit_bases] + [abstract_bases] + [other_bases],
     )
 
 
@@ -123,7 +123,7 @@ def compose_mro(
         cls: T,
         types: ta.Iterable[T],
         *,
-        get_mro: ta.Callable[[T], ta.Optional[ta.Sequence[T]]] = operator.attrgetter('__mro__'),
+        get_mro: ta.Callable[[T], ta.Sequence[T] | None] = operator.attrgetter('__mro__'),
         get_bases: ta.Callable[[T], ta.Sequence[T]] = operator.attrgetter('__bases__'),
         is_subclass: ta.Callable[[T, T], bool] = issubclass,  # type: ignore
         get_subclasses: ta.Callable[[T], ta.Iterable[T]] = operator.methodcaller('__subclasses__'),

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[..., ta.Optional[str]], None]
+Message = str | ta.Callable[..., str | None] | None
 
 _NONE_TYPE = type(None)
 
@@ -33,7 +33,7 @@ def _raise(
         default_message: str,
         message: Message,
         *args: ta.Any,
-        **kwargs: ta.Any
+        **kwargs: ta.Any,
 ) -> ta.NoReturn:
     if _callable(message):
         message = ta.cast(ta.Callable, message)(*args, **kwargs)
@@ -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
@@ -64,7 +64,7 @@ def isinstance(v: ta.Any, spec: ta.Union[type[T], tuple], msg: Message = None) -
     return v
 
 
-def of_isinstance(spec: ta.Union[type[T], tuple], msg: Message = None) -> ta.Callable[[ta.Any], T]:
+def of_isinstance(spec: type[T] | tuple, msg: Message = None) -> ta.Callable[[ta.Any], T]:
     def inner(v):
         return isinstance(v, _unpack_isinstance_spec(spec), msg)
 
@@ -155,7 +155,7 @@ def single(obj: ta.Iterable[T], message: Message = None) -> T:
         return value
 
 
-def optional_single(obj: ta.Iterable[T], message: Message = None) -> ta.Optional[T]:
+def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
     it = iter(obj)
     try:
         value = next(it)
@@ -176,7 +176,7 @@ def none(v: ta.Any, msg: Message = None) -> None:
         _raise(ValueError, 'Must be None', msg, v)
 
 
-def not_none(v: ta.Optional[T], msg: Message = None) -> T:
+def not_none(v: T | None, msg: Message = None) -> T:
     if v is None:
         _raise(ValueError, 'Must not be None', msg, v)
     return v
@@ -206,13 +206,13 @@ 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
 
 
-def non_empty_str(v: ta.Optional[str], msg: Message = None) -> str:
+def non_empty_str(v: str | None, msg: Message = None) -> str:
     if not _isinstance(v, str) or not v:
         _raise(ValueError, 'Must be non-empty str', msg, v)
     return v

omlish/collections/__init__.py

@@ -1,63 +1,98 @@
-from .coerce import abs_set  # noqa
-from .coerce import abs_set_of  # noqa
-from .coerce import abs_set_of_or_none  # noqa
-from .coerce import abs_set_or_none  # noqa
-from .coerce import frozenset_  # noqa
-from .coerce import frozenset_of  # noqa
-from .coerce import frozenset_of_or_none  # noqa
-from .coerce import frozenset_or_none  # noqa
-from .coerce import map  # noqa
-from .coerce import map_of  # noqa
-from .coerce import map_of_or_none  # noqa
-from .coerce import map_or_none  # noqa
-from .coerce import opt_abs_set  # noqa
-from .coerce import opt_abs_set_of  # noqa
-from .coerce import opt_frozenset  # noqa
-from .coerce import opt_frozenset_of  # noqa
-from .coerce import opt_map  # noqa
-from .coerce import opt_map_of  # noqa
-from .coerce import opt_seq  # noqa
-from .coerce import opt_seq_of  # noqa
-from .coerce import seq  # noqa
-from .coerce import seq_of  # noqa
-from .coerce import seq_of_or_none  # noqa
-from .coerce import seq_or_none  # noqa
-from .frozen import Frozen  # noqa
-from .frozen import FrozenDict  # noqa
-from .frozen import FrozenList  # noqa
-from .frozen import frozendict  # noqa
-from .frozen import frozenlist  # noqa
-from .identity import IdentityKeyDict  # noqa
-from .identity import IdentitySet  # noqa
-from .identity import IdentityWrapper  # noqa
-from .indexed import IndexedSeq  # noqa
-from .indexed import IndexedSetSeq  # noqa
-from .mappings import MissingDict  # noqa
-from .mappings import TypeMap  # noqa
-from .mappings import TypeMultiMap  # noqa
-from .mappings import guarded_map_update  # noqa
-from .mappings import multikey_dict  # noqa
-from .mappings import yield_dict_init  # noqa
-from .ordered import OrderedFrozenSet  # noqa
-from .ordered import OrderedSet  # noqa
-from .persistent import PersistentMap  # noqa
-from .skiplist import SkipList  # noqa
-from .skiplist import SkipListDict  # noqa
-from .sorted import SortedCollection  # noqa
-from .sorted import SortedListDict  # noqa
-from .sorted import SortedMapping  # noqa
-from .sorted import SortedMutableMapping  # noqa
-from .treapmap import new_treap_map  # noqa
-from .unmodifiable import Unmodifiable  # noqa
-from .unmodifiable import UnmodifiableMapping  # noqa
-from .unmodifiable import UnmodifiableSequence  # noqa
-from .unmodifiable import UnmodifiableSet  # noqa
-from .utils import all_equal  # noqa
-from .utils import all_not_equal  # noqa
-from .utils import indexes  # noqa
-from .utils import key_cmp  # noqa
-from .utils import mut_toposort  # noqa
-from .utils import partition  # noqa
-from .utils import toposort  # noqa
-from .utils import unique  # noqa
-from .utils import unique_dict  # noqa
+from .coerce import (  # noqa
+    abs_set,
+    abs_set_of,
+    abs_set_of_or_none,
+    abs_set_or_none,
+    frozenset_,
+    frozenset_of,
+    frozenset_of_or_none,
+    frozenset_or_none,
+    map,
+    map_of,
+    map_of_or_none,
+    map_or_none,
+    opt_abs_set,
+    opt_abs_set_of,
+    opt_frozenset,
+    opt_frozenset_of,
+    opt_map,
+    opt_map_of,
+    opt_seq,
+    opt_seq_of,
+    seq,
+    seq_of,
+    seq_of_or_none,
+    seq_or_none,
+)
+
+from .frozen import (  # noqa
+    Frozen,
+    FrozenDict,
+    FrozenList,
+    frozendict,
+    frozenlist,
+)
+
+from .identity import (  # noqa
+    IdentityKeyDict,
+    IdentitySet,
+    IdentityWrapper,
+)
+
+from .indexed import (  # noqa
+    IndexedSeq,
+    IndexedSetSeq,
+)
+
+from .mappings import (  # noqa
+    MissingDict,
+    TypeMap,
+    TypeMultiMap,
+    guarded_map_update,
+    multikey_dict,
+    yield_dict_init,
+)
+
+from .ordered import (  # noqa
+    OrderedFrozenSet,
+    OrderedSet,
+)
+
+from .persistent import (  # noqa
+    PersistentMap,
+)
+
+from .skiplist import (  # noqa
+    SkipList,
+    SkipListDict,
+)
+
+from .sorted import (  # noqa
+    SortedCollection,
+    SortedListDict,
+    SortedMapping,
+    SortedMutableMapping,
+)
+
+from .treapmap import (  # noqa
+    new_treap_map,
+)
+
+from .unmodifiable import (  # noqa
+    Unmodifiable,
+    UnmodifiableMapping,
+    UnmodifiableSequence,
+    UnmodifiableSet,
+)
+
+from .utils import (  # noqa
+    all_equal,
+    all_not_equal,
+    indexes,
+    key_cmp,
+    mut_toposort,
+    partition,
+    toposort,
+    unique,
+    unique_dict,
+)

omlish/collections/_abc.py

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

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/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/collections/cache/descriptor.py

@@ -26,27 +26,27 @@ class _HashedSeq(list):
 
     def __init__(
             self,
-            tup: ta.Tuple,
-            hasher: ta.Callable[[ta.Any], int] = hash
+            tup: tuple,
+            hasher: ta.Callable[[ta.Any], int] = hash,
     ) -> None:
         super().__init__()
 
         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:
@@ -81,7 +81,7 @@ class _CacheDescriptor:
             fn: ta.Callable,
             scope: Scope,
             typed: bool,
-            **kwargs: ta.Any
+            **kwargs: ta.Any,
     ) -> None:
         super().__init__()
 
@@ -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
@@ -175,9 +175,9 @@ class _CacheDescriptor:
 
 
 def cache(
-        scope: ta.Union[Scope, str] = Scope.INSTANCE,
+        scope: Scope | str = Scope.INSTANCE,
         typed: bool = False,
-        **kwargs
+        **kwargs,
 ) -> CC:
     if not isinstance(scope, Scope):
         scope = getattr(Scope, scope.upper())  # noqa