omdev 0.0.0.dev181__py3-none-any.whl → 0.0.0.dev183__py3-none-any.whl

omdev/interp/inject.py

@@ -11,7 +11,7 @@ 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 .pyenv.provider import PyenvInterpProvider
 from .resolvers import InterpResolver
 from .resolvers import InterpResolverProviders
 from .uv.inject import bind_interp_uv

omdev/interp/pyenv/inject.py

@@ -6,8 +6,8 @@ from omlish.lite.inject import InjectorBindings
 from omlish.lite.inject import inj
 
 from ..providers.base import InterpProvider
+from .provider import PyenvInterpProvider
 from .pyenv import Pyenv
-from .pyenv import PyenvInterpProvider
 
 
 def bind_interp_pyenv() -> InjectorBindings:

omdev/interp/pyenv/install.py

@@ -0,0 +1,251 @@
+# ruff: noqa: UP006 UP007
+import abc
+import dataclasses as dc
+import itertools
+import os.path
+import shutil
+import sys
+import typing as ta
+
+from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
+from omlish.lite.cached import async_cached_nullary
+from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check
+
+from ..types import InterpOpts
+from .pyenv import Pyenv
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PyenvInstallOpts:
+    opts: ta.Sequence[str] = ()
+    conf_opts: ta.Sequence[str] = ()
+    cflags: ta.Sequence[str] = ()
+    ldflags: ta.Sequence[str] = ()
+    env: ta.Mapping[str, str] = dc.field(default_factory=dict)
+
+    def merge(self, *others: 'PyenvInstallOpts') -> 'PyenvInstallOpts':
+        return PyenvInstallOpts(
+            opts=list(itertools.chain.from_iterable(o.opts for o in [self, *others])),
+            conf_opts=list(itertools.chain.from_iterable(o.conf_opts for o in [self, *others])),
+            cflags=list(itertools.chain.from_iterable(o.cflags for o in [self, *others])),
+            ldflags=list(itertools.chain.from_iterable(o.ldflags for o in [self, *others])),
+            env=dict(itertools.chain.from_iterable(o.env.items() for o in [self, *others])),
+        )
+
+
+# TODO: https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md#building-for-maximum-performance
+DEFAULT_PYENV_INSTALL_OPTS = PyenvInstallOpts(
+    opts=[
+        '-s',
+        '-v',
+        '-k',
+    ],
+    conf_opts=[
+        # FIXME: breaks on mac for older py's
+        '--enable-loadable-sqlite-extensions',
+
+        # '--enable-shared',
+
+        '--enable-optimizations',
+        '--with-lto',
+
+        # '--enable-profiling', # ?
+
+        # '--enable-ipv6', # ?
+    ],
+    cflags=[
+        # '-march=native',
+        # '-mtune=native',
+    ],
+)
+
+DEBUG_PYENV_INSTALL_OPTS = PyenvInstallOpts(opts=['-g'])
+
+THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
+
+
+#
+
+
+class PyenvInstallOptsProvider(abc.ABC):
+    @abc.abstractmethod
+    def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
+        raise NotImplementedError
+
+
+class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
+    async def opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts()
+
+
+class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
+    @cached_nullary
+    def framework_opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts(conf_opts=['--enable-framework'])
+
+    @cached_nullary
+    def has_brew(self) -> bool:
+        return shutil.which('brew') is not None
+
+    BREW_DEPS: ta.Sequence[str] = [
+        'openssl',
+        'readline',
+        'sqlite3',
+        'zlib',
+    ]
+
+    @async_cached_nullary
+    async def brew_deps_opts(self) -> PyenvInstallOpts:
+        cflags = []
+        ldflags = []
+        for dep in self.BREW_DEPS:
+            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(
+            cflags=cflags,
+            ldflags=ldflags,
+        )
+
+    @async_cached_nullary
+    async def brew_tcl_opts(self) -> PyenvInstallOpts:
+        if await asyncio_subprocesses.try_output('brew', '--prefix', 'tcl-tk') is None:
+            return PyenvInstallOpts()
+
+        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=[
+            f"--with-tcltk-includes='-I{tcl_tk_prefix}/include'",
+            f"--with-tcltk-libs='-L{tcl_tk_prefix}/lib -ltcl{tcl_tk_ver} -ltk{tcl_tk_ver}'",
+        ])
+
+    # @cached_nullary
+    # def brew_ssl_opts(self) -> PyenvInstallOpts:
+    #     pkg_config_path = subprocess_check_output_str('brew', '--prefix', 'openssl')
+    #     if 'PKG_CONFIG_PATH' in os.environ:
+    #         pkg_config_path += ':' + os.environ['PKG_CONFIG_PATH']
+    #     return PyenvInstallOpts(env={'PKG_CONFIG_PATH': pkg_config_path})
+
+    async def opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts().merge(
+            self.framework_opts(),
+            await self.brew_deps_opts(),
+            await self.brew_tcl_opts(),
+            # self.brew_ssl_opts(),
+        )
+
+
+PLATFORM_PYENV_INSTALL_OPTS: ta.Dict[str, PyenvInstallOptsProvider] = {
+    'darwin': DarwinPyenvInstallOpts(),
+    'linux': LinuxPyenvInstallOpts(),
+}
+
+
+##
+
+
+class PyenvVersionInstaller:
+    """
+    Messy: can install freethreaded build with a 't' suffixed version str _or_ by THREADED_PYENV_INSTALL_OPTS - need
+    latter to build custom interp with ft, need former to use canned / blessed interps. Muh.
+    """
+
+    def __init__(
+            self,
+            version: str,
+            opts: ta.Optional[PyenvInstallOpts] = None,
+            interp_opts: InterpOpts = InterpOpts(),
+            *,
+            pyenv: Pyenv,
+
+            install_name: ta.Optional[str] = None,
+            no_default_opts: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._version = version
+        self._given_opts = opts
+        self._interp_opts = interp_opts
+        self._given_install_name = install_name
+
+        self._no_default_opts = no_default_opts
+        self._pyenv = pyenv
+
+    @property
+    def version(self) -> str:
+        return self._version
+
+    @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:
+        if self._given_install_name is not None:
+            return self._given_install_name
+        return self._version + ('-debug' if self._interp_opts.debug else '')
+
+    @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()))
+
+    @async_cached_nullary
+    async def install(self) -> str:
+        opts = await self.opts()
+        env = {**os.environ, **opts.env}
+        for k, l in [
+            ('CFLAGS', opts.cflags),
+            ('LDFLAGS', opts.ldflags),
+            ('PYTHON_CONFIGURE_OPTS', opts.conf_opts),
+        ]:
+            v = ' '.join(l)
+            if k in os.environ:
+                v += ' ' + os.environ[k]
+            env[k] = v
+
+        conf_args = [
+            *opts.opts,
+            self._version,
+        ]
+
+        full_args: ta.List[str]
+        if self._given_install_name is not None:
+            full_args = [
+                os.path.join(check.not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
+                *conf_args,
+                await self.install_dir(),
+            ]
+        else:
+            full_args = [
+                await self._pyenv.exe(),
+                'install',
+                *conf_args,
+            ]
+
+        await asyncio_subprocesses.check_call(
+            *full_args,
+            env=env,
+        )
+
+        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

omdev/interp/pyenv/provider.py

@@ -0,0 +1,144 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import logging
+import typing as ta
+
+from omlish.lite.check import check
+
+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
+from .install import PyenvVersionInstaller
+from .pyenv import Pyenv
+
+
+class PyenvInterpProvider(InterpProvider):
+    @dc.dataclass(frozen=True)
+    class Options:
+        inspect: bool = False
+
+        try_update: bool = False
+
+    def __init__(
+            self,
+            options: Options = Options(),
+            *,
+            pyenv: Pyenv,
+            inspector: InterpInspector,
+            log: ta.Optional[logging.Logger] = None,
+    ) -> None:
+        super().__init__()
+
+        self._options = options
+
+        self._pyenv = pyenv
+        self._inspector = inspector
+        self._log = log
+
+    #
+
+    @staticmethod
+    def guess_version(s: str) -> ta.Optional[InterpVersion]:
+        def strip_sfx(s: str, sfx: str) -> ta.Tuple[str, bool]:
+            if s.endswith(sfx):
+                return s[:-len(sfx)], True
+            return s, False
+        ok = {}
+        s, ok['debug'] = strip_sfx(s, '-debug')
+        s, ok['threaded'] = strip_sfx(s, 't')
+        try:
+            v = Version(s)
+        except InvalidVersion:
+            return None
+        return InterpVersion(v, InterpOpts(**ok))
+
+    class Installed(ta.NamedTuple):
+        name: str
+        exe: str
+        version: InterpVersion
+
+    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
+        iv: ta.Optional[InterpVersion]
+        if self._options.inspect:
+            try:
+                iv = check.not_none(await self._inspector.inspect(ep)).iv
+            except Exception as e:  # noqa
+                return None
+        else:
+            iv = self.guess_version(vn)
+        if iv is None:
+            return None
+        return PyenvInterpProvider.Installed(
+            name=vn,
+            exe=ep,
+            version=iv,
+        )
+
+    async def installed(self) -> ta.Sequence[Installed]:
+        ret: ta.List[PyenvInterpProvider.Installed] = []
+        for vn, ep in await self._pyenv.version_exes():
+            if (i := await self._make_installed(vn, ep)) is None:
+                if self._log is not None:
+                    self._log.debug('Invalid pyenv version: %s', vn)
+                continue
+            ret.append(i)
+        return ret
+
+    #
+
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in await 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,
+                    version=i.version,
+                )
+        raise KeyError(version)
+
+    #
+
+    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = []
+
+        for vs in await self._pyenv.installable_versions():
+            if (iv := self.guess_version(vs)) is None:
+                continue
+            if iv.opts.debug:
+                raise Exception('Pyenv installable versions not expected to have debug suffix')
+            for d in [False, True]:
+                lst.append(dc.replace(iv, opts=dc.replace(iv.opts, debug=d)))
+
+        return lst
+
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = await self._get_installable_versions(spec)
+
+        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)
+
+        return lst
+
+    async def install_version(self, version: InterpVersion) -> Interp:
+        inst_version = str(version.version)
+        inst_opts = version.opts
+        if inst_opts.threaded:
+            inst_version += 't'
+            inst_opts = dc.replace(inst_opts, threaded=False)
+
+        installer = PyenvVersionInstaller(
+            inst_version,
+            interp_opts=inst_opts,
+            pyenv=self._pyenv,
+        )
+
+        exe = await installer.install()
+        return Interp(exe, version)