omlish 0.0.0.dev409__py3-none-any.whl → 0.0.0.dev410__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev409'
-__revision__ = '9ee675d7bba914e838f5f8ce55dc0af32638a52c'
+__version__ = '0.0.0.dev410'
+__revision__ = 'fa58128e15cab568117709c80765dc8d633cb4e0'
 
 
 #

omlish/asyncs/all.py

@@ -1,11 +1,3 @@
-from .sync import (  # noqa
-    SyncableIterable,
-    async_list,
-    sync_await,
-    sync_list,
-    syncable_iterable,
-)
-
 from .bridge import (  # noqa
     a_to_s,
     is_in_bridge,

omlish/asyncs/bridge.py

@@ -43,7 +43,6 @@ from .. import check
 from .. import lang
 from .. import sync
 from ..concurrent import threadlets
-from .sync import sync_await
 
 
 if ta.TYPE_CHECKING:
@@ -71,7 +70,7 @@ def trivial_s_to_a(fn):
 
 def trivial_a_to_s(fn):
     def inner(*args, **kwargs):
-        return sync_await(fn, *args, **kwargs)
+        return lang.sync_await(fn, *args, **kwargs)
     return inner
 
 

omlish/lang/__init__.py

@@ -1,3 +1,10 @@
+from .asyncs import (  # noqa
+    async_list,
+
+    sync_await,
+    sync_async_list,
+)
+
 from .attrs import (  # noqa
     AttrOps,
     AttributePresentError,
@@ -273,11 +280,11 @@ from .lazyglobals import (  # noqa
 )
 
 from .maysyncs import (  # noqa
-    MaysyncP,
+    MaysyncFn,
+    MaysyncGeneratorFn,
 
     make_maysync,
     make_maysync_from_sync,
-
     maysync,
 )
 
@@ -420,8 +427,11 @@ just = Maybe.just
 
 from ..lite.maysyncs import (  # noqa
     Maywaitable,
-    Maysync,
+    MaysyncGenerator,
+
     Maysync_,
+    MaysyncFn_,
+    MaysyncGeneratorFn_,
 )
 
 from ..lite.reprs import (  # noqa

omlish/lang/asyncs.py

@@ -0,0 +1,80 @@
+import typing as ta
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+async def async_list(
+        fn: ta.Callable[P, ta.AsyncIterator[T]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+) -> list[T]:
+    """Simply eagerly reads the full contents of a function call returning an async iterator."""
+
+    return [v async for v in fn(*args, **kwargs)]
+
+
+##
+
+
+def sync_await(
+        fn: ta.Callable[P, ta.Awaitable[T]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+) -> T:
+    """
+    Allows for the synchronous execution of async functions which will never actually *externally* await anything. These
+    functions are allowed to await any number of other functions - including contextmanagers and generators - so long as
+    nothing ever actually 'leaks' out of the function, presumably to an event loop.
+    """
+
+    ret = missing = object()
+
+    async def gate():
+        nonlocal ret
+
+        ret = await fn(*args, **kwargs)
+
+    cr = gate()
+    try:
+        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')
+
+    finally:
+        cr.close()
+
+    return ta.cast(T, ret)
+
+
+def sync_async_list(
+        fn: ta.Callable[P, ta.AsyncIterator[T]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+) -> list[T]:
+    """
+    Uses `sync_await` to synchronously read the full contents of a function call returning an async iterator, given that
+    the function never externally awaits anything.
+    """
+
+    lst: list[T] | None = 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

omlish/lang/maysyncs.py

@@ -1,15 +1,22 @@
 import typing as ta
 
+from ..lite.maysyncs import MaysyncGenerator
 from ..lite.maysyncs import Maywaitable
 from ..lite.maysyncs import make_maysync as _make_maysync
 from ..lite.maysyncs import maysync as _maysync
+from ..lite.maysyncs import maysync_fn as _maysync_fn
+from ..lite.maysyncs import maysync_generator_fn as _maysync_generator_fn
 from .functions import as_async
 
 
 T = ta.TypeVar('T')
+O = ta.TypeVar('O')
+I = ta.TypeVar('I')
+
 P = ta.ParamSpec('P')
 
-MaysyncP: ta.TypeAlias = ta.Callable[P, Maywaitable[T]]
+MaysyncFn: ta.TypeAlias = ta.Callable[P, Maywaitable[T]]
+MaysyncGeneratorFn: ta.TypeAlias = ta.Callable[P, MaysyncGenerator[O, I]]
 
 
 ##
@@ -18,8 +25,8 @@ MaysyncP: ta.TypeAlias = ta.Callable[P, Maywaitable[T]]
 def make_maysync(
         s: ta.Callable[P, T],
         a: ta.Callable[P, ta.Awaitable[T]],
-) -> MaysyncP[P, T]:
-    return ta.cast('MaysyncP[P, T]', _make_maysync(
+) -> MaysyncFn[P, T]:
+    return ta.cast('MaysyncFn[P, T]', _make_maysync(
         s,
         a,
     ))
@@ -28,8 +35,8 @@ def make_maysync(
 def make_maysync_from_sync(
         s: ta.Callable[P, T],
         a: ta.Callable[P, ta.Awaitable[T]] | None = None,
-) -> MaysyncP[P, T]:
-    return ta.cast('MaysyncP[P, T]', _make_maysync(
+) -> MaysyncFn[P, T]:
+    return ta.cast('MaysyncFn[P, T]', _make_maysync(
         s,
         a if a is not None else as_async(s),
     ))
@@ -38,7 +45,31 @@ def make_maysync_from_sync(
 ##
 
 
-def maysync(m: ta.Callable[P, ta.Awaitable[T]]) -> MaysyncP[P, T]:
-    return ta.cast('MaysyncP[P, T]', _maysync(
-        m,
-    ))
+def maysync_fn(
+        m: ta.Callable[P, ta.Awaitable[T]],
+) -> MaysyncFn[P, T]:
+    return ta.cast('MaysyncFn[P, T]', _maysync_fn(m))
+
+
+def maysync_generator_fn(
+        m: ta.Callable[P, ta.AsyncGenerator[O, I]],
+) -> MaysyncGeneratorFn[P, O, I]:
+    return ta.cast('MaysyncGeneratorFn[P, O, I]', _maysync_generator_fn(m))
+
+
+@ta.overload
+def maysync(
+        m: ta.Callable[P, ta.Awaitable[T]],
+) -> MaysyncFn[P, T]:
+    ...
+
+
+@ta.overload
+def maysync(
+        m: ta.Callable[P, ta.AsyncGenerator[O, I]],
+) -> MaysyncGeneratorFn[P, O, I]:
+    ...
+
+
+def maysync(m):
+    return _maysync(m)

omlish/lite/maysyncs.py

@@ -1,67 +1,224 @@
-# ruff: noqa: UP006 UP045
+# ruff: noqa: UP006 UP043 UP045 UP046 UP047
 # @omlish-lite
 """
+A system for writing a python function once which can then be effectively used in both sync and async contexts -
+including IO, under any (or no) event loop.
+
+Where an 'async fn' returns an 'awaitable', a 'maysync fn' returns a 'maywaitable', which is an object with two
+nullary methods:
+
+ - `def s()` - to be called in sync contexts
+ - `async def a()` - to be called in async and maysync contexts
+
+For example, a maysync function `m_inc_int(x: int) -> int` would be used as such:
+
+ - `assert m_inc_int(5).s() == 6` in sync contexts
+ - `assert await m_inc_int(5).a() == 6` in async and maysync contexts
+
+Maysync fns may be constructed in two ways: either using `make_maysync`, providing an equivalent pair of sync and async
+functions, or using the `@maysync` decorator to wrap a 'maysync flavored' async function. 'Maysync flavored' async
+functions are ones which only call other maysync functions through their 'maysync context' - that is, they  use the 'a'
+methods on maywaitables - for example: `await m_foo().a()` - and the maysync machinery will ultimately call the
+appropriate 'leaf' sync or async functions. Being regular python functions they are free to call whatever they like -
+for example doing sync IO - but the point is to, ideally, route all IO through maysync functions such that the maysync
+code is fully efficiently usable in any context.
+
+Internally, it's not really correct to say that there is 'no event loop' in the maysync context - rather, each
+'entrypoint' call to a maysync fn runs within its own tiny event loop.
+
+===
+
 TODO:
  - __del__
+ - (test) maysync context managers
+ - CancelledError
+ - for debug, mask any running eventloop while running maysync code
+ - `[CO_ASYNC_GENERATOR] = {k for k, v in dis.COMPILER_FLAG_NAMES.items() if v == 'ASYNC_GENERATOR'}` ? inspect is big..
+  - works down to 3.8
 """
 import abc
 import functools
+import inspect
+import sys
+import threading
 import typing as ta
 
 
 T = ta.TypeVar('T')
 T_co = ta.TypeVar('T_co', covariant=True)
 
+O = ta.TypeVar('O')
+O_co = ta.TypeVar('O_co', covariant=True)
+
+I = ta.TypeVar('I')
+I_contra = ta.TypeVar('I_contra', contravariant=True)
+
 _MaysyncX = ta.TypeVar('_MaysyncX')
 
-_MaysyncGen = ta.Generator['_MaysyncOp', ta.Any, T]  # ta.TypeAlias
+_MaysyncRS = ta.TypeVar('_MaysyncRS')
+_MaysyncRA = ta.TypeVar('_MaysyncRA')
 
 
 ##
 
 
 class Maywaitable(ta.Protocol[T_co]):
+    """
+    The maysync version of `Awaitable[T]`. Non-generator maysync functions return a `Maywaitable`, with the following
+    nullary methods:
+
+     - `def s()` - to be called in sync contexts
+     - `async def a()` - to be called in async and maysync contexts
+
+    Only the proper method should be called in each context.
+    """
+
     def s(self) -> T_co:
         ...
 
     def a(self) -> ta.Awaitable[T_co]:
         ...
 
-    def m(self) -> ta.Awaitable[T_co]:
+
+class MaysyncGenerator(ta.Protocol[O_co, I_contra]):
+    """
+    The maysync version of `AsyncGenerator[O, I]`. Generator maysync functions return a `MaysyncGenerator`, with the
+    following methods:
+
+     - `def s()` - to be called in sync contexts
+     - `async def a()` - to be called in async and maysync contexts
+
+    Only the proper method should be called in each context.
+    """
+
+    def s(self) -> ta.Generator[O_co, I_contra, None]:
         ...
 
+    def a(self) -> ta.AsyncGenerator[O_co, I_contra]:
+        ...
 
-Maysync = ta.Callable[..., Maywaitable[T]]  # ta.TypeAlias  # omlish-amalg-typing-no-move
 
+# The maysync equivalent of an async function
+MaysyncFn = ta.Callable[..., Maywaitable[T]]  # ta.TypeAlias  # omlish-amalg-typing-no-move
 
-class Maysync_(abc.ABC, ta.Generic[T]):  # noqa
-    @ta.final
-    def cast(self) -> Maysync[T]:
-        return ta.cast('Maysync[T]', self)
+# The maysync equivalent of an async generator function
+MaysyncGeneratorFn = ta.Callable[..., MaysyncGenerator[O, I]]  # ta.TypeAlias  # omlish-amalg-typing-no-move
+
+
+class Maysync_(abc.ABC):  # noqa
+    """
+    Abstract base class for maysync objects - either MaysyncFn's or MaysyncGeneratorFn's.
+
+    The concrete implementations are module-level implementation detail, and in general users should make a point to
+    only interact with the protocols defined above, but introspection can be necessary at times.
+    """
+
+    def __init_subclass__(cls, **kwargs):
+        if Maysync_ in cls.__bases__ and abc.ABC not in cls.__bases__:
+            raise TypeError(cls)
+
+        super().__init_subclass__(**kwargs)
 
     class FnPair(ta.NamedTuple):
         s: ta.Callable[..., ta.Any]
-        a: ta.Callable[..., ta.Awaitable[ta.Any]]
+        a: ta.Callable[..., ta.Any]
 
     @abc.abstractmethod
     def fn_pair(self) -> ta.Optional[FnPair]:
+        """If this maysync object is backed by a (sync, async) pair of functions, returns the pair."""
+
         raise NotImplementedError
 
     @abc.abstractmethod
-    def __call__(self, *args, **kwargs):  # -> Maywaitable[T]
+    def cast(self):
+        pass
+
+    @abc.abstractmethod
+    def __call__(self, *args, **kwargs):
         raise NotImplementedError
 
 
+class MaysyncFn_(Maysync_, abc.ABC, ta.Generic[T]):  # noqa
+    @ta.final
+    def cast(self) -> MaysyncFn[T]:
+        return ta.cast('MaysyncFn[T]', self)
+
+
+class MaysyncGeneratorFn_(Maysync_, abc.ABC, ta.Generic[O, I]):  # noqa
+    @ta.final
+    def cast(self) -> MaysyncGenerator[O, I]:
+        return ta.cast('MaysyncGenerator[O, I]', self)
+
+
+##
+
+
+class _MaysyncThreadLocal(threading.local):
+    context: ta.Optional['_MaysyncContext'] = None
+
+
+class _MaysyncContext(abc.ABC):
+    mode: ta.ClassVar[ta.Literal['s', 'a']]
+
+    @classmethod
+    def current(cls) -> ta.Optional['_MaysyncContext']:
+        return _MaysyncThreadLocal.context
+
+    @abc.abstractmethod
+    def run(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
+        raise NotImplementedError
+
+
+@ta.final
+class _SyncMaysyncContext(_MaysyncContext):
+    mode: ta.ClassVar[ta.Literal['s']] = 's'
+
+    def run(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
+        prev = _MaysyncThreadLocal.context
+        _MaysyncThreadLocal.context = self
+
+        ph = sys.get_asyncgen_hooks()
+        sys.set_asyncgen_hooks(firstiter=None, finalizer=None)
+
+        try:
+            return fn(*args, **kwargs)
+
+        finally:
+            sys.set_asyncgen_hooks(*ph)
+
+            _MaysyncThreadLocal.context = prev
+
+
+@ta.final
+class _AsyncMaysyncContext(_MaysyncContext):
+    mode: ta.ClassVar[ta.Literal['a']] = 'a'
+
+    def run(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
+        prev = _MaysyncThreadLocal.context
+        _MaysyncThreadLocal.context = self
+
+        try:
+            return fn(*args, **kwargs)
+
+        finally:
+            _MaysyncThreadLocal.context = prev
+
+
 ##
 
 
-class _Maywaitable(abc.ABC, ta.Generic[_MaysyncX, T]):
+class _MaywaitableLike(
+    abc.ABC,
+    ta.Generic[_MaysyncX],
+):
+    """Abstract base class for the maysync versions of `Awaitable[T]` and `AsyncGenerator[O, I]`."""
+
     @ta.final
     def __init__(
             self,
             x: _MaysyncX,
-            *args: ta.Any,
-            **kwargs: ta.Any,
+            args: ta.Tuple[ta.Any, ...],
+            kwargs: ta.Mapping[str, ta.Any],
     ) -> None:
         self._x = x
         self._args = args
@@ -70,24 +227,36 @@ class _Maywaitable(abc.ABC, ta.Generic[_MaysyncX, T]):
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}@{id(self):x}({self._x!r})'
 
-    @ta.final
-    def m(self) -> ta.Awaitable[T]:
-        return _MaysyncFuture(_MaysyncOp(
-            ta.cast(ta.Any, self._x),
-            self._args,
-            self._kwargs,
-        ))
+
+class _Maywaitable(
+    _MaywaitableLike[_MaysyncX],
+    abc.ABC,
+    ta.Generic[_MaysyncX, T],
+):
+    pass
+
+
+class _MaysyncGenerator(
+    _MaywaitableLike[_MaysyncX],
+    abc.ABC,
+    ta.Generic[_MaysyncX, O, I],
+):
+    pass
 
 
 ##
 
 
-@ta.final
-class _FnMaysync(Maysync_, ta.Generic[T]):
+class _FpMaysyncFnLike(
+    abc.ABC,
+    ta.Generic[_MaysyncRS, _MaysyncRA],
+):
+    """A maysync object backed by an underlying (sync, async) function pair."""
+
     def __init__(
             self,
-            s: ta.Callable[..., T],
-            a: ta.Callable[..., ta.Awaitable[T]],
+            s: ta.Callable[..., _MaysyncRS],
+            a: ta.Callable[..., _MaysyncRA],
     ) -> None:
         if s is None:
             raise TypeError(s)
@@ -106,39 +275,150 @@ class _FnMaysync(Maysync_, ta.Generic[T]):
         )
 
     def __get__(self, instance, owner=None):
-        return _FnMaysync(
+        return self.__class__(
             self._s.__get__(instance, owner),  # noqa
             self._a.__get__(instance, owner),  # noqa
         )
 
+
+@ta.final
+class _FpMaysyncFn(
+    _FpMaysyncFnLike[T, ta.Awaitable[T]],
+    MaysyncFn_[T],
+    ta.Generic[T],
+):
     def __call__(self, *args, **kwargs):
-        return _FnMaywaitable(self, *args, **kwargs)
+        return _FpMaywaitable(self, args, kwargs)
 
 
 @ta.final
-class _FnMaywaitable(_Maywaitable[_FnMaysync[T], T]):
+class _FpMaywaitable(
+    _Maywaitable[_FpMaysyncFn[T], T],
+):
     def s(self) -> T:
         return self._x._s(*self._args, **self._kwargs)  # noqa
 
-    async def a(self) -> T:
-        return await self._x._a(*self._args, **self._kwargs)  # noqa
+    def a(self) -> ta.Awaitable[T]:
+        if _MaysyncContext.current() is not None:
+            return _MaysyncFuture(self._x, self._args, self._kwargs)
+
+        return self._x._a(*self._args, **self._kwargs)  # noqa
+
+
+def make_maysync_fn(
+        s: ta.Callable[..., T],
+        a: ta.Callable[..., ta.Awaitable[T]],
+) -> MaysyncFn[T]:
+    """Constructs a MaysyncFn from a (sync, async) function pair."""
+
+    return _FpMaysyncFn(s, a)
+
+
+@ta.final
+class _FpMaysyncGeneratorFn(
+    _FpMaysyncFnLike[ta.Generator[O, I, None], ta.AsyncGenerator[O, I]],
+    MaysyncGeneratorFn_[O, I],
+    ta.Generic[O, I],
+):
+    def __call__(self, *args, **kwargs):
+        return _FpMaysyncGenerator(self, args, kwargs)
+
+
+@ta.final
+class _FpMaysyncGenerator(
+    _MaysyncGenerator[_FpMaysyncGeneratorFn[O, I], O, I],
+):
+    def s(self) -> ta.Generator[O, I, None]:
+        return self._x._s(*self._args, **self._kwargs)  # noqa
+
+    def a(self) -> ta.AsyncGenerator[O, I]:
+        if (ctx := _MaysyncContext.current()) is not None and ctx.mode == 's':
+            async def inner():
+                g = self._x._s(*self._args, **self._kwargs)  # noqa
+
+                i: ta.Any = None
+                e: ta.Any = None
+
+                while True:
+                    try:
+                        if e is not None:
+                            o = g.throw(e)
+                        else:
+                            o = g.send(i)
+                    except StopIteration as ex:
+                        if ex.value is not None:
+                            raise TypeError(ex) from None
+                        return
+
+                    i = None
+                    e = None
+
+                    try:
+                        i = yield o
+                    except StopIteration as ex:  # noqa
+                        raise NotImplementedError  # noqa
+                    except StopAsyncIteration as ex:  # noqa
+                        raise NotImplementedError  # noqa
+                    except BaseException as ex:  # noqa
+                        e = ex
+
+            return inner()
+
+        return self._x._a(*self._args, **self._kwargs)  # noqa
+
 
+def make_maysync_generator_fn(
+        s: ta.Callable[..., ta.Generator[O, I, None]],
+        a: ta.Callable[..., ta.AsyncGenerator[O, I]],
+) -> MaysyncGeneratorFn[O, I]:
+    """Constructs a MaysyncGeneratorFn from a (sync, async) generator function pair."""
 
+    return _FpMaysyncGeneratorFn(s, a)
+
+
+@ta.overload
 def make_maysync(
         s: ta.Callable[..., T],
         a: ta.Callable[..., ta.Awaitable[T]],
-) -> Maysync[T]:
-    return _FnMaysync(s, a)
+) -> MaysyncFn[T]:
+    ...
+
+
+@ta.overload
+def make_maysync(
+        s: ta.Callable[..., ta.Generator[O, I, None]],
+        a: ta.Callable[..., ta.AsyncGenerator[O, I]],
+) -> MaysyncGeneratorFn[O, I]:
+    ...
+
+
+def make_maysync(s, a):
+    """
+    Constructs a MaysyncFn or MaysyncGeneratorFn from a (sync, async) function pair, using `inspect.isasyncgenfunction`
+    to determine the type.
+    """
+
+    if inspect.isasyncgenfunction(a):
+        return make_maysync_generator_fn(s, a)
+    else:
+        return make_maysync_fn(s, a)
 
 
 ##
 
 
-@ta.final
-class _MgMaysync(Maysync_, ta.Generic[T]):
+class _MgMaysyncFnLike(
+    abc.ABC,
+    ta.Generic[T],
+):
+    """
+    A maysync object backed by an underlying generator yielding _MaysyncOp's. The _MgDriver and _MgGeneratorDriver
+    classes produce such generators.
+    """
+
     def __init__(
             self,
-            mg: ta.Callable[..., _MaysyncGen[T]],
+            mg: ta.Callable[..., T],
     ) -> None:
         self._mg = mg
 
@@ -151,141 +431,261 @@ class _MgMaysync(Maysync_, ta.Generic[T]):
         return None
 
     def __get__(self, instance, owner=None):
-        return _MgMaysync(
+        return self.__class__(
             self._mg.__get__(instance, owner),  # noqa
         )
 
+    @abc.abstractmethod  # noqa
     def __call__(self, *args, **kwargs):
-        return _MgMaywaitable(self, *args, **kwargs)
+        raise NotImplementedError
 
 
 @ta.final
-class _MgMaywaitable(_Maywaitable[_MgMaysync[T], T]):
-    def s(self) -> T:
-        g = self._x._mg(*self._args, **self._kwargs)  # noqa
-
-        i: ta.Any = None
-        e: ta.Any = None
+class _MgMaysyncFn(
+    _MgMaysyncFnLike[ta.Awaitable[T]],
+    MaysyncFn_[T],
+    ta.Generic[T],
+):
+    def __call__(self, *args, **kwargs):
+        return _MgMaywaitable(self, args, kwargs)
 
-        while True:
-            try:
-                if e is not None:
-                    o = g.throw(e)
-                else:
-                    o = g.send(i)
-            except StopIteration as ex:
-                return ex.value
 
-            i = None
-            e = None
+@ta.final
+class _MgMaysyncDriver:
+    def __init__(self, ctx, mg):
+        self.ctx = ctx
+        self.mg = mg
 
-            if not isinstance(o, _MaysyncOp):
-                raise TypeError(o)
+    value: ta.Any
 
+    def __iter__(self):
+        try:
+            a = self.mg.__await__()
             try:
-                i = o.x(*o.args, **o.kwargs).s()
-            except BaseException as ex:  # noqa
-                e = ex
+                g = iter(a)
+                try:
+                    while True:
+                        try:
+                            f = self.ctx.run(g.send, None)
+                        except StopIteration as ex:
+                            self.value = ex.value
+                            return
 
-            del o
+                        if not isinstance(f, _MaysyncFuture):
+                            raise TypeError(f)
 
-    async def a(self) -> T:
-        g = self._x._mg(*self._args, **self._kwargs)  # noqa
+                        yield f
+                        del f
 
-        i: ta.Any = None
-        e: ta.Any = None
+                finally:
+                    self.ctx.run(g.close)
 
-        while True:
-            try:
-                if e is not None:
-                    o = g.throw(e)
-                else:
-                    o = g.send(i)
-            except StopIteration as ex:
-                return ex.value
+            finally:
+                self.ctx.run(a.close)
+
+        finally:
+            self.ctx.run(self.mg.close)
 
-            i = None
-            e = None
 
-            if not isinstance(o, _MaysyncOp):
-                raise TypeError(o)
+@ta.final
+class _MgMaywaitable(
+    _Maywaitable[_MgMaysyncFn[T], T],
+):
+    def _driver(self, ctx: _MaysyncContext) -> _MgMaysyncDriver:
+        return _MgMaysyncDriver(ctx, self._x._mg(*self._args, **self._kwargs))  # noqa
 
-            try:
-                i = await o.x(*o.args, **o.kwargs).a()
-            except BaseException as ex:  # noqa
-                e = ex
+    def s(self) -> T:
+        for f in (drv := self._driver(_SyncMaysyncContext())):
+            f.s()
+            del f
 
-            del o
+        return drv.value
 
+    def a(self) -> ta.Awaitable[T]:
+        if (ctx := _MaysyncContext.current()) is None or ctx.mode == 'a':
+            return self._x._mg(*self._args, **self._kwargs)  # noqa
 
-@ta.final
-class _MgMaysyncFn:
-    def __init__(self, m):
-        self._m = m
+        async def inner():
+            for f in (drv := self._driver(_AsyncMaysyncContext())):
+                await f.a()
+                del f
 
-        functools.update_wrapper(self, m, updated=())
+            return drv.value
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{id(self):x}({self._m!r})'
+        return inner()
 
-    def __get__(self, instance, owner=None):
-        return _MgMaysyncFn(
-            self._m.__get__(instance, owner),
-        )
 
+@ta.final
+class _MgMaysyncGeneratorFn(
+    _MgMaysyncFnLike[ta.AsyncGenerator[O, I]],
+    MaysyncGeneratorFn_[O, I],
+    ta.Generic[O, I],
+):
     def __call__(self, *args, **kwargs):
-        a = self._m(*args, **kwargs).__await__()
+        return _MgMaysyncGenerator(self, args, kwargs)
+
+
+@ta.final
+class _MgMaysyncGeneratorDriver:
+    def __init__(self, ctx, ag):
+        self.ctx = ctx
+        self.ag = ag
+
+    def __iter__(self):
         try:
-            g = iter(a)
+            ai = self.ag.__aiter__()
             try:
+                i: ta.Any = None
+                e: ta.Any = None
+
                 while True:
-                    try:
-                        o = g.send(None)
-                    except StopIteration as e:
-                        return e.value
+                    if e is not None:
+                        coro = ai.athrow(e)
+                    else:
+                        coro = ai.asend(i)
 
-                    if not isinstance(o, _MaysyncFuture):
-                        raise TypeError(o)
+                    i = None
+                    e = None
 
-                    if not o.done:
-                        try:
-                            o.result = yield o.op
-                        except BaseException as e:  # noqa
-                            o.error = e
-                        o.done = True
+                    for f in (drv := _MgMaysyncDriver(self.ctx, coro)):
+                        if (x := (yield ('f', f))) is not None:
+                            raise RuntimeError(x)
 
-                    del o
+                        del f
+
+                    i, e = yield ('o', drv.value)
 
             finally:
-                g.close()
+                for f in _MgMaysyncDriver(self.ctx, ai.aclose()):
+                    yield ('f', f)
 
         finally:
-            a.close()
+            for f in _MgMaysyncDriver(self.ctx, self.ag.aclose()):
+                yield ('f', f)
 
 
-def maysync(m: ta.Callable[..., ta.Awaitable[T]]) -> Maysync[T]:
-    return _MgMaysync(_MgMaysyncFn(m))
+@ta.final
+class _MgMaysyncGenerator(
+    _MaysyncGenerator[_MgMaysyncGeneratorFn[O, I], O, I],
+):
+    def _driver(self, ctx: _MaysyncContext) -> _MgMaysyncGeneratorDriver:
+        return _MgMaysyncGeneratorDriver(ctx, self._x._mg(*self._args, **self._kwargs))  # noqa
 
+    def s(self) -> ta.Generator[O, I, None]:
+        drv = self._driver(_SyncMaysyncContext())
+        di = iter(drv)
 
-##
+        ie: ta.Any = None
 
+        while True:
+            try:
+                t, x = di.send(ie)
+            except StopAsyncIteration:
+                return
+            except StopIteration:
+                raise RuntimeError from None
 
-@ta.final
-class _MaysyncOp:
-    def __init__(
-            self,
-            x: Maysync[T],
-            args: ta.Tuple[ta.Any, ...],
-            kwargs: ta.Mapping[str, ta.Any],
-    ) -> None:
-        self.x = x
-        self.args = args
-        self.kwargs = kwargs
+            ie = None
+
+            if t == 'f':
+                x.s()
+
+            elif t == 'o':
+                try:
+                    y = yield x
+                    ie = (y, None)
+                except BaseException as ex:  # noqa
+                    ie = (None, ex)
+
+            else:
+                raise RuntimeError((t, x))
+
+            del x
+
+    def a(self) -> ta.AsyncGenerator[O, I]:
+        if _MaysyncContext.current() is not None:
+            return self._x._mg(*self._args, **self._kwargs)  # noqa
+
+        async def inner():
+            drv = self._driver(_AsyncMaysyncContext())
+            di = iter(drv)
+
+            ie: ta.Any = None
+
+            while True:
+                try:
+                    t, x = di.send(ie)
+                except StopAsyncIteration:
+                    return
+                except StopIteration:
+                    raise RuntimeError from None
+
+                ie = None
+
+                if t == 'f':
+                    await x.a()
+
+                elif t == 'o':
+                    try:
+                        y = yield x
+                        ie = (y, None)
+                    except BaseException as ex:  # noqa
+                        ie = (None, ex)
+
+                else:
+                    raise RuntimeError((t, x))
+
+                del x
+
+        return inner()
+
+
+def maysync_fn(
+        m: ta.Callable[..., ta.Awaitable[T]],
+) -> MaysyncFn[T]:
+    """Constructs a MaysyncFn from a 'maysync flavored' async function."""
+
+    return _MgMaysyncFn(m)
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{id(self):x}({self.x!r})'
 
+def maysync_generator_fn(
+        m: ta.Callable[..., ta.AsyncGenerator[O, I]],
+) -> MaysyncGeneratorFn[O, I]:
+    """Constructs a MaysyncGeneratorFn from a 'maysync flavored' async generator function."""
 
+    return _MgMaysyncGeneratorFn(m)
+
+
+@ta.overload
+def maysync(
+        m: ta.Callable[..., ta.Awaitable[T]],
+) -> MaysyncFn[T]:
+    ...
+
+
+@ta.overload
+def maysync(
+        m: ta.Callable[..., ta.AsyncGenerator[O, I]],
+) -> MaysyncGeneratorFn[O, I]:
+    ...
+
+
+def maysync(m):
+    """
+    Constructs a MaysyncFn or MaysyncGeneratorFn from 'maysync flavored' async function or async generator function,
+    using `inspect.isasyncgenfunction` to determine the type. Usable as a decorator.
+    """
+
+    if inspect.isasyncgenfunction(m):
+        return maysync_generator_fn(m)
+    else:
+        return maysync_fn(m)
+
+
+##
+
+
+@ta.final
 class _MaysyncFutureNotAwaitedError(RuntimeError):
     pass
 
@@ -294,12 +694,16 @@ class _MaysyncFutureNotAwaitedError(RuntimeError):
 class _MaysyncFuture(ta.Generic[T]):
     def __init__(
             self,
-            op: _MaysyncOp,
+            x: ta.Any,
+            args: ta.Tuple[ta.Any, ...],
+            kwargs: ta.Mapping[str, ta.Any],
     ) -> None:
-        self.op = op
+        self.x = x
+        self.args = args
+        self.kwargs = kwargs
 
     def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{id(self):x}({self.op!r}, done={self.done!r})'
+        return f'{self.__class__.__name__}@{id(self):x}({self.x!r}, done={self.done!r})'
 
     done: bool = False
     result: T
@@ -314,3 +718,23 @@ class _MaysyncFuture(ta.Generic[T]):
             raise self.error
         else:
             return self.result
+
+    def s(self) -> None:
+        if self.done:
+            return
+
+        try:
+            self.result = self.x(*self.args, **self.kwargs).s()
+        except BaseException as ex:  # noqa
+            self.error = ex
+        self.done = True
+
+    async def a(self) -> None:
+        if self.done:
+            return
+
+        try:
+            self.result = await self.x(*self.args, **self.kwargs).a()
+        except BaseException as ex:  # noqa
+            self.error = ex
+        self.done = True

omlish/subprocesses/maysyncs.py

@@ -68,7 +68,7 @@ class AbstractMaysyncSubprocesses(BaseSubprocesses, abc.ABC):
             *cmd: str,
             **kwargs: ta.Any,
     ) -> str:
-        return (await self.check_output(*cmd, **kwargs).m()).decode().strip()
+        return (await self.check_output(*cmd, **kwargs).a()).decode().strip()
 
     #
 
@@ -78,7 +78,7 @@ class AbstractMaysyncSubprocesses(BaseSubprocesses, abc.ABC):
             *cmd: str,
             **kwargs: ta.Any,
     ) -> bool:
-        if isinstance(await self.async_try_fn(self.check_call(*cmd, **kwargs).m), Exception):
+        if isinstance(await self.async_try_fn(self.check_call(*cmd, **kwargs).a), Exception):
             return False
         else:
             return True
@@ -89,7 +89,7 @@ class AbstractMaysyncSubprocesses(BaseSubprocesses, abc.ABC):
             *cmd: str,
             **kwargs: ta.Any,
     ) -> ta.Optional[bytes]:
-        if isinstance(ret := await self.async_try_fn(self.check_output(*cmd, **kwargs).m), Exception):
+        if isinstance(ret := await self.async_try_fn(self.check_output(*cmd, **kwargs).a), Exception):
             return None
         else:
             return ret
@@ -100,7 +100,7 @@ class AbstractMaysyncSubprocesses(BaseSubprocesses, abc.ABC):
             *cmd: str,
             **kwargs: ta.Any,
     ) -> ta.Optional[str]:
-        if (ret := await self.try_output(*cmd, **kwargs).m()) is None:
+        if (ret := await self.try_output(*cmd, **kwargs).a()) is None:
             return None
         else:
             return ret.decode().strip()

{omlish-0.0.0.dev409.dist-info → omlish-0.0.0.dev410.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev409
+Version: 0.0.0.dev410
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev409.dist-info → omlish-0.0.0.dev410.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=4QkSZDk0KGwNDUXL28RW4dosDTkKwvPxAM7iBzddM4g,3601
+omlish/__about__.py,sha256=4TpD9f2NLOxe8wPIx2jkab-TAgd8pW7229kNrBPdko4,3601
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -21,11 +21,10 @@ omlish/argparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse/all.py,sha256=NeeMM5MIebY7XDAHaCxUzeesEoUYwsf5i9PrBUcO1cI,1057
 omlish/argparse/cli.py,sha256=60cfq_WFLwL3YsIQxGAQ7XDi-LzNjH33RavcKdRnhUU,8737
 omlish/asyncs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/asyncs/all.py,sha256=MjW0P9K8XBrw6AaH2X_qD5Y7hEZOF0cktqFv5BDGH-k,649
-omlish/asyncs/bridge.py,sha256=QonuN2KgT7sRsmJEgRvLqtubXma9RI2xOs27X5JSQcA,10153
+omlish/asyncs/all.py,sha256=cS7dTWR8l3vF0oWYYiV9JXp0YGxOecVyCuJ2fydAPU0,526
+omlish/asyncs/bridge.py,sha256=iRUUrvw5-5YxBxhsy57TvhpM_DmH_JH1QceexkGmiBw,10129
 omlish/asyncs/buffers.py,sha256=_Ds4Aa1bUWQwQTGmcYsKLjcJ_d5HgbSkPTFrG9y-eMQ,1424
 omlish/asyncs/flavors.py,sha256=1mNxGNRVmjUHzA13K5ht8vdJv4CLEmzYTQ6BZXr1520,4866
-omlish/asyncs/sync.py,sha256=hS6VltWMkGnMgDjygls50RD_z-FBdpmlr4q8W_i0fCI,2040
 omlish/asyncs/trio.py,sha256=fmZ5b_lKdVV8NQ3euCUutWgnkqTFzSnOjvJSA_jvmrE,367
 omlish/asyncs/trio_asyncio.py,sha256=b6H5H32pB79Uz5xvWEmuhXTJgTAeKFHBHzocv_Rpt5A,1332
 omlish/asyncs/utils.py,sha256=-oaa6nheDxMOxVDTfRylWZGlyOja3UVJEV2IibJXQv4,369
@@ -426,7 +425,8 @@ omlish/iterators/iterators.py,sha256=RxW35yQ5ed8vBQ22IqpDXFx-i5JiLQdp7-pkMZXhJJ8
 omlish/iterators/recipes.py,sha256=wOwOZg-zWG9Zc3wcAxJFSe2rtavVBYwZOfG09qYEx_4,472
 omlish/iterators/tools.py,sha256=M16LXrJhMdsz5ea2qH0vws30ZvhQuQSCVFSLpRf_gTg,2096
 omlish/iterators/unique.py,sha256=BSE-eanva8byFCJi09Nt2zzTsVr8LnTqY1PIInGYRs0,1396
-omlish/lang/__init__.py,sha256=7Xe1YcE2PPgx-NI-V9VTsvUl4qZD0RPANxuDv9ddRXg,7231
+omlish/lang/__init__.py,sha256=AiFCnMJZo2lXrEOqgU29UAjk8Ovnuc_lwMYuLy6Y748,7393
+omlish/lang/asyncs.py,sha256=HQrf8oaaZnUYbFwIiVLYvsEshJarMvRNHZ3VN-RyqLY,1789
 omlish/lang/attrs.py,sha256=zFiVuGVOq88x45464T_LxDa-ZEq_RD9zJLq2zeVEBDc,5105
 omlish/lang/casing.py,sha256=cFUlbDdXLhwnWwcYx4qnM5c4zGX7hIRUfcjiZbxUD28,4636
 omlish/lang/clsdct.py,sha256=HAGIvBSbCefzRjXriwYSBLO7QHKRv2UsE78jixOb-fA,1828
@@ -441,7 +441,7 @@ omlish/lang/functions.py,sha256=aLdxhmqG0Pj9tBgsKdoCu_q15r82WIkNqDDSPQU19L8,5689
 omlish/lang/generators.py,sha256=a4D5HU_mySs2T2z3xCmE_s3t4QJkj0YRrK4-hhpGd0A,5197
 omlish/lang/iterables.py,sha256=y1SX2Co3VsOeX2wlfFF7K3rwLvF7Dtre7VY6EpfwAwA,3338
 omlish/lang/lazyglobals.py,sha256=G1hwpyIgM4PUkVJ_St3K-EdQkHQdWpFOcXao6I5LwyY,1435
-omlish/lang/maysyncs.py,sha256=kULOW2M9PFhLd1TdtmGGQstPgrJpl--JUv9FOHWl4f8,894
+omlish/lang/maysyncs.py,sha256=Fa6jk8v0JQzoGvg7UbpCQXzrvWUuRqBG9XZCikbYvoQ,1646
 omlish/lang/objects.py,sha256=eOhFyFiwvxqpbLs5QTEkXU3rdSt_tQXDgHoWF5SA28E,6119
 omlish/lang/outcomes.py,sha256=0PqxoKaGbBXU9UYZ6AE2QSq94Z-gFDt6wYdp0KomNQw,8712
 omlish/lang/overrides.py,sha256=IBzK6ljfLX6TLgIyKTSjhqTLcuKRkQNVtEOnBLS4nuA,2095
@@ -490,7 +490,7 @@ omlish/lite/json.py,sha256=m0Ce9eqUZG23-H7-oOp8n1sf4fzno5vtK4AK_4Vc-Mg,706
 omlish/lite/logs.py,sha256=CWFG0NKGhqNeEgryF5atN2gkPYbUdTINEw_s1phbINM,51
 omlish/lite/marshal.py,sha256=K_wnZwfC8cftGILyE3RlmzQEYuZOfzkMLKey41zuwtM,20296
 omlish/lite/maybes.py,sha256=0p_fzb6yiOjEpvMKaQ53Q6CH1VPW1or7v7Lt1JIKcgM,4359
-omlish/lite/maysyncs.py,sha256=MT3zF5kQ5rNlWU7db9Q_uXSM8K2C8LK85PIgdBsJyGE,7251
+omlish/lite/maysyncs.py,sha256=XZ-zbK3bES8Al6--lYcvGGhYKqfVg1zoHJ6GCwLbiv4,19663
 omlish/lite/pycharm.py,sha256=FRHGcCDo42UzZXqNwW_DkhI-6kb_CmJKPiQ8F6mYkLA,1174
 omlish/lite/reflect.py,sha256=gI-Qlws9V-jND7kvCQFaIhBFrndVpDsikTQ7C6U2z3w,2434
 omlish/lite/reprs.py,sha256=2Bc7ukhKvYNTKmxPIuv9glZIph13C37y_W4fg9pBnu8,2006
@@ -765,7 +765,7 @@ omlish/subprocesses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 omlish/subprocesses/asyncs.py,sha256=G9wj275s3r0ueftHFl73Lt4kMRBc2hJOKcoJQCDlBms,2663
 omlish/subprocesses/base.py,sha256=r60N3ad4ooSvdgFmT94L_xZEy7FMbMX6JcG2VgpHo6w,6139
 omlish/subprocesses/editor.py,sha256=xBrd7gY0akhRfDIBK5YIBrYMHECtl_8r499iKViyfpQ,2634
-omlish/subprocesses/maysyncs.py,sha256=XWWVC-jyjVJLcT-nWMZFf4jUQesRuBWWVhmwcG_fUWE,3818
+omlish/subprocesses/maysyncs.py,sha256=sHReoZhT7RRlON_FjcbbHYLvOqK7nyWfkGi6fI26SGY,3818
 omlish/subprocesses/run.py,sha256=8EeMm2FdNEFmEmbhhzJyHXASUhCCMMRN_-8ybqFhgLI,4378
 omlish/subprocesses/sync.py,sha256=L-ZNj9RrZd69XjlKrXjt-EJ-XUpQF8E35Mh3b3SI3vc,3671
 omlish/subprocesses/utils.py,sha256=v5uEzxmbmRvXwOl_0DtBa5Il6yITKYRgmVSGHcLsT4o,402
@@ -909,9 +909,9 @@ omlish/typedvalues/marshal.py,sha256=AtBz7Jq-BfW8vwM7HSxSpR85JAXmxK2T0xDblmm1HI0
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev409.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev409.dist-info/METADATA,sha256=fCzoIaINPTeVtCOvdUmzuUWQqKIGW40xgEmeKO4bIxg,18881
-omlish-0.0.0.dev409.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev409.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev409.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev409.dist-info/RECORD,,
+omlish-0.0.0.dev410.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev410.dist-info/METADATA,sha256=tqNKk_ovprTJtbpkIsi_jZRS44y4hTlBreu5pTxzTRs,18881
+omlish-0.0.0.dev410.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev410.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev410.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev410.dist-info/RECORD,,

omlish/asyncs/sync.py

@@ -1,80 +0,0 @@
-"""
-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?
- - move to lang
-
-https://github.com/sqlalchemy/sqlalchemy/blob/1e75c189da721395bc8c2d899c722a5b9a170404/lib/sqlalchemy/util/_concurrency_py3k.py#L83
-"""
-import functools
-import typing as ta
-
-
-T = ta.TypeVar('T')
-
-
-##
-
-
-def sync_await(fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
-    ret = missing = object()
-
-    async def gate():
-        nonlocal ret
-        ret = await fn(*args, **kwargs)  # type: ignore
-
-    cr = gate()
-    try:
-        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')
-    finally:
-        cr.close()
-
-    return ret  # type: ignore
-
-
-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