omdev 0.0.0.dev178__py3-none-any.whl → 0.0.0.dev179__py3-none-any.whl

omdev/amalg/main.py

@@ -5,6 +5,7 @@ Conventions:
 
 TODO:
  - !! check only importing lite code
+ - check no rel impots
  - !! strip manifests? or relegate them to a separate tiny module ala __main__.py?
   - # @omlish-no-amalg ? in cli.types? will strip stmt (more than 1 line) following @manifest, so shouldn't import
  - more sanity checks lol

omdev/cexts/importhook.py

@@ -26,7 +26,7 @@ def load_dynamic(name: str, path: str) -> types.ModuleType:
     spec = importlib.machinery.ModuleSpec(name=name, loader=loader, origin=path)
 
     import importlib._bootstrap  # FIXME:  # noqa
-    return importlib._bootstrap._load(spec)  # noqa
+    return importlib._bootstrap._load(spec)  # type: ignore  # noqa
 
 
 ##

omdev/interp/cli.py

@@ -7,66 +7,67 @@ TODO:
  - https://github.com/asdf-vm/asdf support (instead of pyenv) ?
  - colon sep provider name prefix - pyenv:3.12
 """
-import argparse
 import asyncio
 import typing as ta
 
+from omlish.argparse.cli import ArgparseCli
+from omlish.argparse.cli import argparse_arg
+from omlish.argparse.cli import argparse_command
+from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
+from omlish.lite.inject import Injector
+from omlish.lite.inject import inj
 from omlish.lite.runtime import check_lite_runtime_version
 from omlish.logs.standard import configure_standard_logging
 
-from .resolvers import DEFAULT_INTERP_RESOLVER
-from .resolvers import INTERP_PROVIDER_TYPES_BY_NAME
+from .inject import bind_interp
 from .resolvers import InterpResolver
+from .resolvers import InterpResolverProviders
 from .types import InterpSpecifier
 
 
-async def _list_cmd(args) -> None:
-    r = DEFAULT_INTERP_RESOLVER
-    s = InterpSpecifier.parse(args.version)
-    await r.list(s)
-
-
-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(await r.resolve(s, install=bool(args.install))).exe)
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser()
-
-    subparsers = parser.add_subparsers()
-
-    parser_list = subparsers.add_parser('list')
-    parser_list.add_argument('version')
-    parser_list.add_argument('-d', '--debug', action='store_true')
-    parser_list.set_defaults(func=_list_cmd)
-
-    parser_resolve = subparsers.add_parser('resolve')
-    parser_resolve.add_argument('version')
-    parser_resolve.add_argument('-p', '--provider')
-    parser_resolve.add_argument('-d', '--debug', action='store_true')
-    parser_resolve.add_argument('-i', '--install', action='store_true')
-    parser_resolve.set_defaults(func=_resolve_cmd)
-
-    return parser
+class InterpCli(ArgparseCli):
+    @cached_nullary
+    def injector(self) -> Injector:
+        return inj.create_injector(bind_interp())
+
+    @cached_nullary
+    def providers(self) -> InterpResolverProviders:
+        return self.injector()[InterpResolverProviders]
+
+    #
+
+    @argparse_command(
+        argparse_arg('version'),
+        argparse_arg('-d', '--debug', action='store_true'),
+    )
+    async def list(self) -> None:
+        r = InterpResolver(self.providers())
+        s = InterpSpecifier.parse(self.args.version)
+        await r.list(s)
+
+    @argparse_command(
+        argparse_arg('version'),
+        argparse_arg('-p', '--provider'),
+        argparse_arg('-d', '--debug', action='store_true'),
+        argparse_arg('-i', '--install', action='store_true'),
+    )
+    async def resolve(self) -> None:
+        if self.args.provider:
+            p = check.single([p for n, p in self.providers().providers if n == self.args.provider])
+            r = InterpResolver(InterpResolverProviders([(p.name, p)]))
+        else:
+            r = InterpResolver(self.providers())
+        s = InterpSpecifier.parse(self.args.version)
+        print(check.not_none(await r.resolve(s, install=bool(self.args.install))).exe)
 
 
 async def _async_main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
     check_lite_runtime_version()
     configure_standard_logging()
 
-    parser = _build_parser()
-    args = parser.parse_args(argv)
-    if not getattr(args, 'func', None):
-        parser.print_help()
-    else:
-        await args.func(args)
+    cli = ArgparseCli(argv)
+    await cli.async_cli_run()
 
 
 def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:

omdev/interp/default.py

@@ -0,0 +1,10 @@
+from omlish.lite.cached import cached_nullary
+from omlish.lite.inject import inj
+
+from .inject import bind_interp
+from .resolvers import InterpResolver
+
+
+@cached_nullary
+def get_default_interp_resolver() -> InterpResolver:
+    return inj.create_injector(bind_interp())[InterpResolver]

omdev/interp/inject.py

@@ -0,0 +1,54 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.inject import Injector
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+
+from .inspect import InterpInspector
+from .providers.inject import bind_interp_providers
+from .providers.running import RunningInterpProvider
+from .providers.system import SystemInterpProvider
+from .pyenv.inject import bind_interp_pyenv
+from .pyenv.pyenv import PyenvInterpProvider
+from .resolvers import InterpResolver
+from .resolvers import InterpResolverProviders
+from .uv.inject import bind_interp_uv
+
+
+def bind_interp() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        bind_interp_providers(),
+
+        bind_interp_pyenv(),
+
+        bind_interp_uv(),
+
+        inj.bind(InterpInspector, singleton=True),
+    ]
+
+    #
+
+    def provide_interp_resolver_providers(injector: Injector) -> InterpResolverProviders:
+        # FIXME: lol
+        rps: ta.List[ta.Any] = [
+            injector.provide(c)
+            for c in [
+                PyenvInterpProvider,
+                RunningInterpProvider,
+                SystemInterpProvider,
+            ]
+        ]
+
+        return InterpResolverProviders([(rp.name, rp) for rp in rps])
+
+    lst.append(inj.bind(provide_interp_resolver_providers, singleton=True))
+
+    lst.extend([
+        inj.bind(InterpResolver, singleton=True),
+    ])
+
+    #
+
+    return inj.as_bindings(*lst)

omdev/interp/inspect.py

@@ -99,6 +99,3 @@ class InterpInspector:
                 ret = None
             self._cache[exe] = ret
             return ret
-
-
-INTERP_INSPECTOR = InterpInspector()

omdev/interp/{providers.py → providers/base.py}

@@ -7,16 +7,13 @@ TODO:
  - loose versions
 """
 import abc
