omdev 0.0.0.dev7__py3-none-any.whl

omdev/interp/resolvers.py

@@ -0,0 +1,76 @@
+# ruff: noqa: UP006
+import abc
+import collections
+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 .types import Interp
+from .types import InterpSpecifier
+
+
+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
+}
+
+
+class InterpResolver:
+    def __init__(
+            self,
+            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
+    ) -> None:
+        super().__init__()
+        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
+
+    def resolve(self, spec: InterpSpecifier) -> Interp:
+        lst = [
+            (i, si)
+            for i, p in enumerate(self._providers.values())
+            for si in p.get_installed_versions(spec)
+            if spec.contains(si)
+        ]
+        best = sorted(lst, key=lambda t: (-t[0], t[1]))[-1]
+        bi, bv = best
+        bp = list(self._providers.values())[bi]
+        return bp.get_installed_version(bv)
+
+    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)
+                if spec.contains(si)
+            ]
+            if lst:
+                print(f'  {n}')
+                for si in lst:
+                    print(f'    {si}')
+
+        print()
+
+        print('installable:')
+        for n, p in self._providers.items():
+            lst = [
+                si
+                for si in p.get_installable_versions(spec)
+                if spec.contains(si)
+            ]
+            if lst:
+                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(),
+
+    RunningInterpProvider(),
+
+    SystemInterpProvider(),
+]])

omdev/interp/standalone.py

