omlish 0.0.0.dev2__py3-none-any.whl → 0.0.0.dev4__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.12'
 
-__version__ = '0.0.0.dev2'
+__version__ = '0.0.0.dev4'

omlish/__init__.py

@@ -0,0 +1,8 @@
+import sys as _sys
+
+
+REQUIRED_PYTHON_VERSION = (3, 12)
+
+
+if _sys.version_info < REQUIRED_PYTHON_VERSION:
+    raise EnvironmentError(f'Python version {_sys.version_info=} < {REQUIRED_PYTHON_VERSION}')

omlish/argparse.py

@@ -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:

omlish/asyncs/__init__.py

@@ -6,12 +6,33 @@ from .asyncs import (  # noqa
     syncable_iterable,
 )
 
+from .flavors import (  # noqa
+    ContextManagerAdapter,
+    Flavor,
+    adapt,
+    adapt_context,
+    from_anyio,
+    from_anyio_context,
+    from_asyncio,
+    from_asyncio_context,
+    from_trio,
+    from_trio_context,
+    get_flavor,
+    mark_anyio,
+    mark_asyncio,
+    mark_flavor,
+    mark_trio,
+)
 
 from .futures import (  # noqa
-    FutureException,
-    FutureTimeoutException,
+    FutureError,
+    FutureTimeoutError,
     ImmediateExecutor,
     new_thread_or_immediate_executor,
     wait_dependent_futures,
     wait_futures,
 )
+
+from .trio_asyncio import (  # noqa
+    with_trio_asyncio_loop,
+)

omlish/asyncs/anyio.py

@@ -39,11 +39,12 @@ def split_memory_object_streams(
 
 
 # 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)
+# 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(
@@ -57,12 +58,13 @@ def staple_memory_object_stream(
 
 
 # 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
-#     )
+# 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]]:

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/flavors.py

@@ -0,0 +1,201 @@
+"""
+TODO:
+ - 'get current'? -> sniffio..
+ - mark whole class / module?
+ - sync/greenlet bridge
+"""
+import abc
+import dataclasses as dc
+import enum
+import typing as ta
+
+from .. import lang
+from .trio_asyncio import check_trio_asyncio
+
+if ta.TYPE_CHECKING:
+    import sniffio
+    import trio_asyncio
+else:
+    sniffio = lang.proxy_import('sniffio')
+    trio_asyncio = lang.proxy_import('trio_asyncio')
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+_FLAVOR_ATTR = '__async_flavor__'
+
+
+class _MISSING(lang.Marker):
+    pass
+
+
+class Flavor(enum.Enum):
+    ASYNCIO = enum.auto()
+    TRIO = enum.auto()
+    ANYIO = enum.auto()
+
+
+def mark_flavor(f: Flavor):
+    if not isinstance(f, Flavor):
+        raise TypeError(f)
+
+    def inner(fn):
+        setattr(fn, _FLAVOR_ATTR, f)
+        return fn
+
+    return inner
+
+
+mark_asyncio = mark_flavor(Flavor.ASYNCIO)
+mark_anyio = mark_flavor(Flavor.ANYIO)
+mark_trio = mark_flavor(Flavor.TRIO)
+
+PACKAGE_FLAVORS: ta.MutableMapping[str, Flavor] = {
+    'anyio': Flavor.ANYIO,
+    'asyncio': Flavor.ASYNCIO,
+    'trio': Flavor.TRIO,
+
+    'sqlalchemy.ext.asyncio': Flavor.ASYNCIO,
+}
+
+_MODULE_FLAVOR_CACHE: dict[str, Flavor | None] = {}
+
+
+def _get_module_flavor(p: str) -> Flavor | None:
+    try:
+        return _MODULE_FLAVOR_CACHE[p]
+    except KeyError:
+        pass
+    pf: Flavor | None = None
+    for cp, cf in PACKAGE_FLAVORS.items():
+        if p.startswith(cp) and (len(cp) == len(p) or p[len(cp)] == '.'):
+            pf = cf
+            break
+    _MODULE_FLAVOR_CACHE[p] = pf
+    return pf
+
+
+def get_flavor(obj: ta.Any, default: ta.Union[Flavor, type[_MISSING], None] = _MISSING) -> Flavor:
+    u = lang.unwrap_func(obj)
+
+    try:
+        return getattr(u, _FLAVOR_ATTR)
+    except AttributeError:
+        pass
+
+    if (mn := getattr(u, '__module__', None)) is not None:
+        if (pf := _get_module_flavor(mn)):
+            return pf
+
+    if default is not _MISSING:
+        return default  # type: ignore
+
+    raise TypeError(f'not marked with flavor: {obj}')
+
+
+##
+
+
+class Adapter(lang.Abstract):
+    _FROM_METHODS_BY_FLAVOR: ta.ClassVar[ta.Mapping[Flavor, str]] = {
+        Flavor.ANYIO: 'from_anyio',
+        Flavor.ASYNCIO: 'from_asyncio',
+        Flavor.TRIO: 'from_trio',
+    }
+
+    def adapt(self, fn, fl=None):
+        if fl is None:
+            fl = get_flavor(fn)
+        return getattr(self, self._FROM_METHODS_BY_FLAVOR[fl])(fn)
+
+    #
+
+    def from_anyio(self, fn):
+        return fn
+
+    @abc.abstractmethod
+    def from_asyncio(self, fn):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def from_trio(self, fn):
+        raise NotImplementedError
+
+
+class AsyncioAdapter(Adapter):
+    def from_asyncio(self, fn):
+        return fn
+
+    def from_trio(self, fn):
+        check_trio_asyncio()
+        return trio_asyncio.trio_as_aio(fn)
+
+
+class TrioAdapter(Adapter):
+    def from_asyncio(self, fn):
+        check_trio_asyncio()
+        return trio_asyncio.aio_as_trio(fn)
+
+    def from_trio(self, fn):
+        return fn
+
+
+_ADAPTERS_BY_BACKEND: ta.Mapping[str, Adapter] = {
+    'asyncio': AsyncioAdapter(),
+    'trio': TrioAdapter(),
+}
+
+
+def get_adapter() -> Adapter:
+    return _ADAPTERS_BY_BACKEND[sniffio.current_async_library()]
+
+
+def adapt(fn, fl=None):
+    return get_adapter().adapt(fn, fl)
+
+
+def from_anyio(fn):
+    return get_adapter().from_anyio(fn)
+
+
+def from_asyncio(fn):
+    return get_adapter().from_asyncio(fn)
+
+
+def from_trio(fn):
+    return get_adapter().from_trio(fn)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ContextManagerAdapter(ta.Generic[T]):
+    obj: ta.AsyncContextManager[T]
+    adapt: ta.Callable[[ta.Callable], ta.Callable]
+
+    async def __aenter__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return await self.adapt(self.obj.__aenter__)(*args, **kwargs)
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self.adapt(self.obj.__aexit__)(exc_type, exc_val, exc_tb)
+
+
+def adapt_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().adapt)
+
+
+def from_anyio_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().from_anyio)
+
+
+def from_asyncio_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().from_asyncio)
+
+
+def from_trio_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().from_trio)