-import sys
 import typing as ta
 
-from omlish.lite.cached import cached_nullary
 from omlish.lite.strings import snake_case
 
-from .inspect import InterpInspector
-from .types import Interp
-from .types import InterpSpecifier
-from .types import InterpVersion
+from ..types import Interp
+from ..types import InterpSpecifier
+from ..types import InterpVersion
 
 
 ##
@@ -48,21 +45,4 @@ class InterpProvider(abc.ABC):
         raise TypeError
 
 
-##
-
-
-class RunningInterpProvider(InterpProvider):
-    @cached_nullary
-    def version(self) -> InterpVersion:
-        return InterpInspector.running().iv
-
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [self.version()]
-
-    async def get_installed_version(self, version: InterpVersion) -> Interp:
-        if version != self.version():
-            raise KeyError(version)
-        return Interp(
-            exe=sys.executable,
-            version=self.version(),
-        )
+InterpProviders = ta.NewType('InterpProviders', ta.Sequence[InterpProvider])

omdev/interp/providers/inject.py

@@ -0,0 +1,26 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+
+from .base import InterpProvider
+from .base import InterpProviders
+from .running import RunningInterpProvider
+from .system import SystemInterpProvider
+
+
+def bind_interp_providers() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(InterpProvider),
+        inj.bind_array_type(InterpProvider, InterpProviders),
+
+        inj.bind(RunningInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=RunningInterpProvider, array=True),
+
+        inj.bind(SystemInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=SystemInterpProvider, array=True),
+    ]
+
+    return inj.as_bindings(*lst)

omdev/interp/providers/running.py

@@ -0,0 +1,27 @@
+import sys
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+from ..inspect import InterpInspector
+from ..types import Interp
+from ..types import InterpSpecifier
+from ..types import InterpVersion
+from .base import InterpProvider
+
+
+class RunningInterpProvider(InterpProvider):
+    @cached_nullary
+    def version(self) -> InterpVersion:
+        return InterpInspector.running().iv
+
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [self.version()]
+
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        if version != self.version():
+            raise KeyError(version)
+        return Interp(
+            exe=sys.executable,
+            version=self.version(),
+        )

omdev/interp/{system.py → providers/system.py}

@@ -10,27 +10,39 @@ import re
 import typing as ta
 
 from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check
 from omlish.lite.logs import log
 
