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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev408'
-__revision__ = '5d4bd94d19abed3d89f070bc4748ab16aed6c9dc'
+__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,
@@ -237,7 +244,7 @@ from .imports.proxyinit import (  # noqa
     auto_proxy_init,
 )
 
-from .imports.resolution import (  # noqa
+from .imports.resolving import (  # noqa
     can_import,
     get_real_module_name,
     resolve_import_name,
@@ -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/imports/conditional.py

@@ -1,6 +1,6 @@
 import sys
 
-from .resolution import resolve_import_name
+from .resolving import resolve_import_name
 
 
 ##

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)