omdev 0.0.0.dev146__tar.gz → 0.0.0.dev148__tar.gz

{omdev-0.0.0.dev146/omdev.egg-info → omdev-0.0.0.dev148}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omdev
-Version: 0.0.0.dev146
+Version: 0.0.0.dev148
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev146
+Requires-Dist: omlish==0.0.0.dev148
 Provides-Extra: all
 Requires-Dist: black~=24.10; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/.manifests.json

@@ -107,6 +107,18 @@
       }
     }
   },
+  {
+    "module": ".manifests.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omdev/manifests/__main__.py",
+    "line": 4,
+    "value": {
+      "$.cli.types.CliModule": {
+        "cmd_name": "manifests",
+        "mod_name": "omdev.manifests.__main__"
+      }
+    }
+  },
   {
     "module": ".precheck.__main__",
     "attr": "_CLI_MODULE",

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/interp/cli.py

@@ -8,6 +8,7 @@ TODO:
  - colon sep provider name prefix - pyenv:3.12
 """
 import argparse
+import asyncio
 import typing as ta
 
 from omlish.lite.check import check_not_none
@@ -20,20 +21,20 @@ from .resolvers import InterpResolver
 from .types import InterpSpecifier
 
 
-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:
@@ -56,7 +57,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()
 
@@ -65,7 +66,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__':

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/interp/inspect.py

@@ -5,8 +5,8 @@ import logging
 import sys
 import typing as ta
 
+from omlish.lite.asyncio.subprocesses import asyncio_subprocess_check_output
 from omlish.lite.logs import log
-from omlish.lite.subprocesses import subprocess_check_output
 
 from ..packaging.versions import Version
 from .types import InterpOpts
@@ -43,7 +43,6 @@ class InterpInspection:
 
 
 class InterpInspector:
-
     def __init__(self) -> None:
         super().__init__()
 
@@ -83,17 +82,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)

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/interp/providers.py

@@ -34,17 +34,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
 
 
@@ -56,10 +56,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(

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/interp/pyenv.py

@@ -18,12 +18,13 @@ import shutil
 import sys
 import typing as ta
 
+from omlish.lite.asyncio.subprocesses import asyncio_subprocess_check_call
+from omlish.lite.asyncio.subprocesses import asyncio_subprocess_check_output_str
+from omlish.lite.asyncio.subprocesses import asyncio_subprocess_try_output
+from omlish.lite.cached import async_cached_nullary
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check_not_none
 from omlish.lite.logs import log
-from omlish.lite.subprocesses import subprocess_check_call
-from omlish.lite.subprocesses import subprocess_check_output_str
-from omlish.lite.subprocesses import subprocess_try_output
 
 from ..packaging.versions import InvalidVersion
 from ..packaging.versions import Version
@@ -40,7 +41,6 @@ from .types import InterpVersion
 
 
 class Pyenv:
-
     def __init__(
             self,
             *,
@@ -53,13 +53,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')):
@@ -67,12 +67,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')
@@ -84,11 +84,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
@@ -98,12 +98,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
 
 
@@ -164,17 +164,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'])
@@ -190,12 +189,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(
@@ -203,13 +202,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=[
@@ -224,11 +223,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(),
         )
 
@@ -260,20 +259,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
 
@@ -284,9 +271,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:
@@ -294,17 +293,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:
@@ -312,13 +312,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(),
             ]
@@ -329,12 +329,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
@@ -344,7 +344,6 @@ class PyenvVersionInstaller:
 
 
 class PyenvInterpProvider(InterpProvider):
-
     def __init__(
             self,
             pyenv: Pyenv = Pyenv(),
@@ -387,11 +386,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:
@@ -404,10 +403,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)
@@ -415,11 +414,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,
@@ -429,10 +428,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:
@@ -442,16 +441,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:
@@ -463,5 +462,5 @@ class PyenvInterpProvider(InterpProvider):
             interp_opts=inst_opts,
         )
 
-        exe = installer.install()
+        exe = await installer.install()
         return Interp(exe, version)

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/interp/resolvers.py

@@ -25,13 +25,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)
         ]
 
@@ -43,16 +44,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
@@ -60,21 +61,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:
@@ -88,7 +89,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:

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/interp/system.py

@@ -87,7 +87,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'):
@@ -97,13 +97,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))
@@ -111,11 +111,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(

{omdev-0.0.0.dev146 → omdev-0.0.0.dev148}/omdev/interp/types.py

@@ -77,6 +77,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,

omdev-0.0.0.dev148/omdev/manifests/__main__.py

@@ -0,0 +1,11 @@
+from ..cli import CliModule
+
+
+# @omlish-manifest
+_CLI_MODULE = CliModule('manifests', __name__)
+
+
+if __name__ == '__main__':
+    from .main import _main  # noqa
+
+    _main()