omlish 0.0.0.dev387__tar.gz → 0.0.0.dev388__tar.gz

{omlish-0.0.0.dev387/omlish.egg-info → omlish-0.0.0.dev388}/PKG-INFO

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

{omlish-0.0.0.dev387 → omlish-0.0.0.dev388}/omlish/__about__.py

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

{omlish-0.0.0.dev387 → omlish-0.0.0.dev388}/omlish/lang/__init__.py

@@ -251,10 +251,9 @@ from .iterables import (  # noqa
 )
 
 from .maysyncs import (  # noqa
-    MaysyncableP,
+    MaysyncP,
 
     make_maysync,
-
     maysync,
 )
 
@@ -396,7 +395,9 @@ empty = Maybe.empty
 just = Maybe.just
 
 from ..lite.maysyncs import (  # noqa
-    Maysyncable,
+    Maywaitable,
+    Maysync,
+    Maysync_,
 )
 
 from ..lite.reprs import (  # noqa

omlish-0.0.0.dev388/omlish/lang/maysyncs.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from ..lite.maysyncs import Maywaitable
+from ..lite.maysyncs import make_maysync as _make_maysync
+from ..lite.maysyncs import maysync as _maysync
+from .functions import as_async
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+MaysyncP: ta.TypeAlias = ta.Callable[P, Maywaitable[T]]
+
+
+##
+
+
+def make_maysync(
+        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(
+        s,
+        a if a is not None else as_async(s),
+    ))
+
+
+def maysync(m: ta.Callable[P, ta.Awaitable[T]]) -> MaysyncP[P, T]:
+    return ta.cast('MaysyncP[P, T]', _maysync(
+        m,
+    ))

omlish-0.0.0.dev388/omlish/lite/maysyncs.py

@@ -0,0 +1,262 @@
+# ruff: noqa: UP045
+# @omlish-lite
+"""
+TODO:
+ - __del__
+"""
+import abc
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+T_co = ta.TypeVar('T_co', covariant=True)
+_X = ta.TypeVar('_X')
+
+_MaysyncGen = ta.Generator['_MaysyncOp', ta.Any, T]  # ta.TypeAlias
+
+
+##
+
+
+class Maywaitable(ta.Protocol[T_co]):
+    def s(self) -> T_co:
+        ...
+
+    def a(self) -> ta.Awaitable[T_co]:
+        ...
+
+    def m(self) -> ta.Awaitable[T_co]:
+        ...
+
+
+Maysync = ta.Callable[..., Maywaitable[T]]  # ta.TypeAlias  # omlish-amalg-typing-no-move
+
+
+class Maysync_(abc.ABC):  # noqa
+    pass
+
+
+##
+
+
+class _Maywaitable(abc.ABC, ta.Generic[_X, T]):
+    @ta.final
+    def __init__(
+            self,
+            x: _X,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        self.x = x
+        self.args = args
+        self.kwargs = kwargs
+
+    @ta.final
+    def m(self) -> ta.Awaitable[T]:
+        return _MaysyncFuture(_MaysyncOp(
+            ta.cast(ta.Any, self.x),
+            *self.args,
+            **self.kwargs,
+        ))
+
+
+##
+
+
+@ta.final
+class _FnMaysync(Maysync_, ta.Generic[T]):
+    def __init__(
+            self,
+            s: ta.Callable[..., T],
+            a: ta.Callable[..., ta.Awaitable[T]],
+    ) -> None:
+        if s is None:
+            raise TypeError(s)
+        if a is None:
+            raise TypeError(a)
+        self.s = s
+        self.a = a
+
+    def __get__(self, instance, owner=None):
+        return _FnMaysync(
+            self.s.__get__(instance, owner),  # noqa
+            self.a.__get__(instance, owner),  # noqa
+        )
+
+    def __call__(self, *args, **kwargs):
+        return _FnMaywaitable(self, *args, **kwargs)
+
+
+@ta.final
+class _FnMaywaitable(_Maywaitable[_FnMaysync[T], T]):
+    def s(self) -> T:
+        return self.x.s(*self.args, **self.kwargs)
+
+    async def a(self) -> T:
+        return await self.x.a(*self.args, **self.kwargs)
+
+
+def make_maysync(
+        s: ta.Callable[..., T],
+        a: ta.Callable[..., ta.Awaitable[T]],
+) -> Maysync[T]:
+    return _FnMaysync(s, a)
+
+
+##
+
+
+@ta.final
+class _MgMaysync(Maysync_, ta.Generic[T]):
+    def __init__(
+            self,
+            mg: ta.Callable[..., _MaysyncGen[T]],
+    ) -> None:
+        self.mg = mg
+
+    def __get__(self, instance, owner=None):
+        return _MgMaysync(
+            self.mg.__get__(instance, owner),  # noqa
+        )
+
+    def __call__(self, *args, **kwargs):
+        return _MgMaywaitable(self, *args, **kwargs)
+
+
+@ta.final
+class _MgMaywaitable(_Maywaitable[_MgMaysync[T], T]):
+    def s(self) -> T:
+        g = self.x.mg(*self.args, **self.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
+
+            if not isinstance(o, _MaysyncOp):
+                raise TypeError(o)
+            try:
+                i = o.x(*o.args, **o.kwargs).s()
+            except BaseException as ex:  # noqa
+                e = ex
+
+            del o
+
+    async def a(self) -> T:
+        g = self.x.mg(*self.args, **self.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
+
+            if not isinstance(o, _MaysyncOp):
+                raise TypeError(o)
+            try:
+                i = await o.x(*o.args, **o.kwargs).a()
+            except BaseException as ex:  # noqa
+                e = ex
+
+            del o
+
+
+@ta.final
+class _MgMaysyncFn:
+    def __init__(self, m):
+        self.m = m
+
+        functools.update_wrapper(self, m)
+
+    def __get__(self, instance, owner=None):
+        return _MgMaysyncFn(
+            self.m.__get__(instance, owner),
+        )
+
+    def __call__(self, *args, **kwargs):
+        a = self.m(*args, **kwargs).__await__()
+        try:
+            g = iter(a)
+            try:
+                while True:
+                    try:
+                        o = g.send(None)
+                    except StopIteration as e:
+                        return e.value
+
+                    if not isinstance(o, _MaysyncFuture):
+                        raise TypeError(o)
+                    if not o.done:
+                        try:
+                            o.result = yield o.op
+                        except BaseException as e:  # noqa
+                            o.error = e
+                        o.done = True
+
+            finally:
+                g.close()
+
+        finally:
+            a.close()
+
+
+def maysync(m: ta.Callable[..., ta.Awaitable[T]]) -> Maysync[T]:
+    return _MgMaysync(_MgMaysyncFn(m))
+
+
+##
+
+
+@ta.final
+class _MaysyncOp:
+    def __init__(
+            self,
+            x: Maysync[T],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        self.x = x
+        self.args = args
+        self.kwargs = kwargs
+
+
+@ta.final
+class _MaysyncFuture(ta.Generic[T]):
+    def __init__(
+            self,
+            op: _MaysyncOp,
+    ) -> None:
+        self.op = op
+
+    done: bool = False
+    result: ta.Optional[T] = None
+    error: ta.Optional[BaseException] = 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.dev387 → omlish-0.0.0.dev388}/omlish/subprocesses/async_.py

@@ -13,7 +13,7 @@ from .run import SubprocessRunOutput
 ##
 
 
-class AbstractAsyncSubprocesses(BaseSubprocesses):
+class _AbstractAsyncSubprocesses(BaseSubprocesses):
     @abc.abstractmethod
     async def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
         raise NotImplementedError
@@ -95,3 +95,7 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             return None
         else:
             return ret.decode().strip()
+
+
+class AbstractAsyncSubprocesses(_AbstractAsyncSubprocesses, abc.ABC):
+    pass

omlish-0.0.0.dev388/omlish/subprocesses/maysync.py

@@ -0,0 +1,52 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+import abc
+import sys
+import typing as ta
+
+from ..lite.maysyncs import make_maysync
+from .async_ import AbstractAsyncSubprocesses
+from .async_ import _AbstractAsyncSubprocesses
+from .run import SubprocessRun
+from .run import SubprocessRunOutput
+from .sync import AbstractSubprocesses
+
+
+##
+
+
+class AbstractMaysyncSubprocesses(_AbstractAsyncSubprocesses, abc.ABC):
+    pass
+
+
+##
+
+
+class MaysyncSubprocesses(AbstractMaysyncSubprocesses):
+    def __init__(
+            self,
+            subprocesses: AbstractSubprocesses,
+            async_subprocesses: AbstractAsyncSubprocesses,
+    ) -> None:
+        super().__init__()
+
+        self._subprocesses = subprocesses
+        self._async_subprocesses = async_subprocesses
+
+    async def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
+        return await make_maysync(
+            self._subprocesses.run,
+            self._async_subprocesses.run,
+        )(run).m()
+
+    async def check_call(self, *cmd: str, stdout: ta.Any = sys.stderr, **kwargs: ta.Any) -> None:
+        return await make_maysync(
+            self._subprocesses.check_call,
+            self._async_subprocesses.check_call,
+        )(*cmd, **kwargs).m()
+
+    async def check_output(self, *cmd: str, **kwargs: ta.Any) -> bytes:
+        return await make_maysync(
+            self._subprocesses.check_output,
+            self._async_subprocesses.check_output,
+        )(*cmd, **kwargs).m()

{omlish-0.0.0.dev387 → omlish-0.0.0.dev388}/omlish/subprocesses/run.py

@@ -105,6 +105,17 @@ class SubprocessRun:
             async_subprocesses = self._DEFAULT_ASYNC_SUBPROCESSES
         return await check.not_none(async_subprocesses).run_(self.replace(**kwargs))
 
+    _DEFAULT_MAYSYNC_SUBPROCESSES: ta.ClassVar[ta.Optional[ta.Any]] = None  # AbstractMaysyncSubprocesses
+
+    async def maysync_run(
+            self,
+            maysync_subprocesses: ta.Optional[ta.Any] = None,  # AbstractMaysyncSubprocesses
+            **kwargs: ta.Any,
+    ) -> SubprocessRunOutput:
+        if maysync_subprocesses is None:
+            maysync_subprocesses = self._DEFAULT_MAYSYNC_SUBPROCESSES
+        return await check.not_none(maysync_subprocesses).run_(self.replace(**kwargs))
+
 
 SubprocessRun._FIELD_NAMES = frozenset(fld.name for fld in dc.fields(SubprocessRun))  # noqa
 
@@ -136,3 +147,10 @@ class SubprocessRunnable(abc.ABC, ta.Generic[T]):
             **kwargs: ta.Any,
     ) -> T:
         return self.handle_run_output(await self.make_run().async_run(async_subprocesses, **kwargs))
+
+    async def maysync_run(
+            self,
+            maysync_subprocesses: ta.Optional[ta.Any] = None,  # AbstractMaysyncSubprocesses
+            **kwargs: ta.Any,
+    ) -> T:
+        return self.handle_run_output(await self.make_run().maysync_run(maysync_subprocesses, **kwargs))

{omlish-0.0.0.dev387 → omlish-0.0.0.dev388/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev387 → omlish-0.0.0.dev388}/omlish.egg-info/SOURCES.txt

@@ -761,6 +761,7 @@ omlish/subprocesses/__init__.py
 omlish/subprocesses/async_.py
 omlish/subprocesses/base.py
 omlish/subprocesses/editor.py
+omlish/subprocesses/maysync.py
 omlish/subprocesses/run.py
 omlish/subprocesses/sync.py
 omlish/subprocesses/utils.py

{omlish-0.0.0.dev387 → omlish-0.0.0.dev388}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev387'
+version = '0.0.0.dev388'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',

omlish-0.0.0.dev387/omlish/lang/maysyncs.py

@@ -1,41 +0,0 @@
-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-0.0.0.dev387/omlish/lite/maysyncs.py

@@ -1,184 +0,0 @@
-# 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