@@ -0,0 +1,187 @@
+"""
+TODO:
+ - ~/.cache/omlish/interp/standalone/...
+ - remove fallback
+"""
+# MIT License
+#
+# Copyright (c) 2023 Tushar Sadhwani
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# https://github.com/tusharsadhwani/yen/blob/8d1bb0c1232c7b0159caefb1bf3a5348b93f7b43/src/yen/github.py
+# ruff: noqa: UP006 UP007
+import json
+import os.path
+import platform
+import re
+import typing
+import typing as ta
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check_not_none
+from omlish.lite.logs import log
+
+
+class StandalonePythons:
+    LAST_TAG_FOR_I686_LINUX = '118809599'  # tag name: "20230826"
+
+    MACHINE_SUFFIX: ta.Mapping[str, ta.Mapping[str, ta.Any]] = {
+        'Darwin': {
+            'arm64': ['aarch64-apple-darwin-install_only.tar.gz'],
+            'x86_64': ['x86_64-apple-darwin-install_only.tar.gz'],
+        },
+        'Linux': {
+            'aarch64': {
+                'glibc': ['aarch64-unknown-linux-gnu-install_only.tar.gz'],
+                # musl doesn't exist
+            },
+            'x86_64': {
+                'glibc': [
+                    'x86_64_v3-unknown-linux-gnu-install_only.tar.gz',
+                    'x86_64-unknown-linux-gnu-install_only.tar.gz',
+                ],
+                'musl': ['x86_64_v3-unknown-linux-musl-install_only.tar.gz'],
+            },
+            'i686': {
+                'glibc': ['i686-unknown-linux-gnu-install_only.tar.gz'],
+                # musl doesn't exist
+            },
+        },
+        'Windows': {
+            'AMD64': ['x86_64-pc-windows-msvc-shared-install_only.tar.gz'],
+            'i686': ['i686-pc-windows-msvc-install_only.tar.gz'],
+        },
+    }
+
+    GITHUB_API_RELEASES_URL = 'https://api.github.com/repos/indygreg/python-build-standalone/releases/'
+
+    PYTHON_VERSION_REGEX = re.compile(r'cpython-(\d+\.\d+\.\d+)')
+
+    class GitHubReleaseData(ta.TypedDict):
+        id: int
+        html_url: str
+        assets: ta.List['StandalonePythons.GitHubAsset']
+
+    class GitHubAsset(ta.TypedDict):
+        browser_download_url: str
+
+    def trim_github_release_data(self, release_data: ta.Dict[str, ta.Any]) -> GitHubReleaseData:
+        return {
+            'id': release_data['id'],
+            'html_url': release_data['html_url'],
+            'assets': [
+                {'browser_download_url': asset['browser_download_url']}
+                for asset in release_data['assets']
+            ],
+        }
+
+    def fallback_release_data(self) -> GitHubReleaseData:
+        """Returns the fallback release data, for when GitHub API gives an error."""
+        log.warning('GitHub unreachable. Using fallback release data.')
+        data_file = os.path.join(os.path.dirname(__file__), 'fallback_release_data.json')
+        with open(data_file) as data:
+            return typing.cast(StandalonePythons.GitHubReleaseData, json.load(data))
+
+    class NotAvailableError(Exception):
+        """Raised when the asked Python version is not available."""
+
+    def get_latest_python_releases(self, is_linux_i686: bool) -> GitHubReleaseData:
+        """Returns the list of python download links from the latest github release."""
+        # They stopped shipping for 32 bit linux since after the 20230826 tag
+        if is_linux_i686:
+            data_file = os.path.join(os.path.dirname(__file__), 'linux_i686_release.json')
+            with open(data_file) as data:
+                return typing.cast(StandalonePythons.GitHubReleaseData, json.load(data))
+
+        latest_release_url = urllib.parse.urljoin(self.GITHUB_API_RELEASES_URL, 'latest')
+        try:
+            with urllib.request.urlopen(latest_release_url) as response:  # noqa
+                release_data = typing.cast(StandalonePythons.GitHubReleaseData, json.load(response))
+
+        except urllib.error.URLError:
+            release_data = self.fallback_release_data()
+
+        return release_data
+
+    @cached_nullary
+    def list_pythons(self) -> ta.Mapping[str, str]:
+        """Returns available python versions for your machine and their download links."""
+        system, machine = platform.system(), platform.machine()
+        download_link_suffixes = self.MACHINE_SUFFIX[system][machine]
+        # linux suffixes are nested under glibc or musl builds
+        if system == 'Linux':
+            # fallback to musl if libc version is not found
+            libc_version = platform.libc_ver()[0] or 'musl'
+            download_link_suffixes = download_link_suffixes[libc_version]
+
+        is_linux_i686 = system == 'Linux' and machine == 'i686'
+        releases = self.get_latest_python_releases(is_linux_i686)
+        python_releases = [asset['browser_download_url'] for asset in releases['assets']]
+
+        available_python_links = [
+            link
+            # Suffixes are in order of preference.
+            for download_link_suffix in download_link_suffixes
+            for link in python_releases
+            if link.endswith(download_link_suffix)
+        ]
+
+        python_versions: ta.Dict[str, str] = {}
+        for link in available_python_links:
+            match = self.PYTHON_VERSION_REGEX.search(link)
+            python_version = check_not_none(match)[1]
+            # Don't override already found versions, as they are in order of preference
+            if python_version in python_versions:
+                continue
+
+            python_versions[python_version] = link
+
+        sorted_python_versions = {
+            version: python_versions[version]
+            for version in sorted(
+                python_versions,
+                # sort by semver
+                key=lambda version: [int(k) for k in version.split('.')],
+                reverse=True,
+            )
+        }
+        return sorted_python_versions
+
+    def _parse_python_version(self, version: str) -> ta.Tuple[int, ...]:
+        return tuple(int(k) for k in version.split('.'))
+
+    def resolve_python_version(self, requested_version: ta.Optional[str]) -> ta.Tuple[str, str]:
+        pythons = self.list_pythons()
+
+        if requested_version is None:
+            sorted_pythons = sorted(
+                pythons.items(),
+                key=lambda version_link: self._parse_python_version(version_link[0]),
+                reverse=True,
+            )
+            latest_version, download_link = sorted_pythons[0]
+            return latest_version, download_link
+
+        for version, version_download_link in pythons.items():
+            if version.startswith(requested_version):
+                python_version = version
+                download_link = version_download_link
+                break
+        else:
+            raise StandalonePythons.NotAvailableError
+
+        return python_version, download_link

omdev/interp/system.py

