omdev 0.0.0.dev7__py3-none-any.whl

omdev/pyproject/cli.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+# @omdev-amalg ../scripts/pyproject.py
+# ruff: noqa: UP006 UP007
+"""
+TODO:
+ - check / tests, src dir sets
+ - ci
+ - build / package / publish / version roll
+  - {pkg_name: [src_dirs]}, default excludes, generate MANIFST.in, ...
+ - env vars - PYTHONPATH
+
+lookit:
+ - https://pdm-project.org/en/latest/
+ - https://rye.astral.sh/philosophy/
+ - https://github.com/indygreg/python-build-standalone/blob/main/pythonbuild/cpython.py
+ - https://astral.sh/blog/uv
+ - https://github.com/jazzband/pip-tools
+ - https://github.com/Osiris-Team/1JPM
+ - https://github.com/brettcannon/microvenv
+ - https://github.com/pypa/pipx
+ - https://github.com/tox-dev/tox/
+"""
+import argparse
+import dataclasses as dc
+import glob
+import itertools
+import os.path
+import shlex
+import shutil
+import sys
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check_not
+from omlish.lite.check import check_not_none
+from omlish.lite.logs import configure_standard_logging
+from omlish.lite.logs import log
+from omlish.lite.runtime import check_runtime_version
+from omlish.lite.subprocesses import subprocess_check_call
+
+from ..interp.resolvers import DEFAULT_INTERP_RESOLVER
+from ..interp.types import InterpSpecifier
+from ..toml.parser import toml_loads
+from .configs import PyprojectConfig
+from .configs import PyprojectConfigPreparer
+from .configs import VenvConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class VersionsFile:
+    name: ta.Optional[str] = '.versions'
+
+    @staticmethod
+    def parse(s: str) -> ta.Mapping[str, str]:
+        return {
+            k: v
+            for l in s.splitlines()
+            if (sl := l.split('#')[0].strip())
+            for k, _, v in (sl.partition('='),)
+        }
+
+    @cached_nullary
+    def contents(self) -> ta.Mapping[str, str]:
+        if not self.name or not os.path.exists(self.name):
+            return {}
+        with open(self.name) as f:
+            s = f.read()
+        return self.parse(s)
+
+    @staticmethod
+    def get_pythons(d: ta.Mapping[str, str]) -> ta.Mapping[str, str]:
+        pfx = 'PYTHON_'
+        return {k[len(pfx):].lower(): v for k, v in d.items() if k.startswith(pfx)}
+
+    @cached_nullary
+    def pythons(self) -> ta.Mapping[str, str]:
+        return self.get_pythons(self.contents())
+
+
+##
+
+
+@cached_nullary
+def _script_rel_path() -> str:
+    cwd = os.getcwd()
+    if not (f := __file__).startswith(cwd):
+        raise OSError(f'file {f} not in {cwd}')
+    return f[len(cwd):].lstrip(os.sep)
+
+
+##
+
+
+class Venv:
+    def __init__(
+            self,
+            name: str,
+            cfg: VenvConfig,
+    ) -> None:
+        super().__init__()
+        self._name = name
+        self._cfg = cfg
+
+    @property
+    def cfg(self) -> VenvConfig:
+        return self._cfg
+
+    DIR_NAME = '.venvs'
+
+    @property
+    def dir_name(self) -> str:
+        return os.path.join(self.DIR_NAME, self._name)
+
+    @cached_nullary
+    def interp_exe(self) -> str:
+        i = InterpSpecifier.parse(check_not_none(self._cfg.interp))
+        return DEFAULT_INTERP_RESOLVER.resolve(i).exe
+
+    @cached_nullary
+    def exe(self) -> str:
+        ve = os.path.join(self.dir_name, 'bin/python')
+        if not os.path.isfile(ve):
+            raise Exception(f'venv exe {ve} does not exist or is not a file!')
+        return ve
+
+    @cached_nullary
+    def create(self) -> bool:
+        if os.path.exists(dn := self.dir_name):
+            if not os.path.isdir(dn):
+                raise Exception(f'{dn} exists but is not a directory!')
+            return False
+
+        log.info('Using interpreter %s', (ie := self.interp_exe()))
+        subprocess_check_call(ie, '-m', 'venv', dn)
+
+        ve = self.exe()
+
+        subprocess_check_call(
+            ve,
+            '-m', 'pip',
+            'install', '-v', '--upgrade',
+            'pip',
+            'setuptools',
+            'wheel',
+        )
+
+        if (sr := self._cfg.requires):
+            subprocess_check_call(
+                ve,
+                '-m', 'pip',
+                'install', '-v',
+                *sr,
+            )
+
+        return True
+
+    @staticmethod
+    def _resolve_srcs(raw: ta.List[str]) -> ta.List[str]:
+        out: list[str] = []
+        seen: ta.Set[str] = set()
+        for r in raw:
+            es: list[str]
+            if any(c in r for c in '*?'):
+                es = list(glob.glob(r, recursive=True))
+            else:
+                es = [r]
+            for e in es:
+                if e not in seen:
+                    seen.add(e)
+                    out.append(e)
+        return out
+
+    @cached_nullary
+    def srcs(self) -> ta.Sequence[str]:
+        return self._resolve_srcs(self._cfg.srcs or [])
+
+
+##
+
+
+class Run:
+    def __init__(
+            self,
+            *,
+            raw_cfg: ta.Union[ta.Mapping[str, ta.Any], str, None] = None,
+    ) -> None:
+        super().__init__()
+
+        self._raw_cfg = raw_cfg
+
+    @cached_nullary
+    def raw_cfg(self) -> ta.Mapping[str, ta.Any]:
+        if self._raw_cfg is None:
+            with open('pyproject.toml') as f:
+                buf = f.read()
+        elif isinstance(self._raw_cfg, str):
+            buf = self._raw_cfg
+        else:
+            return self._raw_cfg
+        return toml_loads(buf)
+
+    @cached_nullary
+    def cfg(self) -> PyprojectConfig:
+        dct = self.raw_cfg()['tool']['omlish']['pyproject']
+        return PyprojectConfigPreparer(
+            python_versions=VersionsFile().pythons(),
+        ).prepare_config(dct)
+
+    @cached_nullary
+    def venvs(self) -> ta.Mapping[str, Venv]:
+        return {
+            n: Venv(n, c)
+            for n, c in self.cfg().venvs.items()
+            if not n.startswith('_')
+        }
+
+
+##
+
+
+def _venv_cmd(args) -> None:
+    venv = Run().venvs()[args.name]
+    if (sd := venv.cfg.docker) is not None and sd != (cd := args._docker_container):  # noqa
+        script = ' '.join([
+            'python3',
+            shlex.quote(_script_rel_path()),
+            f'--_docker_container={shlex.quote(sd)}',
+            *map(shlex.quote, sys.argv[1:]),
+        ])
+        subprocess_check_call(
+            'docker',
+            'compose',
+            '-f', 'docker/compose.yml',
+            'exec',
+            *itertools.chain.from_iterable(
+                ('-e', f'{e}={os.environ.get(e, "")}' if '=' not in e else e)
+                for e in (args.docker_env or [])
+            ),
+            '-it', sd,
+            'bash', '--login', '-c', script,
+        )
+        return
+
+    venv.create()
+
+    cmd = args.cmd
+    if not cmd:
+        pass
+
+    elif cmd == 'python':
+        os.execl(
+            (exe := venv.exe()),
+            exe,
+            *args.args,
+        )
+
+    elif cmd == 'exe':
+        check_not(args.args)
+        print(venv.exe())
+
+    elif cmd == 'run':
+        sh = check_not_none(shutil.which('bash'))
+        script = ' '.join(args.args)
+        if not script:
+            script = sh
+        os.execl(
+            (bash := check_not_none(sh)),
+            bash,
+            '-c',
+            f'. {venv.dir_name}/bin/activate && ' + script,
+        )
+
+    elif cmd == 'srcs':
+        check_not(args.args)
+        print('\n'.join(venv.srcs()))
+
+    elif cmd == 'test':
+        subprocess_check_call(venv.exe(), '-m', 'pytest', *(args.args or []), *venv.srcs())
+
+    else:
+        raise Exception(f'unknown subcommand: {cmd}')
+
+
+##
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--_docker_container', help=argparse.SUPPRESS)
+
+    subparsers = parser.add_subparsers()
+
+    parser_resolve = subparsers.add_parser('venv')
+    parser_resolve.add_argument('name')
+    parser_resolve.add_argument('-e', '--docker-env', action='append')
+    parser_resolve.add_argument('cmd', nargs='?')
+    parser_resolve.add_argument('args', nargs=argparse.REMAINDER)
+    parser_resolve.set_defaults(func=_venv_cmd)
+
+    return parser
+
+
+def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+    check_runtime_version()
+    configure_standard_logging()
+
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, 'func', None):
+        parser.print_help()
+    else:
+        args.func(args)
+
+
+if __name__ == '__main__':
+    _main()

