omlish 0.0.0.dev0__tar.gz → 0.0.0.dev2__tar.gz

omlish-0.0.0.dev2/MANIFEST.in

@@ -0,0 +1 @@
+global-exclude **/conftest.py

omlish-0.0.0.dev2/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.1
+Name: omlish
+Version: 0.0.0.dev2
+Summary: omlish
+Author: wrmsr
+License: BSD-3-Clause
+Project-URL: source, https://github.com/wrmsr/omlish
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+License-File: LICENSE
+Provides-Extra: async
+Requires-Dist: anyio; extra == "async"
+Provides-Extra: http
+Requires-Dist: httpx; extra == "http"
+Provides-Extra: sql
+Requires-Dist: sqlalchemy; extra == "sql"
+Provides-Extra: wrapt
+Requires-Dist: wrapt; extra == "wrapt"
+Provides-Extra: yaml
+Requires-Dist: pyyaml; extra == "yaml"
+Provides-Extra: server
+Requires-Dist: h11; extra == "server"
+Requires-Dist: h2; extra == "server"
+Requires-Dist: priority; extra == "server"
+Requires-Dist: wsproto; extra == "server"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"

omlish-0.0.0.dev2/omlish/__about__.py

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

{omlish-0.0.0.dev0 → omlish-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-0.0.0.dev0 → omlish-0.0.0.dev2}/omlish/asyncs/__init__.py

@@ -1,12 +1,17 @@
 from .asyncs import (  # noqa
-    AsyncTimeoutException,
-    FutureException,
-    ImmediateExecutor,
     SyncableIterable,
     async_list,
-    await_dependent_futures,
-    await_futures,
     sync_await,
     sync_list,
     syncable_iterable,
 )
+
+
+from .futures import (  # noqa
+    FutureException,
+    FutureTimeoutException,
+    ImmediateExecutor,
+    new_thread_or_immediate_executor,
+    wait_dependent_futures,
+    wait_futures,
+)

omlish-0.0.0.dev2/omlish/asyncs/anyio.py

