omlish 0.0.0.dev155__py3-none-any.whl → 0.0.0.dev157__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev155'
-__revision__ = '7187ecad3907bd95f19a85608e9cbd7b9a103920'
+__version__ = '0.0.0.dev157'
+__revision__ = 'f327aa714545eba416378a8b99f407e8c5eeaac4'
 
 
 #

omlish/argparse/cli.py

@@ -14,6 +14,8 @@ import sys
 import typing as ta
 
 from ..lite.check import check
+from ..lite.reflect import get_optional_alias_arg
+from ..lite.reflect import is_optional_alias
 
 
 T = ta.TypeVar('T')
@@ -120,6 +122,8 @@ def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
         return {'action': 'store_true'}
     elif ann is list:
         return {'action': 'append'}
+    elif is_optional_alias(ann):
+        return _get_argparse_arg_ann_kwargs(get_optional_alias_arg(ann))
     else:
         raise TypeError(ann)
 

omlish/lite/asyncio/subprocesses.py

@@ -4,7 +4,6 @@ import asyncio.subprocess
 import contextlib
 import dataclasses as dc
 import functools
-import logging
 import subprocess
 import sys
 import typing as ta
@@ -12,9 +11,7 @@ import typing as ta
 from ...asyncs.asyncio.timeouts import asyncio_maybe_timeout
 from ..check import check
 from ..logs import log
-from ..subprocesses import DEFAULT_SUBPROCESS_TRY_EXCEPTIONS
-from ..subprocesses import prepare_subprocess_invocation
-from ..subprocesses import subprocess_common_context
+from ..subprocesses import AbstractSubprocesses
 
 
 T = ta.TypeVar('T')
@@ -23,43 +20,6 @@ T = ta.TypeVar('T')
 ##
 
 
