omlish 0.0.0.dev388__py3-none-any.whl → 0.0.0.dev390__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev388'
-__revision__ = 'fcc404b8a37769b71f1c1118911ccffe78dbcb4b'
+__version__ = '0.0.0.dev390'
+__revision__ = 'ff94a07f8eda21fdfb8dbc4a4b090d4d42470f83'
 
 
 #

omlish/asyncs/anyio/subprocesses.py

@@ -1,13 +1,12 @@
 import io
 import subprocess
-import sys
 import typing as ta
 
 import anyio.abc
 
 from ... import check
 from ...lite.timeouts import Timeout
-from ...subprocesses.async_ import AbstractAsyncSubprocesses
+from ...subprocesses.asyncs import AbstractAsyncSubprocesses
 from ...subprocesses.run import SubprocessRun
 from ...subprocesses.run import SubprocessRunOutput
 
@@ -73,13 +72,5 @@ class AnyioSubprocesses(AbstractAsyncSubprocesses):
             stderr=stderr.getvalue() if stderr is not None else None,
         )
 
-    async def check_call(self, *cmd: str, stdout: ta.Any = sys.stderr, **kwargs: ta.Any) -> None:
-        with self.prepare_and_wrap(*cmd, stdout=stdout, check=True, **kwargs) as (cmd, kwargs):  # noqa
-            await self.run(*cmd, **kwargs)
-
-    async def check_output(self, *cmd: str, **kwargs: ta.Any) -> bytes:
-        with self.prepare_and_wrap(*cmd, stdout=subprocess.PIPE, check=True, **kwargs) as (cmd, kwargs):  # noqa
-            return check.not_none((await self.run(*cmd, **kwargs)).stdout)
-
 
 anyio_subprocesses = AnyioSubprocesses()

omlish/asyncs/asyncio/subprocesses.py

@@ -6,12 +6,11 @@ import contextlib
 import functools
 import logging
 import subprocess
-import sys
 import typing as ta
 
 from ...lite.check import check
 from ...lite.timeouts import TimeoutLike
-from ...subprocesses.async_ import AbstractAsyncSubprocesses
+from ...subprocesses.asyncs import AbstractAsyncSubprocesses
 from ...subprocesses.run import SubprocessRun
 from ...subprocesses.run import SubprocessRunOutput
 from .timeouts import asyncio_maybe_timeout
@@ -208,24 +207,5 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
             stderr=stderr,
         )
 
-    #
-
-    async def check_call(
-            self,
-            *cmd: str,
-            stdout: ta.Any = sys.stderr,
-            **kwargs: ta.Any,
-    ) -> None:
-        with self.prepare_and_wrap(*cmd, stdout=stdout, check=True, **kwargs) as (cmd, kwargs):  # noqa
-            await self.run(*cmd, **kwargs)
-
-    async def check_output(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> bytes:
-        with self.prepare_and_wrap(*cmd, stdout=subprocess.PIPE, check=True, **kwargs) as (cmd, kwargs):  # noqa
-            return check.not_none((await self.run(*cmd, **kwargs)).stdout)
-
 
 asyncio_subprocesses = AsyncioSubprocesses()

omlish/lite/maysyncs.py

@@ -11,7 +11,8 @@ import typing as ta
 
 T = ta.TypeVar('T')
 T_co = ta.TypeVar('T_co', covariant=True)
-_X = ta.TypeVar('_X')
+
+_MaysyncX = ta.TypeVar('_MaysyncX')
 
 _MaysyncGen = ta.Generator['_MaysyncOp', ta.Any, T]  # ta.TypeAlias
 
@@ -40,11 +41,11 @@ class Maysync_(abc.ABC):  # noqa
 ##
 
 
-class _Maywaitable(abc.ABC, ta.Generic[_X, T]):
+class _Maywaitable(abc.ABC, ta.Generic[_MaysyncX, T]):
     @ta.final
     def __init__(
             self,
-            x: _X,
+            x: _MaysyncX,
             *args: ta.Any,
             **kwargs: ta.Any,
     ) -> None:
@@ -115,6 +116,8 @@ class _MgMaysync(Maysync_, ta.Generic[T]):
     ) -> None:
         self.mg = mg
 