@@ -0,0 +1,125 @@
+"""
+TODO:
+ - python, python3, python3.12, ...
+ - check if path py's are venvs: sys.prefix != sys.base_prefix
+"""
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import os
+import re
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+from omlish.lite.logs import log
+
+from ..versioning.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
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SystemInterpProvider(InterpProvider):
+    cmd: str = 'python3'
+    path: ta.Optional[str] = None
+
+    inspect: bool = False
+    inspector: InterpInspector = INTERP_INSPECTOR
+
+    #
+
+    @staticmethod
+    def _re_which(
+            pat: re.Pattern,
+            *,
+            mode: int = os.F_OK | os.X_OK,
+            path: ta.Optional[str] = None,
+    ) -> ta.List[str]:
+        if path is None:
+            path = os.environ.get('PATH', None)
+            if path is None:
+                try:
+                    path = os.confstr('CS_PATH')
+                except (AttributeError, ValueError):
+                    path = os.defpath
+
+        if not path:
+            return []
+
+        path = os.fsdecode(path)
+        pathlst = path.split(os.pathsep)
+
+        def _access_check(fn: str, mode: int) -> bool:
+            return os.path.exists(fn) and os.access(fn, mode)
+
+        out = []
+        seen = set()
+        for d in pathlst:
+            normdir = os.path.normcase(d)
+            if normdir not in seen:
+                seen.add(normdir)
+                if not _access_check(normdir, mode):
+                    continue
+                for thefile in os.listdir(d):
+                    name = os.path.join(d, thefile)
+                    if not (
+                            os.path.isfile(name) and
+                            pat.fullmatch(thefile) and
+                            _access_check(name, mode)
+                    ):
+                        continue
+                    out.append(name)
+
+        return out
+
+    @cached_nullary
+    def exes(self) -> ta.List[str]:
+        return self._re_which(
+            re.compile(r'python3(\.\d+)?'),
+            path=self.path,
+        )
+
+    #
+
+    def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+        if not self.inspect:
+            s = os.path.basename(exe)
+            if s.startswith('python'):
+                s = s[len('python'):]
+            if '.' in s:
+                try:
+                    return InterpVersion.parse(s)
+                except InvalidVersion:
+                    pass
+        ii = self.inspector.inspect(exe)
+        return ii.iv if ii is not None else None
+
+    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:
+                log.debug('Invalid system version: %s', e)
+                continue
+            lst.append((e, ev))
+        return lst
+
+    #
+
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [ev for e, ev in self.exe_versions()]
+
+    def get_installed_version(self, version: InterpVersion) -> Interp:
+        for e, ev in self.exe_versions():
+            if ev != version:
+                continue
+            return Interp(
+                exe=e,
+                version=ev,
+            )
+        raise KeyError(version)

omdev/interp/types.py

@@ -0,0 +1,92 @@
+# ruff: noqa: UP006
+import collections
+import dataclasses as dc
+import typing as ta
+
+from ..versioning.specifiers import Specifier
+from ..versioning.versions import InvalidVersion
+from ..versioning.versions import Version
+
+
+# See https://peps.python.org/pep-3149/
+INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
+    ('debug', 'd'),
+    ('threaded', 't'),
+])
+
+INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
+    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
+)
+
+
+@dc.dataclass(frozen=True)
+class InterpOpts:
+    threaded: bool = False
+    debug: bool = False
+
+    def __str__(self) -> str:
+        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
+
+    @classmethod
+    def parse(cls, s: str) -> 'InterpOpts':
+        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
+
+    @classmethod
+    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
+        kw = {}
+        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
+            s, kw[a] = s[:-1], True
+        return s, cls(**kw)
+
+
+@dc.dataclass(frozen=True)
+class InterpVersion:
+    version: Version
+    opts: InterpOpts
+
+    def __str__(self) -> str:
+        return str(self.version) + str(self.opts)
+
+    @classmethod
+    def parse(cls, s: str) -> 'InterpVersion':
+        s, o = InterpOpts.parse_suffix(s)
+        v = Version(s)
+        return cls(
+            version=v,
+            opts=o,
+        )
+
+    @classmethod
+    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
+        try:
+            return cls.parse(s)
+        except (KeyError, InvalidVersion):
+            return None
+
+
+@dc.dataclass(frozen=True)
+class InterpSpecifier:
+    specifier: Specifier
+    opts: InterpOpts
+
+    def __str__(self) -> str:
+        return str(self.specifier) + str(self.opts)
+
+    @classmethod
+    def parse(cls, s: str) -> 'InterpSpecifier':
+        s, o = InterpOpts.parse_suffix(s)
+        if not any(s.startswith(o) for o in Specifier.OPERATORS):
+            s = '~=' + s
+        return cls(
+            specifier=Specifier(s),
+            opts=o,
+        )
+
+    def contains(self, iv: InterpVersion) -> bool:
+        return self.specifier.contains(iv.version) and self.opts == iv.opts
+
+
+@dc.dataclass(frozen=True)
+class Interp:
+    exe: str
+    version: InterpVersion