omdev/pyproject/configs.py

@@ -0,0 +1,97 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import typing as ta
+
+from omlish.lite.marshal import unmarshal_obj
+
+
+@dc.dataclass(frozen=True)
+class VenvConfig:
+    inherits: ta.Optional[ta.Sequence[str]] = None
+    interp: ta.Optional[str] = None
+    requires: ta.Optional[ta.List[str]] = None
+    docker: ta.Optional[str] = None
+    srcs: ta.Optional[ta.List[str]] = None
+
+
+@dc.dataclass(frozen=True)
+class PyprojectConfig:
+    srcs: ta.Mapping[str, ta.Sequence[str]]
+    venvs: ta.Mapping[str, VenvConfig]
+
+    venvs_dir: str = '.venvs'
+    versions_file: ta.Optional[str] = '.versions'
+
+
+class PyprojectConfigPreparer:
+    def __init__(
+            self,
+            *,
+            python_versions: ta.Optional[ta.Mapping[str, str]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._python_versions = python_versions or {}
+
+    def _inherit_venvs(self, m: ta.Mapping[str, VenvConfig]) -> ta.Mapping[str, VenvConfig]:
+        done: ta.Dict[str, VenvConfig] = {}
+
+        def rec(k):
+            try:
+                return done[k]
+            except KeyError:
+                pass
+
+            c = m[k]
+            kw = dc.asdict(c)
+            for i in c.inherits or ():
+                ic = rec(i)
+                kw.update({k: v for k, v in dc.asdict(ic).items() if v is not None and kw.get(k) is None})
+            del kw['inherits']
+
+            d = done[k] = VenvConfig(**kw)
+            return d
+
+        for k in m:
+            rec(k)
+        return done
+
+    def _resolve_srcs(
+            self,
+            lst: ta.Sequence[str],
+            aliases: ta.Mapping[str, ta.Sequence[str]],
+    ) -> ta.List[str]:
+        todo = list(reversed(lst))
+        raw: ta.List[str] = []
+        seen: ta.Set[str] = set()
+
+        while todo:
+            cur = todo.pop()
+            if cur in seen:
+                continue
+
+            seen.add(cur)
+            if not cur.startswith('@'):
+                raw.append(cur)
+                continue
+
+            todo.extend(aliases[cur[1:]][::-1])
+
+        return raw
+
+    def _fixup_interp(self, s: ta.Optional[str]) -> ta.Optional[str]:
+        if not s or not s.startswith('@'):
+            return s
+        return self._python_versions[s[1:]]
+
+    def prepare_config(self, dct: ta.Mapping[str, ta.Any]) -> PyprojectConfig:
+        pcfg: PyprojectConfig = unmarshal_obj(dct, PyprojectConfig)
+
+        ivs = dict(self._inherit_venvs(pcfg.venvs or {}))
+        for k, v in ivs.items():
+            v = dc.replace(v, srcs=self._resolve_srcs(v.srcs or [], pcfg.srcs or {}))
+            v = dc.replace(v, interp=self._fixup_interp(v.interp))
+            ivs[k] = v
+
+        pcfg = dc.replace(pcfg, venvs=ivs)
+        return pcfg

omdev/pyproject/ext.py

@@ -0,0 +1,107 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import typing as ta
+
+
+"""
+# https://setuptools.pypa.io/en/latest/userguide/ext_modules.html#extension-api-reference
+
+name (str) -
+    the full name of the extension, including any packages - ie. not a filename or pathname, but Python dotted name
+
+sources (list[str]) -
+    list of source filenames, relative to the distribution root (where the setup script lives), in Unix form
+    (slash-separated) for portability. Source files may be C, C++, SWIG (.i), platform-specific resource files, or
+    whatever else is recognized by the “build_ext” command as source for a Python extension.
+
+include_dirs (list[str]) -
+    list of directories to search for C/C++ header files (in Unix form for portability)
+
+define_macros (list[tuple[str, str|None]]) -
+    list of macros to define; each macro is defined using a 2-tuple: the first item corresponding to the name of the
+    macro and the second item either a string with its value or None to define it without a particular value (equivalent
+    of “#define FOO” in source or -DFOO on Unix C compiler command line)
+
+undef_macros (list[str]) -
+    list of macros to undefine explicitly
+
+library_dirs (list[str]) -
+    list of directories to search for C/C++ libraries at link time
+
+libraries (list[str]) -
+    list of library names (not filenames or paths) to link against
+
+runtime_library_dirs (list[str]) -
+    list of directories to search for C/C++ libraries at run time (for shared extensions, this is when the extension is
+    loaded). Setting this will cause an exception during build on Windows platforms.
+
+extra_objects (list[str]) -
+    list of extra files to link with (eg. object files not implied by 'sources', static library that must be explicitly
+    specified, binary resource files, etc.)
+
+extra_compile_args (list[str]) -
+    any extra platform- and compiler-specific information to use when compiling the source files in 'sources'. For
+    platforms and compilers where “command line” makes sense, this is typically a list of command-line arguments, but
+    for other platforms it could be anything.
+
+extra_link_args (list[str]) -
+    any extra platform- and compiler-specific information to use when linking object files together to create the
+    extension (or to create a new static Python interpreter). Similar interpretation as for 'extra_compile_args'.
+
+export_symbols (list[str]) -
+    list of symbols to be exported from a shared extension. Not used on all platforms, and not generally necessary for
+    Python extensions, which typically export exactly one symbol: “init” + extension_name.
+
+swig_opts (list[str]) -
+    any extra options to pass to SWIG if a source file has the .i extension.
+
+depends (list[str]) -
+    list of files that the extension depends on
+
+language (str) -
+    extension language (i.e. “c”, “c++”, “objc”). Will be detected from the source extensions if not provided.
+
+optional (bool) -
+    specifies that a build failure in the extension should not abort the build process, but simply not install the
+    failing extension.
+
+py_limited_api (bool) -
+    opt-in flag for the usage of Python's limited API.
+"""
+
+
+SETUP_PY_TMPL = """
+import setuptools as st
+
+st.setup(
+    ext_modules=[
+        st.Extension(
+            '{mod_name}',
+            [{mod_srcs}],
+            include_dirs=['lib'],
+            py_limited_api=True
+        ),
+    ],
+)
+"""
+
+
+@dc.dataclass(frozen=True)
+class ExtModule:
+    name: str
+    sources: ta.List[str]
+    include_dirs: ta.Optional[ta.List[str]] = None
+    define_macros: ta.Optional[ta.List[ta.Tuple[str, ta.Optional[str]]]] = None
+    undef_macros: ta.Optional[ta.List[str]] = None
+    library_dirs: ta.Optional[ta.List[str]] = None
+    libraries: ta.Optional[ta.List[str]] = None
+    runtime_library_dirs: ta.Optional[ta.List[str]] = None
+    extra_objects: ta.Optional[ta.List[str]] = None
+    extra_compile_args: ta.Optional[ta.List[str]] = None
+    extra_link_args: ta.Optional[ta.List[str]] = None
+    export_symbols: ta.Optional[ta.List[str]] = None
+    swig_opts: ta.Optional[ta.List[str]] = None
+    depends: ta.Optional[ta.List[str]] = None
+    language: ta.Optional[str] = None
+    optional: ta.Optional[bool] = None
+    py_limited_api: ta.Optional[bool] = None