+        functools.update_wrapper(self, mg, updated=())
+
     def __get__(self, instance, owner=None):
         return _MgMaysync(
             self.mg.__get__(instance, owner),  # noqa
@@ -146,6 +149,7 @@ class _MgMaywaitable(_Maywaitable[_MgMaysync[T], T]):
 
             if not isinstance(o, _MaysyncOp):
                 raise TypeError(o)
+
             try:
                 i = o.x(*o.args, **o.kwargs).s()
             except BaseException as ex:  # noqa
@@ -173,6 +177,7 @@ class _MgMaywaitable(_Maywaitable[_MgMaysync[T], T]):
 
             if not isinstance(o, _MaysyncOp):
                 raise TypeError(o)
+
             try:
                 i = await o.x(*o.args, **o.kwargs).a()
             except BaseException as ex:  # noqa
@@ -186,7 +191,7 @@ class _MgMaysyncFn:
     def __init__(self, m):
         self.m = m
 
-        functools.update_wrapper(self, m)
+        functools.update_wrapper(self, m, updated=())
 
     def __get__(self, instance, owner=None):
         return _MgMaysyncFn(
@@ -206,6 +211,7 @@ class _MgMaysyncFn:
 
                     if not isinstance(o, _MaysyncFuture):
                         raise TypeError(o)
+
                     if not o.done:
                         try:
                             o.result = yield o.op
@@ -213,6 +219,8 @@ class _MgMaysyncFn:
                             o.error = e
                         o.done = True
 
+                    del o
+
             finally:
                 g.close()
 
@@ -240,6 +248,10 @@ class _MaysyncOp:
         self.kwargs = kwargs
 
 
+class _MaysyncFutureNotAwaitedError(RuntimeError):
+    pass
+
+
 @ta.final
 class _MaysyncFuture(ta.Generic[T]):
     def __init__(
@@ -249,14 +261,15 @@ class _MaysyncFuture(ta.Generic[T]):
         self.op = op
 
     done: bool = False
-    result: ta.Optional[T] = None
+    result: T
     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")
+            raise _MaysyncFutureNotAwaitedError
         if self.error is not None:
             raise self.error
-        return self.result
+        else:
+            return self.result

omlish/subprocesses/{async_.py → asyncs.py}

@@ -1,9 +1,11 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
 import abc
+import subprocess
 import sys
 import typing as ta
 
+from ..lite.check import check
 from ..lite.timeouts import TimeoutLike
 from .base import BaseSubprocesses
 from .run import SubprocessRun
@@ -13,9 +15,9 @@ from .run import SubprocessRunOutput
 ##
 
 
-class _AbstractAsyncSubprocesses(BaseSubprocesses):
+class AbstractAsyncSubprocesses(BaseSubprocesses):
     @abc.abstractmethod
-    async def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
+    def run_(self, run: SubprocessRun) -> ta.Awaitable[SubprocessRunOutput]:
         raise NotImplementedError
 
     def run(
@@ -38,31 +40,41 @@ class _AbstractAsyncSubprocesses(BaseSubprocesses):
 
     #
 
-    @abc.abstractmethod
     async def check_call(
             self,
             *cmd: str,
             stdout: ta.Any = sys.stderr,
             **kwargs: ta.Any,
     ) -> None:
-        raise NotImplementedError
+        await self.run(
+            *cmd,
+            stdout=stdout,
+            check=True,
+            **kwargs,
+        )
 
-    @abc.abstractmethod
     async def check_output(
             self,
             *cmd: str,
+            stdout: ta.Any = subprocess.PIPE,
             **kwargs: ta.Any,
     ) -> bytes:
-        raise NotImplementedError
-
-    #
+        return check.not_none((await self.run(
+            *cmd,
+            stdout=stdout,
+            check=True,
+            **kwargs,
+        )).stdout)
 
     async def check_output_str(
             self,
             *cmd: str,
             **kwargs: ta.Any,
     ) -> str:
-        return (await self.check_output(*cmd, **kwargs)).decode().strip()
+        return (await self.check_output(
+            *cmd,
+            **kwargs,
+        )).decode().strip()
 
     #
 
@@ -95,7 +107,3 @@ class _AbstractAsyncSubprocesses(BaseSubprocesses):
             return None
         else:
             return ret.decode().strip()
-
-
-class AbstractAsyncSubprocesses(_AbstractAsyncSubprocesses, abc.ABC):
-    pass

omlish/subprocesses/maysyncs.py

@@ -0,0 +1,152 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+import abc
+import sys
+import typing as ta
+
+from ..lite.maysyncs import Maywaitable
+from ..lite.maysyncs import make_maysync
+from ..lite.maysyncs import maysync
+from ..lite.timeouts import TimeoutLike
+from .asyncs import AbstractAsyncSubprocesses
+from .base import BaseSubprocesses
+from .run import SubprocessRun
+from .run import SubprocessRunOutput
+from .sync import AbstractSubprocesses
+
+
+##
+
+
+class AbstractMaysyncSubprocesses(BaseSubprocesses, abc.ABC):
+    @abc.abstractmethod
+    def run_(self, run: SubprocessRun) -> Maywaitable[SubprocessRunOutput]:
+        raise NotImplementedError
+
+    def run(
+            self,
+            *cmd: str,
+            input: ta.Any = None,  # noqa
+            timeout: TimeoutLike = None,
+            check: bool = False,
+            capture_output: ta.Optional[bool] = None,
+            **kwargs: ta.Any,
+    ) -> Maywaitable[SubprocessRunOutput]:
+        return self.run_(SubprocessRun(
+            cmd=cmd,
+            input=input,
+            timeout=timeout,
+            check=check,
+            capture_output=capture_output,
+            kwargs=kwargs,
+        ))
+
+    #
+
+    @abc.abstractmethod
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> Maywaitable[None]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> Maywaitable[bytes]:
+        raise NotImplementedError
+
+    #
+
+    @maysync
+    async def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs).m()).decode().strip()
+
+    #
+
+    @maysync
+    async def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(await self.async_try_fn(self.check_call(*cmd, **kwargs).m), Exception):
+            return False
+        else:
+            return True
+
+    @maysync
+    async def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := await self.async_try_fn(self.check_output(*cmd, **kwargs).m), Exception):
+            return None
+        else:
+            return ret
+
+    @maysync
+    async def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := await self.try_output(*cmd, **kwargs).m()) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+##
+
+
+class MaysyncSubprocesses(AbstractMaysyncSubprocesses):
+    def __init__(
+            self,
+            subprocesses: AbstractSubprocesses,
+            async_subprocesses: AbstractAsyncSubprocesses,
+    ) -> None:
+        super().__init__()
+
+        self._subprocesses = subprocesses
+        self._async_subprocesses = async_subprocesses
+
+    #
+
+    def run_(self, run: SubprocessRun) -> Maywaitable[SubprocessRunOutput]:
+        return make_maysync(
+            self._subprocesses.run,
+            self._async_subprocesses.run,
+        )(run)
+
+    #
+
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> Maywaitable[None]:
+        return make_maysync(
+            self._subprocesses.check_call,
+            self._async_subprocesses.check_call,
+        )(*cmd, stdout=stdout, **kwargs)
+
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> Maywaitable[bytes]:
+        return make_maysync(
+            self._subprocesses.check_output,
+            self._async_subprocesses.check_output,
+        )(*cmd, **kwargs)

