omdev 0.0.0.dev155__py3-none-any.whl → 0.0.0.dev156__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -4498,168 +4498,222 @@ 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
+        return cmd
 
 
-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)
+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()
 
-    return args, dict(
-        env=env,
-        shell=shell,
-        **kwargs,
-    )
+    proc.wait(timeout)
 
 
 ##
 
 
-@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
+class AbstractSubprocesses(abc.ABC):  # noqa
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = log
 
-    except Exception as exc:  # noqa
-        log.debug('subprocess_common_context.except: exc=%r', exc)
-        raise
+    def __init__(
+            self,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+    ) -> None:
+        super().__init__()
 
-    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)
+        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}
 
-def subprocess_check_call(
-        *args: str,
-        stdout: ta.Any = sys.stderr,
-        **kwargs: ta.Any,
-) -> None:
-    args, kwargs = prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
-    with subprocess_common_context(*args, **kwargs):
-        return subprocess.check_call(args, **kwargs)  # type: ignore
+        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)
 
-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)
+        return cmd, dict(
+            env=env,
+            shell=shell,
+            **kwargs,
+        )
 
+    @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
 
-def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
-    return subprocess_check_output(*args, **kwargs).decode().strip()
+        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_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
-    FileNotFoundError,
-    subprocess.CalledProcessError,
-)
+    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
 
-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
+        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
 
-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,
-            **kwargs,
-    ), Exception):
-        return False
-    else:
-        return True
+    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)
 
-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
+        except try_exceptions as e:  # noqa
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception('command failed')
+            return e
 
 
-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
+##
 
 
-##
+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 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()
+    def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return self.check_output(*cmd, **kwargs).decode().strip()
 
-    proc.wait(timeout)
+    #
+
+    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()
 
 
 ########################################
@@ -5070,43 +5124,6 @@ def get_git_status(
 ##
 
 
-@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,
@@ -5217,148 +5234,147 @@ 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,
+            )
 
+        with self.prepare_and_wrap( *cmd, shell=shell, **kwargs) as (cmd, kwargs):  # noqa
+            proc: asyncio.subprocess.Process = await fac(**kwargs)
+            try:
+                yield proc
 
-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,
-    )
+            finally:
+                await asyncio_maybe_timeout(proc.wait(), timeout)
 
+    #
 
-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,
-    )
+    @dc.dataclass(frozen=True)
+    class RunOutput:
+        proc: asyncio.subprocess.Process
+        stdout: ta.Optional[bytes]
+        stderr: ta.Optional[bytes]
 
-    return check.not_none(out.stdout)
+    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,
+            )
 
-async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
-    return (await asyncio_subprocess_check_output(*args, **kwargs)).decode().strip()
+        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 _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 check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs)).decode().strip()
 
+    #
 
-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 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 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 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()
 
 
 ########################################
@@ -5435,7 +5451,7 @@ class InterpInspector:
         return cls._build_inspection(sys.executable, eval(cls._INSPECTION_CODE))  # noqa
 
     async def _inspect(self, exe: str) -> InterpInspection:
-        output = await asyncio_subprocess_check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
+        output = await asyncio_subprocesses.check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
         return self._build_inspection(exe, output.decode())
 
     async def inspect(self, exe: str) -> ta.Optional[InterpInspection]:
@@ -5836,7 +5852,7 @@ class BasePyprojectPackageGenerator(abc.ABC):
             output_dir: ta.Optional[str] = None,
             opts: BuildOpts = BuildOpts(),
     ) -> None:
