omdev 0.0.0.dev147__py3-none-any.whl → 0.0.0.dev148__py3-none-any.whl

omdev/scripts/interp.py

@@ -12,6 +12,9 @@ TODO:
 """
 import abc
 import argparse
+import asyncio
+import asyncio.base_subprocess
+import asyncio.subprocess
 import collections
 import contextlib
 import dataclasses as dc
@@ -29,6 +32,7 @@ import shutil
 import subprocess
 import sys
 import threading
+import time
 import types
 import typing as ta
 
@@ -51,6 +55,9 @@ VersionCmpLocalType = ta.Union['NegativeInfinityVersionType', _VersionCmpLocalTy
 VersionCmpKey = ta.Tuple[int, ta.Tuple[int, ...], VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpLocalType]  # noqa
 VersionComparisonMethod = ta.Callable[[VersionCmpKey, VersionCmpKey], bool]
 
+# ../../omlish/lite/asyncio/asyncio.py
+AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
+
 # ../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
@@ -474,11 +481,74 @@ def canonicalize_version(
     return ''.join(parts)
 
 
+########################################
+# ../../../omlish/lite/asyncio/asyncio.py
+
+
+##
+
+
+ASYNCIO_DEFAULT_BUFFER_LIMIT = 2 ** 16
+
+
+async def asyncio_open_stream_reader(
+        f: ta.IO,
+        loop: ta.Any = None,
+        *,
+        limit: int = ASYNCIO_DEFAULT_BUFFER_LIMIT,
+) -> asyncio.StreamReader:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    reader = asyncio.StreamReader(limit=limit, loop=loop)
+    await loop.connect_read_pipe(
+        lambda: asyncio.StreamReaderProtocol(reader, loop=loop),
+        f,
+    )
+
+    return reader
+
+
+async def asyncio_open_stream_writer(
+        f: ta.IO,
+        loop: ta.Any = None,
+) -> asyncio.StreamWriter:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    writer_transport, writer_protocol = await loop.connect_write_pipe(
+        lambda: asyncio.streams.FlowControlMixin(loop=loop),
+        f,
+    )
+
+    return asyncio.streams.StreamWriter(
+        writer_transport,
+        writer_protocol,
+        None,
+        loop,
+    )
+
+
+##
+
+
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: ta.Optional[float] = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+    return fut
+
+
 ########################################
 # ../../../omlish/lite/cached.py
 
 
-class _cached_nullary:  # noqa
+##
+
+
+class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
         self._fn = fn
@@ -486,17 +556,25 @@ class _cached_nullary:  # noqa
         functools.update_wrapper(self, fn)
 
     def __call__(self, *args, **kwargs):  # noqa
-        if self._value is self._missing:
-            self._value = self._fn()
-        return self._value
+        raise TypeError
 
     def __get__(self, instance, owner):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
 
+##
+
+
+class _CachedNullary(_AbstractCachedNullary):
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
+
+
 def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _cached_nullary(fn)
+    return _CachedNullary(fn)
 
 
 def static_init(fn: CallableT) -> CallableT:
@@ -505,6 +583,20 @@ def static_init(fn: CallableT) -> CallableT:
     return fn
 
 
+##
+
+
+class _AsyncCachedNullary(_AbstractCachedNullary):
+    async def __call__(self, *args, **kwargs):
+        if self._value is self._missing:
+            self._value = await self._fn()
+        return self._value
+
+
+def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _AsyncCachedNullary(fn)
+
+
 ########################################
 # ../../../omlish/lite/check.py
 
@@ -1637,6 +1729,8 @@ class InterpSpecifier:
         s, o = InterpOpts.parse_suffix(s)
         if not any(s.startswith(o) for o in Specifier.OPERATORS):
             s = '~=' + s
+            if s.count('.') < 2:
+                s += '.0'
         return cls(
             specifier=Specifier(s),
             opts=o,
@@ -1686,7 +1780,7 @@ def subprocess_maybe_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
         return args
 
 
-def _prepare_subprocess_invocation(
+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,
@@ -1694,9 +1788,9 @@ def _prepare_subprocess_invocation(
         shell: bool = False,
         **kwargs: ta.Any,
 ) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
-    log.debug(args)
+    log.debug('prepare_subprocess_invocation: args=%r', args)
     if extra_env:
-        log.debug(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}
@@ -1715,14 +1809,46 @@ def _prepare_subprocess_invocation(
     )
 
 
-def subprocess_check_call(*args: str, stdout=sys.stderr, **kwargs: ta.Any) -> None:
-    args, kwargs = _prepare_subprocess_invocation(*args, stdout=stdout, **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)
-    return subprocess.check_output(args, **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)
+
+
+##
+
+
+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
+
+
+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)
 
 
 def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
@@ -1738,16 +1864,31 @@ DEFAULT_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
 )
 
 
-def subprocess_try_call(
-        *args: str,
+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,
-) -> bool:
+) -> ta.Union[T, Exception]:
     try:
-        subprocess_check_call(*args, **kwargs)
+        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,
+            **kwargs,
+    ), Exception):
         return False
     else:
         return True
@@ -1758,12 +1899,15 @@ def subprocess_try_output(
         try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
         **kwargs: ta.Any,
 ) -> ta.Optional[bytes]:
-    try:
-        return subprocess_check_output(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
+    if isinstance(ret := _subprocess_try_run(
+            subprocess_check_output,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
         return None
+    else:
+        return ret
 
 
 def subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
@@ -1789,6 +1933,285 @@ def subprocess_close(
     proc.wait(timeout)
 
 
+########################################
+# ../../../omlish/lite/asyncio/subprocesses.py
+
+
+##
+
+
+@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,
+            proc: asyncio.subprocess.Process,
+            loop: ta.Optional[ta.Any] = None,
+    ) -> None:
+        super().__init__()
+
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        self._proc = proc
+        self._loop = loop
+
+        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check_isinstance(
+            proc._transport,  # type: ignore  # noqa
+            asyncio.base_subprocess.BaseSubprocessTransport,
+        )
+
+    @property
+    def _debug(self) -> bool:
+        return self._loop.get_debug()
+
+    async def _feed_stdin(self, input: bytes) -> None:  # noqa
+        stdin = check_not_none(self._proc.stdin)
+        try:
+            if input is not None:
+                stdin.write(input)
+                if self._debug:
+                    log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
+
+            await stdin.drain()
+
+        except (BrokenPipeError, ConnectionResetError) as exc:
+            # communicate() ignores BrokenPipeError and ConnectionResetError. write() and drain() can raise these
+            # exceptions.
+            if self._debug:
+                log.debug('%r communicate: stdin got %r', self, exc)
+
+        if self._debug:
+            log.debug('%r communicate: close stdin', self)
+
+        stdin.close()
+
+    async def _noop(self) -> None:
+        return None
+
+    async def _read_stream(self, fd: int) -> bytes:
+        transport: ta.Any = check_not_none(self._transport.get_pipe_transport(fd))
+
+        if fd == 2:
+            stream = check_not_none(self._proc.stderr)
+        else:
+            check_equal(fd, 1)
+            stream = check_not_none(self._proc.stdout)
+
+        if self._debug:
+            name = 'stdout' if fd == 1 else 'stderr'
+            log.debug('%r communicate: read %s', self, name)
+
+        output = await stream.read()
+
+        if self._debug:
+            name = 'stdout' if fd == 1 else 'stderr'
+            log.debug('%r communicate: close %s', self, name)
+
+        transport.close()
+
+        return output
+
+    class Communication(ta.NamedTuple):
+        stdout: ta.Optional[bytes]
+        stderr: ta.Optional[bytes]
+
+    async def _communicate(
+            self,
+            input: ta.Any = None,  # noqa
+    ) -> Communication:
+        stdin_fut: ta.Any
+        if self._proc.stdin is not None:
+            stdin_fut = self._feed_stdin(input)
+        else:
+            stdin_fut = self._noop()
+
+        stdout_fut: ta.Any
+        if self._proc.stdout is not None:
+            stdout_fut = self._read_stream(1)
+        else:
+            stdout_fut = self._noop()
+
+        stderr_fut: ta.Any
+        if self._proc.stderr is not None:
+            stderr_fut = self._read_stream(2)
+        else:
+            stderr_fut = self._noop()
+
+        stdin_res, stdout_res, stderr_res = await asyncio.gather(stdin_fut, stdout_fut, stderr_fut)
+
+        await self._proc.wait()
+
+        return AsyncioProcessCommunicator.Communication(stdout_res, stderr_res)
+
+    async def communicate(
+            self,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+    ) -> Communication:
+        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
+
+
+##
+
+
+async def _asyncio_subprocess_check_run(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+    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 proc.returncode:
+        raise subprocess.CalledProcessError(
+            proc.returncode,
+            args,
+            output=stdout,
+            stderr=stderr,
+        )
+
+    return stdout, stderr
+
+
+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_check_run(
+        *args,
+        stdout=stdout,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+
+async def asyncio_subprocess_check_output(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> bytes:
+    stdout, stderr = await _asyncio_subprocess_check_run(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+    return check_not_none(stdout)
+
+
+async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
+    return (await asyncio_subprocess_check_output(*args, **kwargs)).decode().strip()
+
+
+##
+
+
+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 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
+
+
 ########################################
 # ../inspect.py
 
@@ -1823,7 +2246,6 @@ class InterpInspection:
 
 
 class InterpInspector:
-
     def __init__(self) -> None:
         super().__init__()
 
@@ -1863,17 +2285,17 @@ class InterpInspector:
     def running(cls) -> 'InterpInspection':
         return cls._build_inspection(sys.executable, eval(cls._INSPECTION_CODE))  # noqa
 
-    def _inspect(self, exe: str) -> InterpInspection:
-        output = subprocess_check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
+    async def _inspect(self, exe: str) -> InterpInspection:
+        output = await asyncio_subprocess_check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
         return self._build_inspection(exe, output.decode())
 
-    def inspect(self, exe: str) -> ta.Optional[InterpInspection]:
+    async def inspect(self, exe: str) -> ta.Optional[InterpInspection]:
         try:
             return self._cache[exe]
         except KeyError:
             ret: ta.Optional[InterpInspection]
             try:
-                ret = self._inspect(exe)
+                ret = await self._inspect(exe)
             except Exception as e:  # noqa
                 if log.isEnabledFor(logging.DEBUG):
                     log.exception('Failed to inspect interp: %s', exe)
@@ -1912,17 +2334,17 @@ class InterpProvider(abc.ABC):
             setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
 
     @abc.abstractmethod
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Awaitable[ta.Sequence[InterpVersion]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get_installed_version(self, version: InterpVersion) -> Interp:
+    def get_installed_version(self, version: InterpVersion) -> ta.Awaitable[Interp]:
         raise NotImplementedError
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         return []
 
-    def install_version(self, version: InterpVersion) -> Interp:
+    async def install_version(self, version: InterpVersion) -> Interp:
         raise TypeError
 
 
@@ -1934,10 +2356,10 @@ class RunningInterpProvider(InterpProvider):
     def version(self) -> InterpVersion:
         return InterpInspector.running().iv
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         return [self.version()]
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
         if version != self.version():
             raise KeyError(version)
         return Interp(
@@ -1965,7 +2387,6 @@ TODO:
 
 
 class Pyenv:
-
     def __init__(
             self,
             *,
@@ -1978,13 +2399,13 @@ class Pyenv:
 
         self._root_kw = root
 
-    @cached_nullary
-    def root(self) -> ta.Optional[str]:
+    @async_cached_nullary
+    async def root(self) -> ta.Optional[str]:
         if self._root_kw is not None:
             return self._root_kw
 
         if shutil.which('pyenv'):
-            return subprocess_check_output_str('pyenv', 'root')
+            return await asyncio_subprocess_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')):
@@ -1992,12 +2413,12 @@ class Pyenv:
 
         return None
 
-    @cached_nullary
-    def exe(self) -> str:
-        return os.path.join(check_not_none(self.root()), 'bin', 'pyenv')
+    @async_cached_nullary
+    async def exe(self) -> str:
+        return os.path.join(check_not_none(await self.root()), 'bin', 'pyenv')
 
-    def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
-        if (root := self.root()) is None:
+    async def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
+        if (root := await self.root()) is None:
             return []
         ret = []
         vp = os.path.join(root, 'versions')
@@ -2009,11 +2430,11 @@ class Pyenv:
                 ret.append((dn, ep))
         return ret
 
-    def installable_versions(self) -> ta.List[str]:
-        if self.root() is None:
+    async def installable_versions(self) -> ta.List[str]:
+        if await self.root() is None:
             return []
         ret = []
-        s = subprocess_check_output_str(self.exe(), 'install', '--list')
+        s = await asyncio_subprocess_check_output_str(await self.exe(), 'install', '--list')
         for l in s.splitlines():
             if not l.startswith('  '):
                 continue
@@ -2023,12 +2444,12 @@ class Pyenv:
             ret.append(l)
         return ret
 
-    def update(self) -> bool:
-        if (root := self.root()) is None:
+    async def update(self) -> bool:
+        if (root := await self.root()) is None:
             return False
         if not os.path.isdir(os.path.join(root, '.git')):
             return False
-        subprocess_check_call('git', 'pull', cwd=root)
+        await asyncio_subprocess_check_call('git', 'pull', cwd=root)
         return True
 
 
@@ -2089,17 +2510,16 @@ THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
 
 class PyenvInstallOptsProvider(abc.ABC):
     @abc.abstractmethod
-    def opts(self) -> PyenvInstallOpts:
+    def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
         raise NotImplementedError
 
 
 class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
-    def opts(self) -> PyenvInstallOpts:
+    async def opts(self) -> PyenvInstallOpts:
         return PyenvInstallOpts()
 
 
 class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
-
     @cached_nullary
     def framework_opts(self) -> PyenvInstallOpts:
         return PyenvInstallOpts(conf_opts=['--enable-framework'])
@@ -2115,12 +2535,12 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
         'zlib',
     ]
 
-    @cached_nullary
-    def brew_deps_opts(self) -> PyenvInstallOpts:
+    @async_cached_nullary
+    async def brew_deps_opts(self) -> PyenvInstallOpts:
         cflags = []
         ldflags = []
         for dep in self.BREW_DEPS:
-            dep_prefix = subprocess_check_output_str('brew', '--prefix', dep)
+            dep_prefix = await asyncio_subprocess_check_output_str('brew', '--prefix', dep)
             cflags.append(f'-I{dep_prefix}/include')
             ldflags.append(f'-L{dep_prefix}/lib')
         return PyenvInstallOpts(
@@ -2128,13 +2548,13 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
             ldflags=ldflags,
         )
 
-    @cached_nullary
-    def brew_tcl_opts(self) -> PyenvInstallOpts:
-        if subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
+    @async_cached_nullary
+    async def brew_tcl_opts(self) -> PyenvInstallOpts:
+        if await asyncio_subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
             return PyenvInstallOpts()
 
-        tcl_tk_prefix = subprocess_check_output_str('brew', '--prefix', 'tcl-tk')
-        tcl_tk_ver_str = subprocess_check_output_str('brew', 'ls', '--versions', 'tcl-tk')
+        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_ver = '.'.join(tcl_tk_ver_str.split()[1].split('.')[:2])
 
         return PyenvInstallOpts(conf_opts=[
@@ -2149,11 +2569,11 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
     #         pkg_config_path += ':' + os.environ['PKG_CONFIG_PATH']
     #     return PyenvInstallOpts(env={'PKG_CONFIG_PATH': pkg_config_path})
 
-    def opts(self) -> PyenvInstallOpts:
+    async def opts(self) -> PyenvInstallOpts:
         return PyenvInstallOpts().merge(
             self.framework_opts(),
-            self.brew_deps_opts(),
-            self.brew_tcl_opts(),
+            await self.brew_deps_opts(),
+            await self.brew_tcl_opts(),
             # self.brew_ssl_opts(),
         )
 
@@ -2185,20 +2605,8 @@ class PyenvVersionInstaller:
     ) -> None:
         super().__init__()
 
-        if no_default_opts:
-            if opts is None:
-                opts = PyenvInstallOpts()
-        else:
-            lst = [opts if opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
-            if interp_opts.debug:
-                lst.append(DEBUG_PYENV_INSTALL_OPTS)
-            if interp_opts.threaded:
-                lst.append(THREADED_PYENV_INSTALL_OPTS)
-            lst.append(PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
-            opts = PyenvInstallOpts().merge(*lst)
-
         self._version = version
-        self._opts = opts
+        self._given_opts = opts
         self._interp_opts = interp_opts
         self._given_install_name = install_name
 
@@ -2209,9 +2617,21 @@ class PyenvVersionInstaller:
     def version(self) -> str:
         return self._version
 
-    @property
-    def opts(self) -> PyenvInstallOpts:
-        return self._opts
+    @async_cached_nullary
+    async def opts(self) -> PyenvInstallOpts:
+        opts = self._given_opts
+        if self._no_default_opts:
+            if opts is None:
+                opts = PyenvInstallOpts()
+        else:
+            lst = [self._given_opts if self._given_opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
+            if self._interp_opts.debug:
+                lst.append(DEBUG_PYENV_INSTALL_OPTS)
+            if self._interp_opts.threaded:
+                lst.append(THREADED_PYENV_INSTALL_OPTS)
+            lst.append(await PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
+            opts = PyenvInstallOpts().merge(*lst)
+        return opts
 
     @cached_nullary
     def install_name(self) -> str:
@@ -2219,17 +2639,18 @@ class PyenvVersionInstaller:
             return self._given_install_name
         return self._version + ('-debug' if self._interp_opts.debug else '')
 
-    @cached_nullary
-    def install_dir(self) -> str:
-        return str(os.path.join(check_not_none(self._pyenv.root()), 'versions', self.install_name()))
+    @async_cached_nullary
+    async def install_dir(self) -> str:
+        return str(os.path.join(check_not_none(await self._pyenv.root()), 'versions', self.install_name()))
 
-    @cached_nullary
-    def install(self) -> str:
-        env = {**os.environ, **self._opts.env}
+    @async_cached_nullary
+    async def install(self) -> str:
+        opts = await self.opts()
+        env = {**os.environ, **opts.env}
         for k, l in [
-            ('CFLAGS', self._opts.cflags),
-            ('LDFLAGS', self._opts.ldflags),
-            ('PYTHON_CONFIGURE_OPTS', self._opts.conf_opts),
+            ('CFLAGS', opts.cflags),
+            ('LDFLAGS', opts.ldflags),
+            ('PYTHON_CONFIGURE_OPTS', opts.conf_opts),
         ]:
             v = ' '.join(l)
             if k in os.environ:
@@ -2237,13 +2658,13 @@ class PyenvVersionInstaller:
             env[k] = v
 
         conf_args = [
-            *self._opts.opts,
+            *opts.opts,
             self._version,
         ]
 
         if self._given_install_name is not None:
             full_args = [
-                os.path.join(check_not_none(self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),
+                os.path.join(check_not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
                 *conf_args,
                 self.install_dir(),
             ]
@@ -2254,12 +2675,12 @@ class PyenvVersionInstaller:
                 *conf_args,
             ]
 
-        subprocess_check_call(
+        await asyncio_subprocess_check_call(
             *full_args,
             env=env,
         )
 
-        exe = os.path.join(self.install_dir(), 'bin', 'python')
+        exe = os.path.join(await self.install_dir(), 'bin', 'python')
         if not os.path.isfile(exe):
             raise RuntimeError(f'Interpreter not found: {exe}')
         return exe
@@ -2269,7 +2690,6 @@ class PyenvVersionInstaller:
 
 
 class PyenvInterpProvider(InterpProvider):
-
     def __init__(
             self,
             pyenv: Pyenv = Pyenv(),
@@ -2312,11 +2732,11 @@ class PyenvInterpProvider(InterpProvider):
         exe: str
         version: InterpVersion
 
-    def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
+    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
         iv: ta.Optional[InterpVersion]
         if self._inspect:
             try:
-                iv = check_not_none(self._inspector.inspect(ep)).iv
+                iv = check_not_none(await self._inspector.inspect(ep)).iv
             except Exception as e:  # noqa
                 return None
         else:
@@ -2329,10 +2749,10 @@ class PyenvInterpProvider(InterpProvider):
             version=iv,
         )
 
-    def installed(self) -> ta.Sequence[Installed]:
+    async def installed(self) -> ta.Sequence[Installed]:
         ret: ta.List[PyenvInterpProvider.Installed] = []
-        for vn, ep in self._pyenv.version_exes():
-            if (i := self._make_installed(vn, ep)) is None:
+        for vn, ep in await self._pyenv.version_exes():
+            if (i := await self._make_installed(vn, ep)) is None:
                 log.debug('Invalid pyenv version: %s', vn)
                 continue
             ret.append(i)
@@ -2340,11 +2760,11 @@ class PyenvInterpProvider(InterpProvider):
 
     #
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [i.version for i in self.installed()]
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in await self.installed()]
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        for i in self.installed():
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for i in await self.installed():
             if i.version == version:
                 return Interp(
                     exe=i.exe,
@@ -2354,10 +2774,10 @@ class PyenvInterpProvider(InterpProvider):
 
     #
 
-    def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         lst = []
 
-        for vs in self._pyenv.installable_versions():
+        for vs in await self._pyenv.installable_versions():
             if (iv := self.guess_version(vs)) is None:
                 continue
             if iv.opts.debug:
@@ -2367,16 +2787,16 @@ class PyenvInterpProvider(InterpProvider):
 
         return lst
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = self._get_installable_versions(spec)
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = await self._get_installable_versions(spec)
 
         if self._try_update and not any(v in spec for v in lst):
             if self._pyenv.update():
-                lst = self._get_installable_versions(spec)
+                lst = await self._get_installable_versions(spec)
 
         return lst
 
-    def install_version(self, version: InterpVersion) -> Interp:
+    async def install_version(self, version: InterpVersion) -> Interp:
         inst_version = str(version.version)
         inst_opts = version.opts
         if inst_opts.threaded:
@@ -2388,7 +2808,7 @@ class PyenvInterpProvider(InterpProvider):
             interp_opts=inst_opts,
         )
 
-        exe = installer.install()
+        exe = await installer.install()
         return Interp(exe, version)
 
 
@@ -2467,7 +2887,7 @@ class SystemInterpProvider(InterpProvider):
 
     #
 
-    def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
         if not self.inspect:
             s = os.path.basename(exe)
             if s.startswith('python'):
@@ -2477,13 +2897,13 @@ class SystemInterpProvider(InterpProvider):
                     return InterpVersion.parse(s)
                 except InvalidVersion:
                     pass
-        ii = self.inspector.inspect(exe)
+        ii = await self.inspector.inspect(exe)
         return ii.iv if ii is not None else None
 
-    def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
+    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
         lst = []
         for e in self.exes():
-            if (ev := self.get_exe_version(e)) is None:
+            if (ev := await self.get_exe_version(e)) is None:
                 log.debug('Invalid system version: %s', e)
                 continue
             lst.append((e, ev))
@@ -2491,11 +2911,11 @@ class SystemInterpProvider(InterpProvider):
 
     #
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in self.exe_versions()]
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [ev for e, ev in await self.exe_versions()]
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        for e, ev in self.exe_versions():
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for e, ev in await self.exe_versions():
             if ev != version:
                 continue
             return Interp(
@@ -2520,13 +2940,14 @@ class InterpResolver:
             providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
     ) -> None:
         super().__init__()
+
         self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
 
-    def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
+    async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
         lst = [
             (i, si)
             for i, p in enumerate(self._providers.values())
-            for si in p.get_installed_versions(spec)
+            for si in await p.get_installed_versions(spec)
             if spec.contains(si)
         ]
 
@@ -2538,16 +2959,16 @@ class InterpResolver:
         bp = list(self._providers.values())[bi]
         return (bp, bv)
 
-    def resolve(
+    async def resolve(
             self,
             spec: InterpSpecifier,
             *,
             install: bool = False,
     ) -> ta.Optional[Interp]:
-        tup = self._resolve_installed(spec)
+        tup = await self._resolve_installed(spec)
         if tup is not None:
             bp, bv = tup
-            return bp.get_installed_version(bv)
+            return await bp.get_installed_version(bv)
 
         if not install:
             return None
@@ -2555,21 +2976,21 @@ class InterpResolver:
         tp = list(self._providers.values())[0]  # noqa
 
         sv = sorted(
-            [s for s in tp.get_installable_versions(spec) if s in spec],
+            [s for s in await tp.get_installable_versions(spec) if s in spec],
             key=lambda s: s.version,
         )
         if not sv:
             return None
 
         bv = sv[-1]
-        return tp.install_version(bv)
+        return await tp.install_version(bv)
 
-    def list(self, spec: InterpSpecifier) -> None:
+    async def list(self, spec: InterpSpecifier) -> None:
         print('installed:')
         for n, p in self._providers.items():
             lst = [
                 si
-                for si in p.get_installed_versions(spec)
+                for si in await p.get_installed_versions(spec)
                 if spec.contains(si)
             ]
             if lst:
@@ -2583,7 +3004,7 @@ class InterpResolver:
         for n, p in self._providers.items():
             lst = [
                 si
-                for si in p.get_installable_versions(spec)
+                for si in await p.get_installable_versions(spec)
                 if spec.contains(si)
             ]
             if lst:
@@ -2606,20 +3027,20 @@ DEFAULT_INTERP_RESOLVER = InterpResolver([(p.name, p) for p in [
 # cli.py
 
 
-def _list_cmd(args) -> None:
+async def _list_cmd(args) -> None:
     r = DEFAULT_INTERP_RESOLVER
     s = InterpSpecifier.parse(args.version)
-    r.list(s)
+    await r.list(s)
 
 
-def _resolve_cmd(args) -> None:
+async def _resolve_cmd(args) -> None:
     if args.provider:
         p = INTERP_PROVIDER_TYPES_BY_NAME[args.provider]()
         r = InterpResolver([(p.name, p)])
     else:
         r = DEFAULT_INTERP_RESOLVER
     s = InterpSpecifier.parse(args.version)
-    print(check_not_none(r.resolve(s, install=bool(args.install))).exe)
+    print(check_not_none(await r.resolve(s, install=bool(args.install))).exe)
 
 
 def _build_parser() -> argparse.ArgumentParser:
@@ -2642,7 +3063,7 @@ def _build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+async def _async_main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
     check_runtime_version()
     configure_standard_logging()
 
@@ -2651,7 +3072,11 @@ def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
     if not getattr(args, 'func', None):
         parser.print_help()
     else:
-        args.func(args)
+        await args.func(args)
+
+
+def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+    asyncio.run(_async_main(argv))
 
 
 if __name__ == '__main__':