omlish/subprocesses/sync.py

@@ -127,6 +127,8 @@ class Subprocesses(AbstractSubprocesses):
             stderr=proc.stderr,  # noqa
         )
 
+    #
+
     def check_call(
             self,
             *cmd: str,

{omlish-0.0.0.dev388.dist-info → omlish-0.0.0.dev390.dist-info}/METADATA

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

{omlish-0.0.0.dev388.dist-info → omlish-0.0.0.dev390.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=aT8yZ-Zh-9wfHl5Ym5ouiWC1i0cy7Q7RlhzavB6VLPI,8587
-omlish/__about__.py,sha256=Yte_7PVV4dR_gMOEh3rykgNGh8hm1tSqvBzJHfYNgcE,3543
+omlish/__about__.py,sha256=alsBldkE0-UGNfrDGdG5bJin7IBPy2fvZg-usmwH17A,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
@@ -34,7 +34,7 @@ omlish/asyncs/anyio/backends.py,sha256=jJIymWoiedaEJJm82gvKiJ41EWLQZ-bcyNHpbDpKK
 omlish/asyncs/anyio/futures.py,sha256=Nm1gLerZEnHk-rlsmr0UfK168IWIK6zA8EebZFtoY_E,2052
 omlish/asyncs/anyio/signals.py,sha256=ySSut5prdnoy0-5Ws5V1M4cC2ON_vY550vU10d2NHk8,893
 omlish/asyncs/anyio/streams.py,sha256=Zum2qd1t3EiH6yzGWFwxFw79m-IH2VY5sTUTiluFfIY,2164
-omlish/asyncs/anyio/subprocesses.py,sha256=nyl1A9z3rymxQMvIekWHU3IAiKBu1CcEqm-Ag1cGRPY,3018
+omlish/asyncs/anyio/subprocesses.py,sha256=5nWYw9sPaelK2AJ17NHTHQ34Qa3DXCFkcTpvddzjboA,2500
 omlish/asyncs/anyio/sync.py,sha256=ZmSNhSsEkPwlXThrpefhtVTxw4GJ9F0P-yKyo5vbbSk,1574
 omlish/asyncs/anyio/utils.py,sha256=-mveSB20De6znphfMlIuEd_rwITkcSjFNO07isshDjk,1704
 omlish/asyncs/asyncio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -42,7 +42,7 @@ omlish/asyncs/asyncio/all.py,sha256=u2JpMEs-0AJ0Vd8yU10HvWD8rfKxdFfMiwBu2oDeuuQ,
 omlish/asyncs/asyncio/channels.py,sha256=oniTpmw_eeKK70APyEZLhRUChwLwebE4N0_uZiwSKgQ,1085
 omlish/asyncs/asyncio/sockets.py,sha256=i1a2DZ52IuvRQQQW8FJxEUFboqpKn_K08a_MsMaecqU,1264
 omlish/asyncs/asyncio/streams.py,sha256=Laa9BNwajZ7Wt_rJoYMbQtfSX4Q4i-dVHhtYSekCHXM,1015
-omlish/asyncs/asyncio/subprocesses.py,sha256=jVtvitvWgCLzAhgSLabHTzIOcPmNQqnsJpDr6hy6zgU,6908
+omlish/asyncs/asyncio/subprocesses.py,sha256=8o-uWNsJhSoM7Egbofc23CeJFRmb4isb9zVVh1Fxjfk,6285
 omlish/asyncs/asyncio/timeouts.py,sha256=lJ4qmDqyxUeAQCXJGiLL8pxYwoR1F1lntZ18HVf40Wo,452
 omlish/asyncs/asyncio/utils.py,sha256=dCC4hXqCTKBpU5urAXsKUIIua2M9JXAtumwh7IUEu7E,2443
 omlish/asyncs/bluelet/LICENSE,sha256=q5Kpj4s30qpi8H66tXFlh5v8_fkaKMFIzqdGfnN0Hz0,555
@@ -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/maysyncs.py,sha256=Za0kvANYaK9q-IUs_rSjo1ZQIOTZzkVB7IIEGw5eOsQ,5687
+omlish/lite/maysyncs.py,sha256=ltB3CQ_zYl2PiTmHjtpeErZDFpNwj27JhO6_3xBmnfk,5852
 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
@@ -748,12 +748,12 @@ omlish/sql/tabledefs/lower.py,sha256=i4_QkVlVH5U99O6pqokrB661AudNVJ9Q-OwtkKOBleU
 omlish/sql/tabledefs/marshal.py,sha256=5Z7K433SzfN7-z8Yd7FJRzOV9tJv-ErRMA6inZ2iBCE,475
 omlish/sql/tabledefs/tabledefs.py,sha256=lIhvlt0pk6G7RZAtDFsFXm5j0l9BvRfnP7vNGeydHtE,816
 omlish/subprocesses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/subprocesses/async_.py,sha256=Zs9TxCyROVTOhbZmZMHi_-zwydptVi7MN4esUiK4-YI,2448
+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/maysync.py,sha256=dK2wDv2so4wa0rOWBkafUqBy1QEJmLg_9CxMsr_kR4I,1456
+omlish/subprocesses/maysyncs.py,sha256=XWWVC-jyjVJLcT-nWMZFf4jUQesRuBWWVhmwcG_fUWE,3818
 omlish/subprocesses/run.py,sha256=8EeMm2FdNEFmEmbhhzJyHXASUhCCMMRN_-8ybqFhgLI,4378
-omlish/subprocesses/sync.py,sha256=YdGxa9_GhqqsvTucmnmUXWYcKKys0S5PQk271K1Jg68,3664
+omlish/subprocesses/sync.py,sha256=L-ZNj9RrZd69XjlKrXjt-EJ-XUpQF8E35Mh3b3SI3vc,3671
 omlish/subprocesses/utils.py,sha256=v5uEzxmbmRvXwOl_0DtBa5Il6yITKYRgmVSGHcLsT4o,402
 omlish/subprocesses/wrap.py,sha256=AhGV8rsnaVUMQCFYKkrjj35fs3O-VJLZC1hZ14dz3C8,769
 omlish/term/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -895,9 +895,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.dev388.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev388.dist-info/METADATA,sha256=YvbEgGvf4ZNKIIJWrToJVEysF8nsyVuzRgd1VeAcc8k,18825
-omlish-0.0.0.dev388.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev388.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev388.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev388.dist-info/RECORD,,
+omlish-0.0.0.dev390.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev390.dist-info/METADATA,sha256=2Ozri2hyskBCfsdHgBPNMJXGWCnvQz5xIm_p3MPXVaE,18825
+omlish-0.0.0.dev390.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev390.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev390.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev390.dist-info/RECORD,,

omlish/subprocesses/maysync.py

@@ -1,52 +0,0 @@
-# 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()