omdev/mypy/debug.py

@@ -0,0 +1,86 @@
+import importlib.machinery
+import re
+import sys
+
+
+def _is_instance_or_subclass(obj, cls):
+    return (isinstance(obj, type) and issubclass(obj, cls)) or isinstance(obj, cls)
+
+
+class MypyDebugPathFinder(importlib.machinery.PathFinder):
+
+    @classmethod
+    def _get_spec(cls, fullname, path, target=None):  # noqa
+        namespace_path = []
+        for entry in path:
+            if not isinstance(entry, (str, bytes)):
+                continue
+            finder = cls._path_importer_cache(entry)  # type: ignore  # noqa
+            if finder is not None:
+                if isinstance(finder, importlib.machinery.FileFinder):
+                    finder = importlib.machinery.FileFinder(
+                        finder.path,
+                        *[
+                            (i, [s]) for s, i in finder._loaders  # type: ignore  # noqa
+                            if not _is_instance_or_subclass(i, importlib.machinery.ExtensionFileLoader)
+                        ],
+                    )
+                if hasattr(finder, 'find_spec'):
+                    spec = finder.find_spec(fullname, target)
+                else:
+                    spec = cls._legacy_get_spec(fullname, finder)  # type: ignore  # noqa
+                if spec is None:
+                    continue
+                if spec.loader is not None:
+                    return spec
+                portions = spec.submodule_search_locations
+                if portions is None:
+                    raise ImportError('spec missing loader')
+                namespace_path.extend(portions)
+        return None
+
+    @classmethod
+    def find_spec(cls, fullname, path=None, target=None):  # noqa
+        if not fullname.startswith('mypy.') and fullname != 'mypy':
+            return None
+        if path is None:
+            path = sys.path
+        spec = cls._get_spec(fullname, path, target)
+        if spec is None:
+            return None
+        elif spec.loader is None:
+            namespace_path = spec.submodule_search_locations
+            if namespace_path:
+                spec.origin = None
+                spec.submodule_search_locations = importlib.machinery._NamespacePath(  # type: ignore  # noqa
+                    fullname,
+                    namespace_path,
+                    cls._get_spec,
+                )
+                return spec
+            else:
+                return None
+        else:
+            return spec
+
+
+def _main():
+    for i, e in enumerate(sys.meta_path):  # noqa
+        if _is_instance_or_subclass(e, importlib.machinery.PathFinder):
+            break
+    sys.meta_path.insert(i, MypyDebugPathFinder)  # noqa
+    sys.path_importer_cache.clear()
+    importlib.invalidate_caches()
+
+    from mypy.__main__ import console_entry  # noqa
+
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+
+    if not any(k in sys.argv[1:] for k in ['--show-traceback', '--tb']):
+        sys.argv.insert(1, '--show-traceback')
+
+    console_entry()
+
+
+if __name__ == '__main__':
+    _main()

omdev/pyproject/__init__.py

@@ -0,0 +1 @@
+# @omlish-lite

omdev/pyproject/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .cli import _main
+
+    _main()