-from ..packaging.versions import InvalidVersion
-from .inspect import INTERP_INSPECTOR
-from .inspect import InterpInspector
-from .providers import InterpProvider
-from .types import Interp
-from .types import InterpSpecifier
-from .types import InterpVersion
+from ...packaging.versions import InvalidVersion
+from ..inspect import InterpInspector
+from ..types import Interp
+from ..types import InterpSpecifier
+from ..types import InterpVersion
+from .base import InterpProvider
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
 class SystemInterpProvider(InterpProvider):
-    cmd: str = 'python3'
-    path: ta.Optional[str] = None
+    @dc.dataclass(frozen=True)
+    class Options:
+        cmd: str = 'python3'  # FIXME: unused lol
+        path: ta.Optional[str] = None
 
-    inspect: bool = False
-    inspector: InterpInspector = INTERP_INSPECTOR
+        inspect: bool = False
+
+    def __init__(
+            self,
+            options: Options = Options(),
+            *,
+            inspector: ta.Optional[InterpInspector] = None,
+    ) -> None:
+        super().__init__()
+
+        self._options = options
+
+        self._inspector = inspector
 
     #
 
@@ -82,13 +94,13 @@ class SystemInterpProvider(InterpProvider):
     def exes(self) -> ta.List[str]:
         return self._re_which(
             re.compile(r'python3(\.\d+)?'),
-            path=self.path,
+            path=self._options.path,
         )
 
     #
 
     async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
-        if not self.inspect:
+        if not self._options.inspect:
             s = os.path.basename(exe)
             if s.startswith('python'):
                 s = s[len('python'):]
@@ -97,7 +109,7 @@ class SystemInterpProvider(InterpProvider):
                     return InterpVersion.parse(s)
                 except InvalidVersion:
                     pass
-        ii = await self.inspector.inspect(exe)
+        ii = await check.not_none(self._inspector).inspect(exe)
         return ii.iv if ii is not None else None
 
     async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:

omdev/interp/pyenv/inject.py

@@ -0,0 +1,21 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+
+from ..providers.base import InterpProvider
+from .pyenv import Pyenv
+from .pyenv import PyenvInterpProvider
+
+
+def bind_interp_pyenv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(Pyenv, singleton=True),
+
+        inj.bind(PyenvInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=PyenvInterpProvider, array=True),
+    ]
+
+    return inj.as_bindings(*lst)

omdev/interp/{pyenv.py → pyenv/pyenv.py}

@@ -24,15 +24,14 @@ from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 from omlish.lite.logs import log
 
-from ..packaging.versions import InvalidVersion
-from ..packaging.versions import Version
-from .inspect import INTERP_INSPECTOR
-from .inspect import InterpInspector
-from .providers import InterpProvider
-from .types import Interp
-from .types import InterpOpts
-from .types import InterpSpecifier
-from .types import InterpVersion
+from ...packaging.versions import InvalidVersion
+from ...packaging.versions import Version
+from ..inspect import InterpInspector
+from ..providers.base import InterpProvider
+from ..types import Interp
+from ..types import InterpOpts
+from ..types import InterpSpecifier
+from ..types import InterpVersion
 
 
 ##
@@ -251,9 +250,10 @@ class PyenvVersionInstaller:
             opts: ta.Optional[PyenvInstallOpts] = None,
             interp_opts: InterpOpts = InterpOpts(),
             *,
+            pyenv: Pyenv,
+
             install_name: ta.Optional[str] = None,
             no_default_opts: bool = False,
-            pyenv: Pyenv = Pyenv(),
     ) -> None:
         super().__init__()
 
@@ -343,26 +343,26 @@ class PyenvVersionInstaller:
 
 
 class PyenvInterpProvider(InterpProvider):
