omlish 0.0.0.dev411__py3-none-any.whl → 0.0.0.dev413__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev411'
-__revision__ = 'ab397888a161157384b42de969a8c743c5a2c4b6'
+__version__ = '0.0.0.dev413'
+__revision__ = '3a75442fb3c6056a588c83a888a2f2792d35a3ab'
 
 
 #
@@ -105,7 +105,7 @@ class Project(ProjectBase):
 
             'apsw ~= 3.50',
 
-            'sqlean.py ~= 3.49',
+            'sqlean.py ~= 3.50',
 
             'duckdb ~= 1.3',
         ],

omlish/asyncs/bridge.py

@@ -70,7 +70,7 @@ def trivial_s_to_a(fn):
 
 def trivial_a_to_s(fn):
     def inner(*args, **kwargs):
-        return lang.sync_await(fn, *args, **kwargs)
+        return lang.sync_await(fn(*args, **kwargs))
     return inner
 
 

omlish/lang/__init__.py

@@ -171,6 +171,8 @@ from .descriptors import (  # noqa
     decorator,
     is_method_descriptor,
     item_property,
+    unwrap_callable,
+    unwrap_callable_with_partials,
     unwrap_func,
     unwrap_func_with_partials,
     unwrap_method_descriptors,
@@ -280,12 +282,11 @@ from .lazyglobals import (  # noqa
 )
 
 from .maysyncs import (  # noqa
-    MaysyncFn,
-    MaysyncGeneratorFn,
-
+    make_maysync_fn,
+    make_maysync_generator_fn,
     make_maysync,
+
     make_maysync_from_sync,
-    maysync,
 )
 
 from .objects import (  # noqa
@@ -426,12 +427,23 @@ empty = Maybe.empty
 just = Maybe.just
 
 from ..lite.maysyncs import (  # noqa
+    mark_maysync,
+    is_maysync,
+
+    AnyMaysyncFn,
+
+    MaywaitableAlreadyConsumedError,
+    AnyMaywaitable,
+
+    MaysyncFn,
     Maywaitable,
+
+    MaysyncGeneratorFn,
     MaysyncGenerator,
 
-    Maysync_,
-    MaysyncFn_,
-    MaysyncGeneratorFn_,
+    is_running_maysync,
+
+    run_maysync,
 )
 
 from ..lite.reprs import (  # noqa

omlish/lang/asyncs.py

@@ -2,29 +2,24 @@ 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,
+        ai: ta.AsyncIterable[T],
 ) -> 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)]
+    return [v async for v in ai]
 
 
 ##
 
 
 def sync_await(
-        fn: ta.Callable[P, ta.Awaitable[T]],
-        *args: P.args,
-        **kwargs: P.kwargs,
+        aw: ta.Awaitable[T],
 ) -> T:
     """
     Allows for the synchronous execution of async functions which will never actually *externally* await anything. These
@@ -37,7 +32,7 @@ def sync_await(
     async def gate():
         nonlocal ret
 
-        ret = await fn(*args, **kwargs)
+        ret = await aw
 
     cr = gate()
     try:
@@ -56,9 +51,7 @@ def sync_await(
 
 
 def sync_async_list(
-        fn: ta.Callable[P, ta.AsyncIterator[T]],
-        *args: P.args,
-        **kwargs: P.kwargs,
+        ai: ta.AsyncIterable[T],
 ) -> list[T]:
     """
     Uses `sync_await` to synchronously read the full contents of a function call returning an async iterator, given that
@@ -70,9 +63,9 @@ def sync_async_list(
     async def inner():
         nonlocal lst
 
-        lst = [v async for v in fn(*args, **kwargs)]
+        lst = [v async for v in ai]
 
-    sync_await(inner)
+    sync_await(inner())
 
     if not isinstance(lst, list):
         raise TypeError(lst)

omlish/lang/descriptors.py

@@ -92,6 +92,20 @@ def unwrap_func(fn: ta.Any) -> ta.Any:
 ##
 
 
+def unwrap_callable_with_partials(obj: ta.Any) -> tuple[ta.Any, list[functools.partial]]:
+    if isinstance(obj, type):
+        obj = obj.__call__
+    return unwrap_func_with_partials(obj)
+
+
+def unwrap_callable(obj: ta.Any) -> ta.Any:
+    uw, _ = unwrap_callable_with_partials(obj)
+    return uw
+
+
+##
+
+
 def update_wrapper(
         wrapper: T,
         wrapped: ta.Any,

omlish/lang/maysyncs.py

@@ -1,11 +1,8 @@
 import typing as ta
 
-from ..lite.maysyncs import MaysyncGenerator
-from ..lite.maysyncs import Maywaitable
+from ..lite.maysyncs import MaysyncFn
+from ..lite.maysyncs import MaysyncGeneratorFn
 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
 
 
@@ -15,61 +12,61 @@ I = ta.TypeVar('I')
 
 P = ta.ParamSpec('P')
 
-MaysyncFn: ta.TypeAlias = ta.Callable[P, Maywaitable[T]]
-MaysyncGeneratorFn: ta.TypeAlias = ta.Callable[P, MaysyncGenerator[O, I]]
-
 
 ##
 
 
-def make_maysync(
+def make_maysync_fn(
         s: ta.Callable[P, T],
         a: ta.Callable[P, ta.Awaitable[T]],
-) -> MaysyncFn[P, T]:
-    return ta.cast('MaysyncFn[P, T]', _make_maysync(
-        s,
-        a,
-    ))
-
-
-def make_maysync_from_sync(
-        s: ta.Callable[P, T],
-        a: ta.Callable[P, ta.Awaitable[T]] | None = None,
-) -> MaysyncFn[P, T]:
-    return ta.cast('MaysyncFn[P, T]', _make_maysync(
-        s,
-        a if a is not None else as_async(s),
-    ))
+) -> ta.Callable[P, ta.Awaitable[T]]:
+    """Constructs a MaysyncFn from a (sync, async) function pair."""
 
+    return MaysyncFn(s, a)
 
-##
 
+def make_maysync_generator_fn(
+        s: ta.Callable[P, ta.Generator[O, I]],
+        a: ta.Callable[P, ta.AsyncGenerator[O, I]],
+) -> ta.Callable[P, ta.AsyncGenerator[O, I]]:
+    """Constructs a MaysyncGeneratorFn from a (sync, async) generator function pair."""
 
-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))
+    return MaysyncGeneratorFn(s, a)
 
 
 @ta.overload
-def maysync(
-        m: ta.Callable[P, ta.Awaitable[T]],
-) -> MaysyncFn[P, T]:
+def make_maysync(
+        s: ta.Callable[P, T],
+        a: ta.Callable[P, ta.Awaitable[T]],
+) -> ta.Callable[P, ta.Awaitable[T]]:
     ...
 
 
 @ta.overload
-def maysync(
-        m: ta.Callable[P, ta.AsyncGenerator[O, I]],
-) -> MaysyncGeneratorFn[P, O, I]:
+def make_maysync(
+        s: ta.Callable[P, ta.Generator[O, I]],
+        a: ta.Callable[P, ta.AsyncGenerator[O, I]],
+) -> ta.Callable[P, ta.AsyncGenerator[O, I]]:
     ...
 
 
-def maysync(m):
-    return _maysync(m)
+def make_maysync(s, a):
+    """
+    Constructs a MaysyncFn or MaysyncGeneratorFn from a (sync, async) function pair, using `inspect.isasyncgenfunction`
+    to determine the type.
+    """
+
+    return _make_maysync(s, a)
+
+
+##
+
+
+def make_maysync_from_sync(
+        s: ta.Callable[P, T],
+        a: ta.Callable[P, ta.Awaitable[T]] | None = None,
+) -> ta.Callable[P, ta.Awaitable[T]]:
+    return _make_maysync(
+        s,
+        a if a is not None else as_async(s),
+    )