-@contextlib.asynccontextmanager
-async def asyncio_subprocess_popen(
-        *cmd: str,
-        shell: bool = False,
-        timeout: ta.Optional[float] = None,
-        **kwargs: ta.Any,
-) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
-    fac: ta.Any
-    if shell:
-        fac = functools.partial(
-            asyncio.create_subprocess_shell,
-            check.single(cmd),
-        )
-    else:
-        fac = functools.partial(
-            asyncio.create_subprocess_exec,
-            *cmd,
-        )
-
-    with subprocess_common_context(
-            *cmd,
-            shell=shell,
-            timeout=timeout,
-            **kwargs,
-    ):
-        proc: asyncio.subprocess.Process
-        proc = await fac(**kwargs)
-        try:
-            yield proc
-
-        finally:
-            await asyncio_maybe_timeout(proc.wait(), timeout)
-
-
-##
-
-
 class AsyncioProcessCommunicator:
     def __init__(
             self,
@@ -170,145 +130,144 @@ class AsyncioProcessCommunicator:
         return await asyncio_maybe_timeout(self._communicate(input), timeout)
 
 
-async def asyncio_subprocess_communicate(
-        proc: asyncio.subprocess.Process,
-        input: ta.Any = None,  # noqa
-        timeout: ta.Optional[float] = None,
-) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
-    return await AsyncioProcessCommunicator(proc).communicate(input, timeout)  # noqa
-
-
-@dc.dataclass(frozen=True)
-class AsyncioSubprocessOutput:
-    proc: asyncio.subprocess.Process
-    stdout: ta.Optional[bytes]
-    stderr: ta.Optional[bytes]
-
-
-async def asyncio_subprocess_run(
-        *args: str,
-        input: ta.Any = None,  # noqa
-        timeout: ta.Optional[float] = None,
-        check: bool = False,  # noqa
-        capture_output: ta.Optional[bool] = None,
-        **kwargs: ta.Any,
-) -> AsyncioSubprocessOutput:
-    if capture_output:
-        kwargs.setdefault('stdout', subprocess.PIPE)
-        kwargs.setdefault('stderr', subprocess.PIPE)
-
-    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
-
-    proc: asyncio.subprocess.Process
-    async with asyncio_subprocess_popen(*args, **kwargs) as proc:
-        stdout, stderr = await asyncio_subprocess_communicate(proc, input, timeout)
-
-    if check and proc.returncode:
-        raise subprocess.CalledProcessError(
-            proc.returncode,
-            args,
-            output=stdout,
-            stderr=stderr,
-        )
+##
 
-    return AsyncioSubprocessOutput(
-        proc,
-        stdout,
-        stderr,
-    )
 
+class AsyncioSubprocesses(AbstractSubprocesses):
+    async def communicate(
+            self,
+            proc: asyncio.subprocess.Process,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+    ) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+        return await AsyncioProcessCommunicator(proc).communicate(input, timeout)  # noqa
 
-##
+    #
 
+    @contextlib.asynccontextmanager
+    async def popen(
+            self,
+            *cmd: str,
+            shell: bool = False,
+            timeout: ta.Optional[float] = None,
+            **kwargs: ta.Any,
+    ) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
+        fac: ta.Any
+        if shell:
+            fac = functools.partial(
+                asyncio.create_subprocess_shell,
+                check.single(cmd),
+            )
+        else:
+            fac = functools.partial(
+                asyncio.create_subprocess_exec,
+                *cmd,
+            )
 
-async def asyncio_subprocess_check_call(
-        *args: str,
-        stdout: ta.Any = sys.stderr,
-        input: ta.Any = None,  # noqa
-        timeout: ta.Optional[float] = None,
-        **kwargs: ta.Any,
-) -> None:
-    await asyncio_subprocess_run(
-        *args,
-        stdout=stdout,
-        input=input,
-        timeout=timeout,
-        check=True,
-        **kwargs,
-    )
-
-
-async def asyncio_subprocess_check_output(
-        *args: str,
-        input: ta.Any = None,  # noqa
-        timeout: ta.Optional[float] = None,
-        **kwargs: ta.Any,
-) -> bytes:
-    out = await asyncio_subprocess_run(
-        *args,
-        stdout=asyncio.subprocess.PIPE,
-        input=input,
-        timeout=timeout,
-        check=True,
-        **kwargs,
-    )
-
-    return check.not_none(out.stdout)
-
-
-async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
-    return (await asyncio_subprocess_check_output(*args, **kwargs)).decode().strip()
+        with self.prepare_and_wrap( *cmd, shell=shell, **kwargs) as (cmd, kwargs):  # noqa
+            proc: asyncio.subprocess.Process = await fac(**kwargs)
+            try:
+                yield proc
 
+            finally:
+                await asyncio_maybe_timeout(proc.wait(), timeout)
 
-##
+    #
 
+    @dc.dataclass(frozen=True)
+    class RunOutput:
+        proc: asyncio.subprocess.Process
+        stdout: ta.Optional[bytes]
+        stderr: ta.Optional[bytes]
 
-async def _asyncio_subprocess_try_run(
-        fn: ta.Callable[..., ta.Awaitable[T]],
-        *args: ta.Any,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> ta.Union[T, Exception]:
-    try:
-        return await fn(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
-        return e
-
-
-async def asyncio_subprocess_try_call(
-        *args: str,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> bool:
-    if isinstance(await _asyncio_subprocess_try_run(
-            asyncio_subprocess_check_call,
-            *args,
-            try_exceptions=try_exceptions,
-            **kwargs,
-    ), Exception):
-        return False
-    else:
-        return True
-
-
-async def asyncio_subprocess_try_output(
-        *args: str,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> ta.Optional[bytes]:
-    if isinstance(ret := await _asyncio_subprocess_try_run(
-            asyncio_subprocess_check_output,
-            *args,
-            try_exceptions=try_exceptions,
-            **kwargs,
-    ), Exception):
-        return None
-    else:
-        return ret
+    async def run(
+            self,
+            *cmd: str,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+            check: bool = False,  # noqa
+            capture_output: ta.Optional[bool] = None,
+            **kwargs: ta.Any,
+    ) -> RunOutput:
+        if capture_output:
+            kwargs.setdefault('stdout', subprocess.PIPE)
+            kwargs.setdefault('stderr', subprocess.PIPE)
+
+        proc: asyncio.subprocess.Process
+        async with self.popen(*cmd, **kwargs) as proc:
+            stdout, stderr = await self.communicate(proc, input, timeout)
+
+        if check and proc.returncode:
+            raise subprocess.CalledProcessError(
+                proc.returncode,
+                cmd,
+                output=stdout,
+                stderr=stderr,
+            )
+
+        return self.RunOutput(
+            proc,
+            stdout,
+            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)
+
+    async def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs)).decode().strip()
+
+    #
+
+    async def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    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), Exception):
+            return None
+        else:
+            return ret
+
+    async def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := await self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
 
 
-async def asyncio_subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
-    out = await asyncio_subprocess_try_output(*args, **kwargs)
-    return out.decode().strip() if out is not None else None
+asyncio_subprocesses = AsyncioSubprocesses()

omlish/lite/cached.py

@@ -35,8 +35,8 @@ class _CachedNullary(_AbstractCachedNullary):
         return self._value
 
 
-def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _CachedNullary(fn)
+def cached_nullary(fn: CallableT) -> CallableT:
+    return _CachedNullary(fn)  # type: ignore
 
 
 def static_init(fn: CallableT) -> CallableT:

omlish/lite/marshal.py

@@ -3,6 +3,7 @@ TODO:
  - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
  - namedtuple
  - literals
+ - newtypes?
 """
 # ruff: noqa: UP006 UP007
 import abc

omlish/lite/subprocesses.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+import abc
 import contextlib
 import logging
 import os
@@ -8,8 +9,8 @@ import sys
 import time
 import typing as ta
 
-from .logs import log
-from .runtime import is_debugger_attached
+from omlish.lite.logs import log
+from omlish.lite.runtime import is_debugger_attached
 
 
 T = ta.TypeVar('T')
@@ -32,165 +33,219 @@ SUBPROCESS_CHANNEL_OPTION_VALUES: ta.Mapping[SubprocessChannelOption, int] = {
 _SUBPROCESS_SHELL_WRAP_EXECS = False
 
 
-def subprocess_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
-    return ('sh', '-c', ' '.join(map(shlex.quote, args)))
+def subprocess_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
+    return ('sh', '-c', ' '.join(map(shlex.quote, cmd)))
 
 
-def subprocess_maybe_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
+def subprocess_maybe_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
     if _SUBPROCESS_SHELL_WRAP_EXECS or is_debugger_attached():
-        return subprocess_shell_wrap_exec(*args)
+        return subprocess_shell_wrap_exec(*cmd)
     else:
-        return args
-
-
-def prepare_subprocess_invocation(
-        *args: str,
-        env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
-        extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
-        quiet: bool = False,
-        shell: bool = False,
-        **kwargs: ta.Any,
-) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
-    log.debug('prepare_subprocess_invocation: args=%r', args)
-    if extra_env:
-        log.debug('prepare_subprocess_invocation: extra_env=%r', extra_env)
-
-    if extra_env:
-        env = {**(env if env is not None else os.environ), **extra_env}
-
-    if quiet and 'stderr' not in kwargs:
-        if not log.isEnabledFor(logging.DEBUG):
-            kwargs['stderr'] = subprocess.DEVNULL
-
-    if not shell:
-        args = subprocess_maybe_shell_wrap_exec(*args)
-
-    return args, dict(
-        env=env,
-        shell=shell,
-        **kwargs,
-    )
-
-
-##
-
-
-@contextlib.contextmanager
-def subprocess_common_context(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterator[None]:
-    start_time = time.time()
-    try:
-        log.debug('subprocess_common_context.try: args=%r', args)
-        yield
-
-    except Exception as exc:  # noqa
-        log.debug('subprocess_common_context.except: exc=%r', exc)
-        raise
-
-    finally:
-        end_time = time.time()
-        elapsed_s = end_time - start_time
-        log.debug('subprocess_common_context.finally: elapsed_s=%f args=%r', elapsed_s, args)
+        return cmd
 
 
 ##
 
 
-def subprocess_check_call(
-        *args: str,
-        stdout: ta.Any = sys.stderr,
-        **kwargs: ta.Any,
+def subprocess_close(
+        proc: subprocess.Popen,
+        timeout: ta.Optional[float] = None,
 ) -> None:
-    args, kwargs = prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
-    with subprocess_common_context(*args, **kwargs):
-        return subprocess.check_call(args, **kwargs)  # type: ignore
-
-
-def subprocess_check_output(
-        *args: str,
-        **kwargs: ta.Any,
-) -> bytes:
-    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
-    with subprocess_common_context(*args, **kwargs):
-        return subprocess.check_output(args, **kwargs)
-
+    # TODO: terminate, sleep, kill
+    if proc.stdout:
+        proc.stdout.close()
+    if proc.stderr:
+        proc.stderr.close()
+    if proc.stdin:
+        proc.stdin.close()
 
-def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
-    return subprocess_check_output(*args, **kwargs).decode().strip()
+    proc.wait(timeout)
 
 
 ##
 
 
-DEFAULT_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
-    FileNotFoundError,
-    subprocess.CalledProcessError,
-)
-
-
-def _subprocess_try_run(
-        fn: ta.Callable[..., T],
-        *args: ta.Any,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> ta.Union[T, Exception]:
-    try:
-        return fn(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
-        return e
-
-
-def subprocess_try_call(
-        *args: str,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> bool:
-    if isinstance(_subprocess_try_run(
-            subprocess_check_call,
-            *args,
-            try_exceptions=try_exceptions,
+class AbstractSubprocesses(abc.ABC):  # noqa
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = log
+
+    def __init__(
+            self,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._log = log if log is not None else self.DEFAULT_LOGGER
+        self._try_exceptions = try_exceptions if try_exceptions is not None else self.DEFAULT_TRY_EXCEPTIONS
+
+    #
+
+    def prepare_args(
+            self,
+            *cmd: str,
+            env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+            extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+            quiet: bool = False,
+            shell: bool = False,
+            **kwargs: ta.Any,
+    ) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
+        if self._log:
+            self._log.debug('Subprocesses.prepare_args: cmd=%r', cmd)
+            if extra_env:
+                self._log.debug('Subprocesses.prepare_args: extra_env=%r', extra_env)
+
+        if extra_env:
+            env = {**(env if env is not None else os.environ), **extra_env}
+
+        if quiet and 'stderr' not in kwargs:
+            if self._log and not self._log.isEnabledFor(logging.DEBUG):
+                kwargs['stderr'] = subprocess.DEVNULL
+
+        if not shell:
+            cmd = subprocess_maybe_shell_wrap_exec(*cmd)
+
+        return cmd, dict(
+            env=env,
+            shell=shell,
             **kwargs,
-    ), Exception):
-        return False
-    else:
-        return True
-
-
-def subprocess_try_output(
-        *args: str,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> ta.Optional[bytes]:
-    if isinstance(ret := _subprocess_try_run(
-            subprocess_check_output,
-            *args,
-            try_exceptions=try_exceptions,
-            **kwargs,
-    ), Exception):
-        return None
-    else:
-        return ret
-
+        )
+
+    @contextlib.contextmanager
+    def wrap_call(self, *cmd: ta.Any, **kwargs: ta.Any) -> ta.Iterator[None]:
+        start_time = time.time()
+        try:
+            if self._log:
+                self._log.debug('Subprocesses.wrap_call.try: cmd=%r', cmd)
+            yield
+
+        except Exception as exc:  # noqa
+            if self._log:
+                self._log.debug('Subprocesses.wrap_call.except: exc=%r', exc)
+            raise
+
+        finally:
+            end_time = time.time()
+            elapsed_s = end_time - start_time
+            if self._log:
+                self._log.debug('sSubprocesses.wrap_call.finally: elapsed_s=%f cmd=%r', elapsed_s, cmd)
+
+    @contextlib.contextmanager
+    def prepare_and_wrap(
+            self,
+            *cmd: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Iterator[ta.Tuple[
+        ta.Tuple[ta.Any, ...],
+        ta.Dict[str, ta.Any],
+    ]]:
+        cmd, kwargs = self.prepare_args(*cmd, **kwargs)
+        with self.wrap_call(*cmd, **kwargs):
+            yield cmd, kwargs
+
+    #
+
+    DEFAULT_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
+        FileNotFoundError,
+        subprocess.CalledProcessError,
+    )
 
-def subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
-    out = subprocess_try_output(*args, **kwargs)
-    return out.decode().strip() if out is not None else None
+    def try_fn(
+            self,
+            fn: ta.Callable[..., T],
+            *cmd: str,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Union[T, Exception]:
+        if try_exceptions is None:
+            try_exceptions = self._try_exceptions
+
+        try:
+            return fn(*cmd, **kwargs)
+
+        except try_exceptions as e:  # noqa
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception('command failed')
+            return e
+
+    async def async_try_fn(
+            self,
+            fn: ta.Callable[..., ta.Awaitable[T]],
+            *cmd: ta.Any,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Union[T, Exception]:
+        if try_exceptions is None:
+            try_exceptions = self._try_exceptions
+
+        try:
+            return await fn(*cmd, **kwargs)
+
+        except try_exceptions as e:  # noqa
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception('command failed')
+            return e
 
 
 ##
 
 
-def subprocess_close(
-        proc: subprocess.Popen,
-        timeout: ta.Optional[float] = None,
-) -> None:
-    # TODO: terminate, sleep, kill
-    if proc.stdout:
-        proc.stdout.close()
-    if proc.stderr:
-        proc.stderr.close()
-    if proc.stdin:
-        proc.stdin.close()
-
-    proc.wait(timeout)
+class Subprocesses(AbstractSubprocesses):
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
+            subprocess.check_call(cmd, **kwargs)
+
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
+            return subprocess.check_output(cmd, **kwargs)
+
+    def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return self.check_output(*cmd, **kwargs).decode().strip()
+
+    #
+
+    def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(self.try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := self.try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+subprocesses = Subprocesses()

{omlish-0.0.0.dev155.dist-info → omlish-0.0.0.dev157.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev155
+Version: 0.0.0.dev157
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev155.dist-info → omlish-0.0.0.dev157.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=RX24SRc6DCEg77PUVnaXOKCWa5TF_c9RQJdGIf7gl9c,1135
-omlish/__about__.py,sha256=TTGSgQiaw8RlS3TEaNm9PX3osMhDFRCTCzGdQmtU5dQ,3409
+omlish/__about__.py,sha256=Gp7-GXOxzTN9ee-T1I3svA-Tc_rF24tMP_-u8t9ApaI,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -75,7 +75,7 @@ omlish/antlr/_runtime/xpath/XPathLexer.py,sha256=xFtdr4ZXMZxb2dnB_ggWyhvlQiC7RXQ
 omlish/antlr/_runtime/xpath/__init__.py,sha256=lMd_BbXYdlDhZQN_q0TKN978XW5G0pq618F0NaLkpFE,71
 omlish/argparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse/all.py,sha256=EfUSf27vFWqa4Q93AycU5YRsrHt-Nx3pU3uNVapb-EE,1054
-omlish/argparse/cli.py,sha256=RrFql1bS1Lw3GA1ooLCJDQX4bK_Ci-dDqD5nEkVgHGI,8072
+omlish/argparse/cli.py,sha256=Nd16RNNABOd9UjfLGtJrDOYkIs5uv1BnoqvJdQ2Ipc8,8273
 omlish/asyncs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/asyncs/all.py,sha256=uUz9ziKh4_QrgmdhKFMgq6j7mFbiZd3LiogguDCQsGI,587
 omlish/asyncs/anyio.py,sha256=gfpx-D8QGmUfhnQxHEaHXcAP8zSMQjcGw4COFTGNnHI,8021
@@ -333,13 +333,13 @@ omlish/lifecycles/manager.py,sha256=Au66KaO-fI-SEJALaPUJsCHYW2GE20xextk1wKn2BEU,
 omlish/lifecycles/states.py,sha256=zqMOU2ZU-MDNnWuwauM3_anIAiXM8LoBDElDEraptFg,1292
 omlish/lifecycles/transitions.py,sha256=qQtFby-h4VzbvgaUqT2NnbNumlcOx9FVVADP9t83xj4,1939
 omlish/lite/__init__.py,sha256=Y3l4WY4JRi2uLG6kgbGp93fuGfkxkKwZDvhsa0Rwgtk,15
-omlish/lite/cached.py,sha256=hBW77-F7ZLtFqbLwVrlqaJ4-iFHMQleMWZXaZN1IubA,1308
+omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 omlish/lite/check.py,sha256=KvcO86LqWlh2j4ORaZXRR4FM8fFb7kUkNqq3lTs0Ta0,12821
 omlish/lite/contextmanagers.py,sha256=m9JO--p7L7mSl4cycXysH-1AO27weDKjP3DZG61cwwM,1683
 omlish/lite/inject.py,sha256=729Qi0TLbQgBtkvx97q1EUMe73VFYA1hu4woXkOTcwM,23572
 omlish/lite/json.py,sha256=7-02Ny4fq-6YAu5ynvqoijhuYXWpLmfCI19GUeZnb1c,740
 omlish/lite/logs.py,sha256=1pcGu0ekhVCcLUckLSP16VccnAoprjtl5Vkdfm7y1Wg,6184
-omlish/lite/marshal.py,sha256=jbdKjTeumReSKUNNEn-oAyd5Bdy6NK_9_LsPSHpvqRU,13817
+omlish/lite/marshal.py,sha256=u5n43bEbct1ps8oIR7wjFCSWeyOhfHAF7LxUjELh8Jk,13830
 omlish/lite/maybes.py,sha256=7OlHJ8Q2r4wQ-aRbZSlJY7x0e8gDvufFdlohGEIJ3P4,833
 omlish/lite/pycharm.py,sha256=pUOJevrPClSqTCEOkQBO11LKX2003tfDcp18a03QFrc,1163
 omlish/lite/reflect.py,sha256=ad_ya_zZJOQB8HoNjs9yc66R54zgflwJVPJqiBXMzqA,1681
@@ -349,10 +349,10 @@ omlish/lite/secrets.py,sha256=3Mz3V2jf__XU9qNHcH56sBSw95L3U2UPL24bjvobG0c,816
 omlish/lite/socket.py,sha256=7OYgkXTcQv0wq7TQuLnl9y6dJA1ZT6Vbc1JH59QlxgY,1792
 omlish/lite/socketserver.py,sha256=doTXIctu_6c8XneFtzPFVG_Wq6xVmA3p9ymut8IvBoU,1586
 omlish/lite/strings.py,sha256=QURcE4-1pKVW8eT_5VCJpXaHDWR2dW2pYOChTJnZDiQ,1504
-omlish/lite/subprocesses.py,sha256=iN-HX44g9uxkZ7HII2Upvkfjp7YK6qQuhPrBqM4Hnp0,4934
+omlish/lite/subprocesses.py,sha256=fN8Hu1cDhu9PoYlfwYyIsMpeznOzisIU_3eKcYcnARs,6700
 omlish/lite/typing.py,sha256=U3-JaEnkDSYxK4tsu_MzUn3RP6qALBe5FXQXpD-licE,1090
 omlish/lite/asyncio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/lite/asyncio/subprocesses.py,sha256=luHARTCKB5qoxwUln1LH_v-z8k7YTkf32b2rgV_qkMg,8634
+omlish/lite/asyncio/subprocesses.py,sha256=pTcSbBDM6rpPKnjl8YqfdOhThDSalDcZHuvaCzYF07o,7729
 omlish/logs/__init__.py,sha256=FbOyAW-lGH8gyBlSVArwljdYAU6RnwZLI5LwAfuNnrk,438
 omlish/logs/abc.py,sha256=ho4ABKYMKX-V7g4sp1BByuOLzslYzLlQ0MESmjEpT-o,8005
 omlish/logs/configs.py,sha256=EE0jlNaXJbGnM7V-y4xS5VwyTBSTzFzc0BYaVjg0JmA,1283
@@ -520,9 +520,9 @@ omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,329
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev155.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev155.dist-info/METADATA,sha256=EZnz0auK1L6Br8TpcHXEE4T5zN79d2pJpORfJEZeFss,4264
-omlish-0.0.0.dev155.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev155.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev155.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev155.dist-info/RECORD,,
+omlish-0.0.0.dev157.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev157.dist-info/METADATA,sha256=7EjWfGRPNiPJlMhOs3pO4xT7Le7y2kO4WqbSIZFX-Gc,4264
+omlish-0.0.0.dev157.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev157.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev157.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev157.dist-info/RECORD,,