-    def __init__(
-            self,
-            pyenv: Pyenv = Pyenv(),
+    @dc.dataclass(frozen=True)
+    class Options:
+        inspect: bool = False
 
-            inspect: bool = False,
-            inspector: InterpInspector = INTERP_INSPECTOR,
+        try_update: bool = False
 
+    def __init__(
+            self,
+            options: Options = Options(),
             *,
-
-            try_update: bool = False,
+            pyenv: Pyenv,
+            inspector: InterpInspector,
     ) -> None:
         super().__init__()
 
-        self._pyenv = pyenv
+        self._options = options
 
-        self._inspect = inspect
+        self._pyenv = pyenv
         self._inspector = inspector
 
-        self._try_update = try_update
-
     #
 
     @staticmethod
@@ -387,7 +387,7 @@ class PyenvInterpProvider(InterpProvider):
 
     async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
         iv: ta.Optional[InterpVersion]
-        if self._inspect:
+        if self._options.inspect:
             try:
                 iv = check.not_none(await self._inspector.inspect(ep)).iv
             except Exception as e:  # noqa
@@ -443,7 +443,7 @@ class PyenvInterpProvider(InterpProvider):
     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._options.try_update and not any(v in spec for v in lst):
             if self._pyenv.update():
                 lst = await self._get_installable_versions(spec)
 
@@ -459,6 +459,7 @@ class PyenvInterpProvider(InterpProvider):
         installer = PyenvVersionInstaller(
             inst_version,
             interp_opts=inst_opts,
+            pyenv=self._pyenv,
         )
 
         exe = await installer.install()

omdev/interp/resolvers.py

@@ -1,32 +1,27 @@
 # ruff: noqa: UP006 UP007
-import abc
 import collections
+import dataclasses as dc
 import typing as ta
 
-from omlish.lite.reflect import deep_subclasses
-
-from .providers import InterpProvider
-from .providers import RunningInterpProvider
-from .pyenv import PyenvInterpProvider
-from .system import SystemInterpProvider
+from .providers.base import InterpProvider
 from .types import Interp
 from .types import InterpSpecifier
 from .types import InterpVersion
 
 
-INTERP_PROVIDER_TYPES_BY_NAME: ta.Mapping[str, ta.Type[InterpProvider]] = {
-    cls.name: cls for cls in deep_subclasses(InterpProvider) if abc.ABC not in cls.__bases__  # type: ignore
-}
+@dc.dataclass(frozen=True)
+class InterpResolverProviders:
+    providers: ta.Sequence[ta.Tuple[str, InterpProvider]]
 
 
 class InterpResolver:
     def __init__(
             self,
-            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
+            providers: InterpResolverProviders,
     ) -> None:
         super().__init__()
 
-        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
+        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers.providers)
 
     async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
         lst = [
@@ -96,13 +91,3 @@ class InterpResolver:
                 print(f'  {n}')
                 for si in lst:
                     print(f'    {si}')
-
-
-DEFAULT_INTERP_RESOLVER = InterpResolver([(p.name, p) for p in [
-    # pyenv is preferred to system interpreters as it tends to have more support for things like tkinter
-    PyenvInterpProvider(try_update=True),
-
-    RunningInterpProvider(),
-
-    SystemInterpProvider(),
-]])

omdev/interp/types.py

@@ -8,6 +8,9 @@ from ..packaging.versions import InvalidVersion
 from ..packaging.versions import Version
 
 
+##
+
+
 # See https://peps.python.org/pep-3149/
 INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
     ('debug', 'd'),
@@ -39,6 +42,9 @@ class InterpOpts:
         return s, cls(**kw)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class InterpVersion:
     version: Version
@@ -64,6 +70,9 @@ class InterpVersion:
             return None
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class InterpSpecifier:
     specifier: Specifier
@@ -91,6 +100,9 @@ class InterpSpecifier:
         return self.contains(iv)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class Interp:
     exe: str

omdev/interp/uv/inject.py

@@ -0,0 +1,12 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+
+
+def bind_interp_uv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = []
+
+    return inj.as_bindings(*lst)

omdev/interp/{uv.py → uv/uv.py}

@@ -7,10 +7,10 @@ python3 -m venv barf && barf/bin/pip install uv && barf/bin/uv venv --python 3.1
 """
 import typing as ta
 
-from .providers import InterpProvider
-from .types import Interp
-from .types import InterpSpecifier
-from .types import InterpVersion
+from ..providers.base import InterpProvider
+from ..types import Interp
+from ..types import InterpSpecifier
+from ..types import InterpVersion
 
 
 class PyenvInterpProvider(InterpProvider):

omdev/pyproject/venvs.py

@@ -9,7 +9,7 @@ from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 from omlish.lite.logs import log
 
-from ..interp.resolvers import DEFAULT_INTERP_RESOLVER
+from ..interp.default import get_default_interp_resolver
 from ..interp.types import InterpSpecifier
 from .configs import VenvConfig
 from .reqs import RequirementsRewriter
@@ -41,7 +41,7 @@ class Venv:
     @async_cached_nullary
     async def interp_exe(self) -> str:
         i = InterpSpecifier.parse(check.not_none(self._cfg.interp))
-        return check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=True)).exe
+        return check.not_none(await get_default_interp_resolver().resolve(i, install=True)).exe
 
     @cached_nullary
     def exe(self) -> str: