omlish 0.0.0.dev386__py3-none-any.whl → 0.0.0.dev387__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev386'
-__revision__ = 'e2f1a23f62c35a30fdb5a509f65af87289ceafef'
+__version__ = '0.0.0.dev387'
+__revision__ = '169f8b630b04ef6cf83c18d134c799c83f033818'
 
 
 #

omlish/lang/__init__.py

@@ -250,13 +250,12 @@ from .iterables import (  # noqa
     take,
 )
 
-from .maysync_ import (  # noqa
-    maysync_op,
+from .maysyncs import (  # noqa
+    MaysyncableP,
 
-    maysync_yield,
+    make_maysync,
 
-    maysync_wrap,
-    a_maysync_wrap,
+    maysync,
 )
 
 from .objects import (  # noqa
@@ -393,21 +392,13 @@ from ..lite.maybes import (  # noqa
     Maybe,
 )
 
-from ..lite.maysync import (  # noqa
-    MaysyncGen,
-    MaysyncFn,
-
-    MaysyncOp,
-
-    maysync,
-    a_maysync,
-
-    MaysyncRunnable,
-)
-
 empty = Maybe.empty
 just = Maybe.just
 
+from ..lite.maysyncs import (  # noqa
+    Maysyncable,
+)
+
 from ..lite.reprs import (  # noqa
     AttrRepr,
     attr_repr,

omlish/lang/maysyncs.py

@@ -0,0 +1,41 @@
+import typing as ta
+
+from ..lite.maysyncs import make_maysync as _make_maysync
+from ..lite.maysyncs import maysync as _maysync
+
+
+T_co = ta.TypeVar('T_co', covariant=True)
+P = ta.ParamSpec('P')
+
+
+##
+
+
+class MaysyncableP(ta.Protocol[P, T_co]):
+    @property
+    def s(self) -> ta.Callable[P, T_co]:
+        ...
+
+    @property
+    def a(self) -> ta.Callable[P, ta.Awaitable[T_co]]:
+        ...
+
+    @property
+    def m(self) -> ta.Callable[P, ta.Awaitable[T_co]]:
+        ...
+
+
+def make_maysync(
+        s: ta.Callable[P, T_co],
+        a: ta.Callable[P, ta.Awaitable[T_co]],
+) -> MaysyncableP[P, T_co]:
+    return ta.cast('MaysyncableP[P, T_co]', _make_maysync(
+        s,
+        a,
+    ))
+
+
+def maysync(m: ta.Callable[P, ta.Awaitable[T_co]]) -> MaysyncableP[P, T_co]:
+    return ta.cast('MaysyncableP[P, T_co]', _maysync(
+        m,
+    ))

omlish/lite/args.py

@@ -41,3 +41,8 @@ class Args:
             return args(fn)
         else:
             return fn()
+
+    EMPTY: ta.ClassVar['Args']
+
+
+Args.EMPTY = Args()

omlish/lite/maysyncs.py

@@ -0,0 +1,184 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import abc
+import dataclasses as dc
+import functools
+import typing as ta
+
+from .args import Args
+from .check import check
+
+
+T = ta.TypeVar('T')
+
+_MaysyncGen = ta.Generator['_MaysyncOp', ta.Any, T]  # ta.TypeAlias
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class Maysyncable(abc.ABC, ta.Generic[T]):
+    @abc.abstractmethod
+    def s(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def a(self, *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[T]:
+        raise NotImplementedError
+
+    @ta.final
+    def m(self, *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[T]:
+        return _MaysyncFuture(_MaysyncOp(self, Args(*args, **kwargs)))
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class _FnMaysyncable(Maysyncable[T]):
+    s: ta.Callable[..., T]
+    a: ta.Callable[..., ta.Awaitable[T]]
+
+    def __post_init__(self) -> None:
+        check.not_none(self.s)
+        check.not_none(self.a)
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+
+_FnMaysyncable.__abstractmethods__ = frozenset()
+
+
+def make_maysync(
+        s: ta.Callable[..., T],
+        a: ta.Callable[..., ta.Awaitable[T]],
+) -> Maysyncable[T]:
+    return _FnMaysyncable(
+        s,
+        a,
+    )
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class _MgMaysyncable(Maysyncable[T]):
+    mg: ta.Callable[..., _MaysyncGen[T]]
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    def s(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        g = self.mg(*args, **kwargs)
+
+        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:
+                return ex.value
+
+            i = None
+            e = None
+
+            mo = check.isinstance(o, _MaysyncOp)
+            try:
+                i = mo.a(mo.mx.s)
+            except BaseException as ex:  # noqa
+                e = ex
+
+    async def a(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        g = self.mg(*args, **kwargs)
+
+        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:
+                return ex.value
+
+            i = None
+            e = None
+
+            mo = check.isinstance(o, _MaysyncOp)
+            try:
+                i = await mo.a(mo.mx.a)
+            except BaseException as ex:  # noqa
+                e = ex
+
+
+def maysync(m: ta.Callable[..., ta.Awaitable[T]]) -> Maysyncable[T]:
+    @functools.wraps(m)
+    def mg_fn(*args, **kwargs):
+        a = m(*args, **kwargs).__await__()
+
+        try:
+            g = iter(a)
+            try:
+                while True:
+                    try:
+                        o = g.send(None)
+                    except StopIteration as e:
+                        return e.value
+
+                    f = check.isinstance(o, _MaysyncFuture)
+                    if not f.done:
+                        try:
+                            f.result = yield f.op
+                        except BaseException as e:  # noqa
+                            f.error = e
+                        f.done = True
+
+            finally:
+                g.close()
+
+        finally:
+            a.close()
+
+    return _MgMaysyncable(mg_fn)
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class _MaysyncOp:
+    mx: Maysyncable
+    a: Args
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class _MaysyncFuture(ta.Generic[T]):
+    op: _MaysyncOp
+
+    done: bool = False
+    error: ta.Optional[BaseException] = None
+    result: ta.Optional[T] = None
+
+    def __await__(self):
+        if not self.done:
+            yield self
+        if not self.done:
+            raise RuntimeError("await wasn't used with event future")
+        if self.error is not None:
+            raise self.error
+        return self.result

{omlish-0.0.0.dev386.dist-info → omlish-0.0.0.dev387.dist-info}/METADATA

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

{omlish-0.0.0.dev386.dist-info → omlish-0.0.0.dev387.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=aT8yZ-Zh-9wfHl5Ym5ouiWC1i0cy7Q7RlhzavB6VLPI,8587
-omlish/__about__.py,sha256=BY-Xe7WExFumskKfjUB2aFnO0UT88dNaM5Lzw8-VF1c,3543
+omlish/__about__.py,sha256=1JXviS8ZhIT4Fi_DnSuQcb5P_uSRCpOk-GoDo5m01hs,3543
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -420,7 +420,7 @@ 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=Nw0pSaNEcHAkve0ugfLPvJcirDOn9ECyC5wIL8JlJKI,1395
-omlish/lang/__init__.py,sha256=GRMthX6oFZ4FdGjY5FvP30NT0DZck0CzaRjG2uPKrWM,6867
+omlish/lang/__init__.py,sha256=gNF9vQCR1y1qICSaTfh-eR5d8H_kCjuHwxlGMbjUc9I,6763
 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
@@ -435,7 +435,7 @@ omlish/lang/functions.py,sha256=aLdxhmqG0Pj9tBgsKdoCu_q15r82WIkNqDDSPQU19L8,5689
 omlish/lang/generators.py,sha256=a4D5HU_mySs2T2z3xCmE_s3t4QJkj0YRrK4-hhpGd0A,5197
 omlish/lang/imports.py,sha256=y9W9Y-d_cQ35QCLuSIPoa6vnEqSErFCz8b-34IH128U,10552
 omlish/lang/iterables.py,sha256=y1SX2Co3VsOeX2wlfFF7K3rwLvF7Dtre7VY6EpfwAwA,3338
-omlish/lang/maysync_.py,sha256=ffabm266xc-nqH-3lM0tfyISAX7SO1FBjlIziT4sPIE,1093
+omlish/lang/maysyncs.py,sha256=QXI_I7_yxgRugXYfH8drmLIdcEUmhPrM6hDJwxjpqT4,840
 omlish/lang/objects.py,sha256=ZsibJwNp1EXorbaObm9TlCNtuuM65snCmVb7H4_llqI,6116
 omlish/lang/outcomes.py,sha256=0PqxoKaGbBXU9UYZ6AE2QSq94Z-gFDt6wYdp0KomNQw,8712
 omlish/lang/overrides.py,sha256=IBzK6ljfLX6TLgIyKTSjhqTLcuKRkQNVtEOnBLS4nuA,2095
@@ -466,7 +466,7 @@ omlish/lifecycles/manager.py,sha256=92s1IH_gDP25PM5tFuPMP2hD_6s5fPi_VzZiDS5549g,
 omlish/lifecycles/states.py,sha256=6gTdY3hn7-1sJ60lA3GeMx5RVKvXtFBBXE4KEjoO1Hs,1297
 omlish/lifecycles/transitions.py,sha256=3IFdWGtAeoy3XRlIyW7yCKV4e4Iof9ytkqklGMRFYQs,1944
 omlish/lite/__init__.py,sha256=cyZEpGob7XjU8DohyNxVe5CQRk4CQ5vrHL42OdhQb8w,148
-omlish/lite/args.py,sha256=226ah28AjJKwG9X5dV6bxbuce0UF87MsonjHXh0eLtg,924
+omlish/lite/args.py,sha256=ILJXAiN3KjIoJwY42aKpYPngUdxHIy9ssVIExFVz3fE,978
 omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 omlish/lite/check.py,sha256=ytCkwZoKfOlJqylL-AGm8C2WfsWJd2q3kFbnZCzX3_M,13844
 omlish/lite/configs.py,sha256=4-1uVxo-aNV7vMKa7PVNhM610eejG1WepB42-Dw2xQI,914
@@ -478,7 +478,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=JD_8ox5-yeIo7MZ6iipCdiVxx33So52M02AtvFlRGC8,20392
 omlish/lite/maybes.py,sha256=0p_fzb6yiOjEpvMKaQ53Q6CH1VPW1or7v7Lt1JIKcgM,4359
-omlish/lite/maysync.py,sha256=dwiJE5y8h1nBnrYsfuaxITGpik0RlhpAF8qpba_Z-1g,1537
+omlish/lite/maysyncs.py,sha256=VyzjbjG7GiQGq1GIFyldrH7R6D4HlpkKGx-PSkbnlW0,4115
 omlish/lite/pycharm.py,sha256=FRHGcCDo42UzZXqNwW_DkhI-6kb_CmJKPiQ8F6mYkLA,1174
 omlish/lite/reflect.py,sha256=pzOY2PPuHH0omdtglkN6DheXDrGopdL3PtTJnejyLFU,2189
 omlish/lite/reprs.py,sha256=Tiqf_ciD8FfS0ury7FcJ5G21yY342fW0vPacYlb8EO4,2014
@@ -894,9 +894,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.dev386.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev386.dist-info/METADATA,sha256=VFOznLJPLfiKuYUYuRrJ3wFrH3TEMDQAqH_8H8RQY_g,18825
-omlish-0.0.0.dev386.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev386.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev386.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev386.dist-info/RECORD,,
+omlish-0.0.0.dev387.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev387.dist-info/METADATA,sha256=zhW4aKIRiJ7u6QaBhvG0lt3oNjw4lcjik82VF-mp_SA,18825
+omlish-0.0.0.dev387.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev387.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev387.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev387.dist-info/RECORD,,

omlish/lang/maysync_.py

@@ -1,53 +0,0 @@
-import functools
-import typing as ta
-
-from ..lite.maysync import MaysyncGen
-from ..lite.maysync import MaysyncOp
-from ..lite.maysync import a_maysync
-from ..lite.maysync import maysync
-
-
-T = ta.TypeVar('T')
-P = ta.ParamSpec('P')
-
-
-##
-
-
-def maysync_op(
-        fn: ta.Callable[P, T],
-        a_fn: ta.Callable[P, ta.Awaitable[T]],
-) -> MaysyncOp[T]:
-    return MaysyncOp(
-        fn,
-        a_fn,
-    )
-
-
-##
-
-
-def maysync_yield(
-        fn: ta.Callable[P, T],
-        a_fn: ta.Callable[P, ta.Awaitable[T]],
-) -> ta.Callable[P, ta.Generator[ta.Any, ta.Any, T]]:
-    def inner(*args, **kwargs):
-        return (yield MaysyncOp(fn, a_fn)(*args, **kwargs))
-    return inner
-
-
-##
-
-
-def maysync_wrap(fn: ta.Callable[P, MaysyncGen[T]]) -> ta.Callable[P, T]:
-    @functools.wraps(fn)
-    def inner(*args, **kwargs):
-        return maysync(fn, *args, **kwargs)
-    return inner
-
-
-def a_maysync_wrap(fn: ta.Callable[P, MaysyncGen[T]]) -> ta.Callable[P, ta.Awaitable[T]]:
-    @functools.wraps(fn)
-    async def inner(*args, **kwargs):
-        return await a_maysync(fn, *args, **kwargs)
-    return inner

omlish/lite/maysync.py

@@ -1,74 +0,0 @@
-# ruff: noqa: UP045
-import abc
-import dataclasses as dc
-import typing as ta
-
-from .args import Args
-
-
-T = ta.TypeVar('T')
-
-
-MaysyncGen = ta.Generator['MaysyncOp', ta.Any, T]  # ta.TypeAlias
-MaysyncFn = ta.Callable[..., MaysyncGen[T]]  # ta.TypeAlias
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class MaysyncOp(ta.Generic[T]):
-    fn: ta.Callable[..., T]
-    a_fn: ta.Callable[..., ta.Awaitable[T]]
-
-    args: ta.Optional[Args] = None
-
-    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> 'MaysyncOp[T]':
-        if self.args is not None:
-            raise RuntimeError('Args already bound')
-        return dc.replace(self, args=Args(*args, **kwargs))
-
-
-maysync_op = MaysyncOp
-
-
-##
-
-
-def maysync(fn: MaysyncFn[T], *args: ta.Any, **kwargs: ta.Any) -> T:
-    g = fn(*args, **kwargs)
-    i = None
-    while True:
-        try:
-            o = g.send(i)
-        except StopIteration as e:
-            return e.value
-        i = Args.call(o.fn, o.args)
-
-
-async def a_maysync(fn: MaysyncFn[T], *args: ta.Any, **kwargs: ta.Any) -> T:
-    g = fn(*args, **kwargs)
-    i = None
-    while True:
-        try:
-            o = g.send(i)
-        except StopIteration as e:
-            return e.value
-        i = await Args.call(o.a_fn, o.args)
-
-
-##
-
-
-class MaysyncRunnable(abc.ABC, ta.Generic[T]):
-    @abc.abstractmethod
-    def m_run(self) -> MaysyncGen[T]:
-        raise NotImplementedError
-
-    @ta.final
-    def run(self) -> T:
-        return maysync(self.m_run)
-
-    @ta.final
-    async def a_run(self) -> T:
-        return await a_maysync(self.m_run)