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

omlish/__about__.py

@@ -2,6 +2,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.dev2'

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)
@@ -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/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,59 @@ 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
+# 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)
+
+
+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
+# 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/futures.py

@@ -12,7 +12,7 @@ T = ta.TypeVar('T')
 
 class FutureException(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 +23,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:
@@ -44,8 +44,8 @@ class FutureTimeoutException(Exception):
 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,
@@ -78,8 +78,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():

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
@@ -115,7 +115,7 @@ def mro(
     return merge(
         [[cls]] +
         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 = ta.Union[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)
@@ -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
@@ -212,7 +212,7 @@ def callable(v: T, msg: Message = None) -> T:
     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/cache/descriptor.py

@@ -27,7 +27,7 @@ class _HashedSeq(list):
     def __init__(
             self,
             tup: ta.Tuple,
-            hasher: ta.Callable[[ta.Any], int] = hash
+            hasher: ta.Callable[[ta.Any], int] = hash,
     ) -> None:
         super().__init__()
 
@@ -46,7 +46,7 @@ def _make_key(
         fasttypes=frozenset([int, str, frozenset, type(None)]),
         tuple=tuple,
         type=type,
-        len=len
+        len=len,
 ) -> 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__()
 
@@ -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

omlish/collections/cache/impl.py

@@ -82,8 +82,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
@@ -120,7 +120,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 +165,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: ta.Deque[CacheImpl.Link] | None
         if weak_keys or weak_values:
             weak_dead = collections.deque()
             weak_dead_ref = weakref.ref(weak_dead)