-        subprocess_check_call(
+        subprocesses.check_call(
             sys.executable,
             '-m',
             'build',
@@ -5852,14 +5868,14 @@ class BasePyprojectPackageGenerator(abc.ABC):
             for fn in os.listdir(dist_dir):
                 tmp_dir = tempfile.mkdtemp()
 
-                subprocess_check_call(
+                subprocesses.check_call(
                     sys.executable,
                     '-m', 'venv',
                     'test-install',
                     cwd=tmp_dir,
                 )
 
-                subprocess_check_call(
+                subprocesses.check_call(
                     os.path.join(tmp_dir, 'test-install', 'bin', 'python3'),
                     '-m', 'pip',
                     'install',
@@ -6232,7 +6248,7 @@ class Pyenv:
             return self._root_kw
 
         if shutil.which('pyenv'):
-            return await asyncio_subprocess_check_output_str('pyenv', 'root')
+            return await asyncio_subprocesses.check_output_str('pyenv', 'root')
 
         d = os.path.expanduser('~/.pyenv')
         if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
@@ -6261,7 +6277,7 @@ class Pyenv:
         if await self.root() is None:
             return []
         ret = []
-        s = await asyncio_subprocess_check_output_str(await self.exe(), 'install', '--list')
+        s = await asyncio_subprocesses.check_output_str(await self.exe(), 'install', '--list')
         for l in s.splitlines():
             if not l.startswith('  '):
                 continue
@@ -6276,7 +6292,7 @@ class Pyenv:
             return False
         if not os.path.isdir(os.path.join(root, '.git')):
             return False
-        await asyncio_subprocess_check_call('git', 'pull', cwd=root)
+        await asyncio_subprocesses.check_call('git', 'pull', cwd=root)
         return True
 
 
@@ -6367,7 +6383,7 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
         cflags = []
         ldflags = []
         for dep in self.BREW_DEPS:
-            dep_prefix = await asyncio_subprocess_check_output_str('brew', '--prefix', dep)
+            dep_prefix = await asyncio_subprocesses.check_output_str('brew', '--prefix', dep)
             cflags.append(f'-I{dep_prefix}/include')
             ldflags.append(f'-L{dep_prefix}/lib')
         return PyenvInstallOpts(
@@ -6377,11 +6393,11 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
 
     @async_cached_nullary
     async def brew_tcl_opts(self) -> PyenvInstallOpts:
-        if await asyncio_subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
+        if await asyncio_subprocesses.try_output('brew', '--prefix', 'tcl-tk') is None:
             return PyenvInstallOpts()
 
-        tcl_tk_prefix = await asyncio_subprocess_check_output_str('brew', '--prefix', 'tcl-tk')
-        tcl_tk_ver_str = await asyncio_subprocess_check_output_str('brew', 'ls', '--versions', 'tcl-tk')
+        tcl_tk_prefix = await asyncio_subprocesses.check_output_str('brew', '--prefix', 'tcl-tk')
+        tcl_tk_ver_str = await asyncio_subprocesses.check_output_str('brew', 'ls', '--versions', 'tcl-tk')
         tcl_tk_ver = '.'.join(tcl_tk_ver_str.split()[1].split('.')[:2])
 
         return PyenvInstallOpts(conf_opts=[
@@ -6502,7 +6518,7 @@ class PyenvVersionInstaller:
                 *conf_args,
             ]
 
-        await asyncio_subprocess_check_call(
+        await asyncio_subprocesses.check_call(
             *full_args,
             env=env,
         )
@@ -6897,12 +6913,12 @@ class Venv:
             return False
 
         log.info('Using interpreter %s', (ie := await self.interp_exe()))
-        await asyncio_subprocess_check_call(ie, '-m', 'venv', dn)
+        await asyncio_subprocesses.check_call(ie, '-m', 'venv', dn)
 
         ve = self.exe()
         uv = self._cfg.use_uv
 
-        await asyncio_subprocess_check_call(
+        await asyncio_subprocesses.check_call(
             ve,
             '-m', 'pip',
             'install', '-v', '--upgrade',
@@ -6920,7 +6936,7 @@ class Venv:
             #   Caused by: Failed to download distribution due to network timeout. Try increasing UV_HTTP_TIMEOUT (current value: 30s).  # noqa
             #   UV_CONCURRENT_DOWNLOADS=4 UV_HTTP_TIMEOUT=3600
 
-            await asyncio_subprocess_check_call(
+            await asyncio_subprocesses.check_call(
                 ve,
                 '-m',
                 *(['uv'] if uv else []),
@@ -7074,7 +7090,7 @@ class PyprojectCli(ArgparseCli):
                 else:
                     docker_env[e] = os.environ.get(e, '')
 
-            await asyncio_subprocess_check_call(
+            await asyncio_subprocesses.check_call(
                 'docker',
                 'compose',
                 '-f', 'docker/compose.yml',
@@ -7125,7 +7141,7 @@ class PyprojectCli(ArgparseCli):
 
         elif cmd == 'test':
             await venv.create()
-            await asyncio_subprocess_check_call(venv.exe(), '-m', 'pytest', *(self.args.args or []), *venv.srcs())
+            await asyncio_subprocesses.check_call(venv.exe(), '-m', 'pytest', *(self.args.args or []), *venv.srcs())
 
         else:
             raise Exception(f'unknown subcommand: {cmd}')