@@ -0,0 +1,84 @@
+"""
+lookit:
+ - https://github.com/davidbrochart/sqlite-anyio/blob/a3ba4c6ef0535b14a5a60071fcd6ed565a514963/sqlite_anyio/sqlite.py
+ - https://github.com/rafalkrupinski/ratelimit-anyio/blob/2910a8a3d6fa54ed17ee6ba457686c9f7a4c4beb/src/ratelimit_anyio/__init__.py
+ - https://github.com/nekitdev/async-extensions/tree/main/async_extensions
+ - https://github.com/kinnay/anynet/tree/master/anynet
+ - 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.streams.memory
+import anyio.streams.stapled
+
+from .. import check
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+async def anyio_eof_to_empty(fn: ta.Callable[..., ta.Awaitable[T]], *args: ta.Any, **kwargs: ta.Any) -> T | bytes:
+    try:
+        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-0.0.0.dev2/omlish/asyncs/asyncs.py

@@ -0,0 +1,76 @@
+"""
+TODO:
+ - async<->sync greeenlet bridge
+  In [5]: %timeit greenlet.greenlet(f).switch()
+  517 ns ± 13.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
+  - injected io provider - sync vs greenlet aio trampolined
+ - push/pull bridge?
+
+https://github.com/sqlalchemy/sqlalchemy/blob/1e75c189da721395bc8c2d899c722a5b9a170404/lib/sqlalchemy/util/_concurrency_py3k.py#L83
+"""
+import contextlib
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def sync_await(fn: ta.Callable[..., T], *args, **kwargs) -> T:
+    ret: ta.Any
+    ret = missing = object()
+
+    async def gate():
+        nonlocal ret
+        ret = await fn(*args, **kwargs)  # type: ignore
+
+    cr = gate()
+    with contextlib.closing(cr):
+        try:
+            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')
+
+    return ta.cast(T, ret)
+
+
+def sync_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
+    lst = None
+
+    async def inner():
+        nonlocal lst
+        lst = [v async for v in fn(*args, **kwargs)]
+
+    sync_await(inner)
+    if not isinstance(lst, list):
+        raise TypeError(lst)
+    return lst
+
+
+async def async_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
+    return [v async for v in fn(*args, **kwargs)]
+
+
+class SyncableIterable(ta.Generic[T]):
+
+    def __init__(self, obj) -> None:
+        super().__init__()
+        self._obj = obj
+
+    def __iter__(self) -> ta.Iterator[T]:
+        async def inner():
+            async for i in self._obj:
+                yield i
+        return iter(sync_list(inner))
+
+    def __aiter__(self) -> ta.AsyncIterator[T]:
+        return self._obj.__aiter__()
+
+
+def syncable_iterable(fn: ta.Callable[..., ta.AsyncIterator[T]]) -> ta.Callable[..., SyncableIterable[T]]:
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        return SyncableIterable(fn(*args, **kwargs))
+    return inner

omlish-0.0.0.dev0/omlish/asyncs/asyncs.py → omlish-0.0.0.dev2/omlish/asyncs/futures.py

@@ -1,109 +1,18 @@
-"""
-TODO:
- - async<->sync greeenlet bridge
-  In [5]: %timeit greenlet.greenlet(f).switch()
-  517 ns ± 13.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
-  - injected io provider - sync vs greenlet aio trampolined
- - push/pull bridge?
-
-https://github.com/sqlalchemy/sqlalchemy/blob/1e75c189da721395bc8c2d899c722a5b9a170404/lib/sqlalchemy/util/_concurrency_py3k.py#L83
-"""
 import concurrent.futures as cf
 import contextlib
-import functools
 import time
 import typing as ta
 
 
 T = ta.TypeVar('T')
-CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 
-def sync_await(fn: ta.Callable[..., T], *args, **kwargs) -> T:
-    ret: ta.Any
-    ret = missing = object()
-
-    async def gate():
-        nonlocal ret
-        ret = await fn(*args, **kwargs)  # type: ignore
-
-    cr = gate()
-    with contextlib.closing(cr):
-        try:
-            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')
-
-    return ta.cast(T, ret)
-
-
-def sync_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
-    lst = None
-
-    async def inner():
-        nonlocal lst
-        lst = [v async for v in fn(*args, **kwargs)]
-
-    sync_await(inner)
-    if not isinstance(lst, list):
-        raise TypeError(lst)
-    return lst
-
-
-async def async_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
-    return [v async for v in fn(*args, **kwargs)]
-
-
-class SyncableIterable(ta.Generic[T]):
-
-    def __init__(self, obj) -> None:
-        super().__init__()
-        self._obj = obj
-
-    def __iter__(self) -> ta.Iterator[T]:
-        async def inner():
-            async for i in self._obj:
-                yield i
-        return iter(sync_list(inner))
-
-    def __aiter__(self) -> ta.AsyncIterator[T]:
-        return self._obj.__aiter__()
-
-
-def syncable_iterable(fn: ta.Callable[..., ta.AsyncIterator[T]]) -> ta.Callable[..., SyncableIterable[T]]:
-    @functools.wraps(fn)
-    def inner(*args, **kwargs):
-        return SyncableIterable(fn(*args, **kwargs))
-    return inner
-
-
-class ImmediateExecutor(cf.Executor):
-
-    def __init__(self, *, immediate_exceptions: bool = False) -> None:
-        super().__init__()
-        self._immediate_exceptions = immediate_exceptions
-
-    def submit(self, fn, *args, **kwargs):
-        future: ta.Any = cf.Future()
-        try:
-            result = fn(*args, **kwargs)
-            future.set_result(result)
-        except Exception as e:
-            if self._immediate_exceptions:
-                raise
-            future.set_exception(e)
-        return future
-
-
-class AsyncTimeoutException(Exception):
-    pass
+##
 
 
 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
@@ -114,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:
@@ -128,11 +37,15 @@ class FutureException(Exception, ta.Generic[T]):
     __str__ = __repr__
 
 
-def await_futures(
+class FutureTimeoutException(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,
@@ -155,18 +68,18 @@ def await_futures(
             return True
 
         if time.time() >= (start + timeout_s):
-            raise AsyncTimeoutException
+            raise FutureTimeoutException
         time.sleep(tick_interval_s)
 
     return False
 
 
-def await_dependent_futures(
+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():
@@ -215,7 +128,7 @@ def await_dependent_futures(
 
         if time.time() >= (start + timeout_s):
             cancel()
-            raise AsyncTimeoutException
+            raise FutureTimeoutException
 
     remaining_fns = {fn: deps for fn, deps in remaining_dep_sets_by_fn.items() if deps}
     if remaining_fns:
@@ -223,3 +136,44 @@ def await_dependent_futures(
 
     futs_by_fn = {fn: fut for fut, fn in fns_by_fut.items()}
     return futs_by_fn
+
+
+##
+
+
+class ImmediateExecutor(cf.Executor):
+
+    def __init__(self, *, immediate_exceptions: bool = False) -> None:
+        super().__init__()
+        self._immediate_exceptions = immediate_exceptions
+
+    def submit(self, fn, *args, **kwargs):
+        future: ta.Any = cf.Future()
+        try:
+            result = fn(*args, **kwargs)
+            future.set_result(result)
+        except Exception as e:
+            if self._immediate_exceptions:
+                raise
+            future.set_exception(e)
+        return future
+
+
+@contextlib.contextmanager
+def new_thread_or_immediate_executor(
+        max_workers: int | None = None,
+        *,
+        immediate_exceptions: bool = False,
+        thread_name_prefix: str = '',
+        **kwargs: ta.Any,
+) -> ta.Generator[cf.Executor, None, None]:
+    if max_workers == 0:
+        yield ImmediateExecutor(
+            immediate_exceptions=immediate_exceptions,
+        )
+    else:
+        with cf.ThreadPoolExecutor(
+                thread_name_prefix=thread_name_prefix,
+                **kwargs,
+        ) as exe:
+            yield exe

omlish-0.0.0.dev2/omlish/asyncs/trio.py

@@ -0,0 +1,11 @@
+"""
+lookit:
+ - https://github.com/oremanj/trio-monitor
+ - https://github.com/python-trio/trio-monitor/tree/master
+ - https://github.com/python-trio/triopg
+ - https://github.com/python-trio/trio-mysql
+ - https://github.com/goodboy/tractor
+ - https://github.com/groove-x/trio-util
+ - https://github.com/oremanj/tricycle/tree/master
+ - https://github.com/linkdd/triotp
+"""

{omlish-0.0.0.dev0 → omlish-0.0.0.dev2}/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-0.0.0.dev0 → omlish-0.0.0.dev2}/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-0.0.0.dev2/omlish/collections/__init__.py

@@ -0,0 +1,98 @@
+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,
+)