omlish 0.0.0.dev223__py3-none-any.whl → 0.0.0.dev225__py3-none-any.whl

omlish/subprocesses.py

@@ -1,491 +0,0 @@
-# ruff: noqa: UP006 UP007
-# @omlish-lite
-import abc
-import contextlib
-import dataclasses as dc
-import logging
-import os
-import shlex
-import subprocess
-import sys
-import time
-import typing as ta
-
-from .lite.runtime import is_debugger_attached
-
-
-T = ta.TypeVar('T')
-SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
-
-
-##
-
-
-# Valid channel type kwarg values:
-#  - A special flag negative int
-#  - A positive fd int
-#  - A file-like object
-#  - None
-
-SUBPROCESS_CHANNEL_OPTION_VALUES: ta.Mapping[SubprocessChannelOption, int] = {
-    'pipe': subprocess.PIPE,
-    'stdout': subprocess.STDOUT,
-    'devnull': subprocess.DEVNULL,
-}
-
-
-##
-
-
-_SUBPROCESS_SHELL_WRAP_EXECS = False
-
-
-def subprocess_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
-    return ('sh', '-c', ' '.join(map(shlex.quote, cmd)))
-
-
-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(*cmd)
-    else:
-        return cmd
-
-
-##
-
-
-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 VerboseCalledProcessError(subprocess.CalledProcessError):
-    @classmethod
-    def from_std(cls, e: subprocess.CalledProcessError) -> 'VerboseCalledProcessError':
-        return cls(
-            e.returncode,
-            e.cmd,
-            output=e.output,
-            stderr=e.stderr,
-        )
-
-    def __str__(self) -> str:
-        msg = super().__str__()
-        if self.output is not None:
-            msg += f' Output: {self.output!r}'
-        if self.stderr is not None:
-            msg += f' Stderr: {self.stderr!r}'
-        return msg
-
-
-class BaseSubprocesses(abc.ABC):  # noqa
-    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
-
-    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 set_logger(self, log: ta.Optional[logging.Logger]) -> None:
-        self._log = log
-
-    #
-
-    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
-
-        for chk in ('stdout', 'stderr'):
-            try:
-                chv = kwargs[chk]
-            except KeyError:
-                continue
-            kwargs[chk] = SUBPROCESS_CHANNEL_OPTION_VALUES.get(chv, chv)
-
-        #
-
-        if not shell:
-            cmd = subprocess_maybe_shell_wrap_exec(*cmd)
-
-        #
-
-        return cmd, dict(
-            env=env,
-            shell=shell,
-            **kwargs,
-        )
-
-    @contextlib.contextmanager
-    def wrap_call(
-            self,
-            *cmd: ta.Any,
-            raise_verbose: bool = False,
-            **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)
-
-            if (
-                    raise_verbose and
-                    isinstance(exc, subprocess.CalledProcessError) and
-                    not isinstance(exc, VerboseCalledProcessError) and
-                    (exc.output is not None or exc.stderr is not None)
-            ):
-                raise VerboseCalledProcessError.from_std(exc) from exc
-
-            raise
-
-        finally:
-            end_time = time.time()
-            elapsed_s = end_time - start_time
-
-            if self._log:
-                self._log.debug('Subprocesses.wrap_call.finally: elapsed_s=%f cmd=%r', elapsed_s, cmd)
-
-    @contextlib.contextmanager
-    def prepare_and_wrap(
-            self,
-            *cmd: ta.Any,
-            raise_verbose: bool = False,
-            **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,
-                raise_verbose=raise_verbose,
-                **kwargs,
-        ):
-            yield cmd, kwargs
-
-    #
-
-    DEFAULT_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
-        FileNotFoundError,
-        subprocess.CalledProcessError,
-    )
-
-    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
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class SubprocessRun:
-    cmd: ta.Sequence[str]
-    input: ta.Any = None
-    timeout: ta.Optional[float] = None
-    check: bool = False
-    capture_output: ta.Optional[bool] = None
-    kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None
-
-
-@dc.dataclass(frozen=True)
-class SubprocessRunOutput(ta.Generic[T]):
-    proc: T
-
-    returncode: int  # noqa
-
-    stdout: ta.Optional[bytes] = None
-    stderr: ta.Optional[bytes] = None
-
-
-class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
-    @abc.abstractmethod
-    def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
-        raise NotImplementedError
-
-    def run(
-            self,
-            *cmd: str,
-            input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
-            check: bool = False,
-            capture_output: ta.Optional[bool] = None,
-            **kwargs: ta.Any,
-    ) -> 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,
-    ) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def check_output(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> bytes:
-        raise NotImplementedError
-
-    #
-
-    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()
-
-
-##
-
-
-class Subprocesses(AbstractSubprocesses):
-    def run_(self, run: SubprocessRun) -> SubprocessRunOutput[subprocess.CompletedProcess]:
-        proc = subprocess.run(
-            run.cmd,
-            input=run.input,
-            timeout=run.timeout,
-            check=run.check,
-            capture_output=run.capture_output or False,
-            **(run.kwargs or {}),
-        )
-
-        return SubprocessRunOutput(
-            proc=proc,
-
-            returncode=proc.returncode,
-
-            stdout=proc.stdout,  # noqa
-            stderr=proc.stderr,  # noqa
-        )
-
-    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)
-
-
-subprocesses = Subprocesses()
-
-
-##
-
-
-class AbstractAsyncSubprocesses(BaseSubprocesses):
-    @abc.abstractmethod
-    async def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
-        raise NotImplementedError
-
-    def run(
-            self,
-            *cmd: str,
-            input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
-            check: bool = False,
-            capture_output: ta.Optional[bool] = None,
-            **kwargs: ta.Any,
-    ) -> ta.Awaitable[SubprocessRunOutput]:
-        return self.run_(SubprocessRun(
-            cmd=cmd,
-            input=input,
-            timeout=timeout,
-            check=check,
-            capture_output=capture_output,
-            kwargs=kwargs,
-        ))
-
-    #
-
-    @abc.abstractmethod
-    async def check_call(
-            self,
-            *cmd: str,
-            stdout: ta.Any = sys.stderr,
-            **kwargs: ta.Any,
-    ) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    async def check_output(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> bytes:
-        raise NotImplementedError
-
-    #
-
-    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()