omlish/asyncs/futures.py

@@ -5,12 +5,13 @@ 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: T | None = None) -> None:
         super().__init__()
@@ -37,7 +38,7 @@ class FutureException(Exception, ta.Generic[T]):
     __str__ = __repr__
 
 
-class FutureTimeoutException(Exception):
+class FutureTimeoutError(Exception):
     pass
 
 
@@ -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
@@ -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/asyncs/trio_asyncio.py

@@ -0,0 +1,41 @@
+import functools
+import typing as ta
+
+from .. import lang
+
+if ta.TYPE_CHECKING:
+    import asyncio
+    import sniffio
+    import trio_asyncio
+else:
+    asyncio = lang.proxy_import('asyncio')
+    sniffio = lang.proxy_import('sniffio')
+    trio_asyncio = lang.proxy_import('trio_asyncio')
+
+
+def check_trio_asyncio() -> None:
+    if trio_asyncio.current_loop.get() is None:
+        raise RuntimeError('trio_asyncio loop not running')
+
+
+def with_trio_asyncio_loop(fn, *, wait=False):
+    @functools.wraps(fn)
+    async def inner(*args, **kwargs):
+        if trio_asyncio.current_loop.get() is not None:
+            await fn(*args, **kwargs)
+            return
+
+        if sniffio.current_async_library() != 'trio':
+            raise RuntimeError('trio loop not running')
+
+        loop: asyncio.BaseEventLoop
+        async with trio_asyncio.open_loop() as loop:
+            try:
+                await fn(*args, **kwargs)
+            finally:
+                if wait:
+                    # FIXME: lol
+                    while asyncio.all_tasks(loop):
+                        await asyncio.sleep(.2)
+
+    return inner

omlish/c3.py

@@ -113,7 +113,7 @@ 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],
     )

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[..., str | None], None]
+Message = str | ta.Callable[..., str | None] | None
 
 _NONE_TYPE = type(None)
 
@@ -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
@@ -206,7 +206,7 @@ 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

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,7 +26,7 @@ class _HashedSeq(list):
 
     def __init__(
             self,
-            tup: ta.Tuple,
+            tup: tuple,
             hasher: ta.Callable[[ta.Any], int] = hash,
     ) -> None:
         super().__init__()
@@ -34,19 +34,19 @@ class _HashedSeq(list):
         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:
@@ -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