omdev 0.0.0.dev23__tar.gz → 0.0.0.dev25__tar.gz

{omdev-0.0.0.dev23/omdev.egg-info → omdev-0.0.0.dev25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omdev
-Version: 0.0.0.dev23
+Version: 0.0.0.dev25
 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.dev23
+Requires-Dist: omlish==0.0.0.dev25
 Provides-Extra: all
 Requires-Dist: pycparser~=2.22; extra == "all"
 Requires-Dist: cffi~=1.17; extra == "all"

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/README.rst

@@ -8,3 +8,6 @@ Core packages installable from git via:
 .. code-block::
 
   pip install 'git+https://github.com/wrmsr/omlish@master#subdirectory=.pkg/<pkg>'
+
+Core packages have no required dependencies, but numerous optional ones - see their respective ``pyproject.toml`` files
+for details.

omdev-0.0.0.dev25/omdev/_manifests.json

@@ -0,0 +1 @@
+[]

omdev-0.0.0.dev25/omdev/cexts/_boilerplate.cc

@@ -0,0 +1,82 @@
+// @omdev-cext
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "structmember.h"
+
+#include <unistd.h>
+
+//
+
+#define _MODULE_NAME "_boilerplate"
+#define _PACKAGE_NAME "omdev.cexts"
+#define _MODULE_FULL_NAME _PACKAGE_NAME "." _MODULE_NAME
+
+typedef struct boilerplate_state {
+} boilerplate_state;
+
+static inline boilerplate_state * get_boilerplate_state(PyObject *module)
+{
+    void *state = PyModule_GetState(module);
+    assert(state != NULL);
+    return (boilerplate_state *)state;
+}
+
+//
+
+PyDoc_STRVAR(boilerplate_doc, "boilerplate");
+
+static int boilerplate_exec(PyObject *module)
+{
+    get_boilerplate_state(module);
+    return 0;
+}
+
+static int boilerplate_traverse(PyObject *module, visitproc visit, void *arg)
+{
+    get_boilerplate_state(module);
+    return 0;
+}
+
+static int boilerplate_clear(PyObject *module)
+{
+    get_boilerplate_state(module);
+    return 0;
+}
+
+static void boilerplate_free(void *module)
+{
+    boilerplate_clear((PyObject *)module);
+}
+
+static PyMethodDef boilerplate_methods[] = {
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef_Slot boilerplate_slots[] = {
+    {Py_mod_exec, (void *) boilerplate_exec},
+// #if PY_VERSION_HEX >= 0x030D0000
+//     {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+// #endif
+    {0, NULL}
+};
+
+static struct PyModuleDef boilerplate_module = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = _MODULE_NAME,
+    .m_doc = boilerplate_doc,
+    .m_size = sizeof(boilerplate_state),
+    .m_methods = boilerplate_methods,
+    .m_slots = boilerplate_slots,
+    .m_traverse = boilerplate_traverse,
+    .m_clear = boilerplate_clear,
+    .m_free = boilerplate_free,
+};
+
+extern "C" {
+
+PyMODINIT_FUNC PyInit__boilerplate(void)
+{
+    return PyModuleDef_Init(&boilerplate_module);
+}
+
+}

omdev-0.0.0.dev25/omdev/cexts/_distutils/LICENSE

@@ -0,0 +1,12 @@
+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.

omdev-0.0.0.dev25/omdev/cexts/build.py

@@ -0,0 +1,87 @@
+import dataclasses as dc
+import os.path
+import sys
+import sysconfig
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from . import _distutils as du
+
+
+CPP_STD = 'c++20'
+
+
+@dc.dataclass(frozen=True)
+class BuildExt:
+    full_name: str
+    src_file: str
+
+    inplace: bool = dc.field(default=True, kw_only=True)
+    debug: bool = dc.field(default=True, kw_only=True)
+    force: bool = dc.field(default=False, kw_only=True)
+
+    dry_run: bool = dc.field(default=False, kw_only=True)
+    verbose: bool = dc.field(default=False, kw_only=True)
+
+    extra_src_files: lang.SequenceNotStr[str] | None = dc.field(default=None, kw_only=True)
+    include_dirs: lang.SequenceNotStr[str] | None = dc.field(default=None, kw_only=True)
+    compile_args: lang.SequenceNotStr[str] | None = dc.field(default=None, kw_only=True)
+    link_args: lang.SequenceNotStr[str] | None = dc.field(default=None, kw_only=True)
+    define_macros: ta.Sequence[tuple[str, str]] | None = dc.field(default=None, kw_only=True)
+    undef_macros: lang.SequenceNotStr[str] | None = dc.field(default=None, kw_only=True)
+
+    def __post_init__(self) -> None:
+        check.not_isinstance(self.compile_args, str)
+        check.not_isinstance(self.link_args, str)
+
+
+def build_ext(ext: BuildExt) -> str:
+    extra_link_args: list[str] = []
+    if sys.platform == 'darwin':
+        extra_link_args.append('-Wl,-no_fixup_chains')
+
+    du_ext = du.Extension(
+        ext.full_name,
+        sources=[
+            ext.src_file,
+            *(ext.extra_src_files or []),
+        ],
+        include_dirs=[
+            os.path.dirname(ext.src_file),
+            *(ext.include_dirs or []),
+        ],
+        extra_compile_args=[
+            *([f'-std={CPP_STD}'] if any(ext.src_file.endswith(sf) for sf in ('cc', 'cpp')) else []),
+            *(ext.compile_args or []),
+        ],
+        extra_link_args=[
+            *extra_link_args,
+            *(ext.link_args or []),
+        ],
+        define_macros=(list(ext.define_macros) if ext.define_macros is not None else None),
+        undef_macros=(list(ext.undef_macros) if ext.undef_macros is not None else None),
+    )
+
+    cmd_obj = du.BuildExt(du.BuildExt.Options(
+        inplace=ext.inplace,
+        debug=ext.debug,
+        force=ext.force,
+
+        dry_run=ext.dry_run,
+        verbose=ext.verbose,
+    ))
+    cmd_obj.build_extension(du_ext)
+
+    so_file = os.path.join(
+        os.path.dirname(ext.src_file),
+        ''.join([
+            ext.full_name.rpartition('.')[2],
+            '.',
+            sysconfig.get_config_var('SOABI'),
+            sysconfig.get_config_var('SHLIB_SUFFIX'),
+        ]),
+    )
+
+    return so_file

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/omdev/cexts/cmake.py

@@ -302,7 +302,7 @@ class CmakeProjectGen:
         clg.run()
 
         with open(os.path.join(self.cmake_dir(), 'CMakeLists.txt'), 'w') as f:
-            f.write(out.getvalue())
+            f.write(out.getvalue().strip() + '\n')
 
 
 ##

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/omdev/cexts/importhook.py

@@ -42,7 +42,7 @@ class CextImportLoader(importlib.machinery.ExtensionFileLoader):
         super().__init__(module_name, filename)
 
     def create_module(self, spec: importlib.machinery.ModuleSpec) -> types.ModuleType:
-        so_path = build.build_ext(spec.name, check.non_empty_str(spec.origin))
+        so_path = build.build_ext(build.BuildExt(spec.name, check.non_empty_str(spec.origin)))
         self.path = so_path  # noqa
         spec.origin = so_path
         return super().create_module(spec)

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/omdev/findmagic.py

@@ -17,6 +17,13 @@ def find_magic(
         *,
         py: bool = False,
 ) -> ta.Iterator[str]:
+    if isinstance(roots, str):
+        raise TypeError(roots)
+    if isinstance(magics, str):
+        raise TypeError(magics)
+    if isinstance(exts, str):
+        raise TypeError(exts)
+
     if not magics:
         raise Exception('Must specify magics')
     if not exts:

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/omdev/interp/pyenv.py

@@ -92,6 +92,14 @@ class Pyenv:
             ret.append(l)
         return ret
 
+    def update(self) -> bool:
+        if (root := 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)
+        return True
+
 
 ##
 
@@ -292,6 +300,10 @@ class PyenvInterpProvider(InterpProvider):
 
             inspect: bool = False,
             inspector: InterpInspector = INTERP_INSPECTOR,
+
+            *,
+
+            try_update: bool = False,
     ) -> None:
         super().__init__()
 
@@ -300,6 +312,8 @@ class PyenvInterpProvider(InterpProvider):
         self._inspect = inspect
         self._inspector = inspector
 
+        self._try_update = try_update
+
     #
 
     @staticmethod
@@ -364,8 +378,9 @@ class PyenvInterpProvider(InterpProvider):
 
     #
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         lst = []
+
         for vs in self._pyenv.installable_versions():
             if (iv := self.guess_version(vs)) is None:
                 continue
@@ -373,6 +388,16 @@ class PyenvInterpProvider(InterpProvider):
                 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
+
+    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = 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)
+
         return lst
 
     def install_version(self, version: InterpVersion) -> Interp:

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/omdev/interp/resolvers.py

@@ -99,7 +99,7 @@ class InterpResolver:
 
 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(),
+    PyenvInterpProvider(try_update=True),
 
     RunningInterpProvider(),
 

omdev-0.0.0.dev25/omdev/manifests.py

@@ -0,0 +1,225 @@
+"""
+!!! manifests! get-manifest, _manifest.py
+ - dumb dicts, root keys are 'types'
+ - get put in _manifest.py, root level dict or smth
+  - IMPORT files w comment
+  - comment must immediately precede a global val setter
+  - val is grabbed from imported module dict by name
+  - value is repr'd somehow (roundtrip checked) (naw, json lol)
+  - dumped in _manifest.py
+ - # @omlish-manifest \n _CACHE_MANIFEST = {'cache': {'name': 'llm', …
+ - also can do prechecks!
+"""
+# ruff: noqa: UP006
+# @omlish-lite
+import argparse
+import collections
+import dataclasses as dc
+import inspect
+import json
+import os.path
+import re
+import shlex
+import subprocess
+import sys
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+from omlish.lite.json import json_dumps_pretty
+
+from . import findmagic
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ManifestOrigin:
+    module: str
+    attr: str
+
+    file: str
+    line: int
+
+
+@dc.dataclass(frozen=True)
+class Manifest(ManifestOrigin):
+    value: ta.Any
+
+
+MANIFEST_MAGIC = '# @omlish-manifest'
+
+_MANIFEST_GLOBAL_PAT = re.compile(r'^(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*=.*')
+
+
+def _dump_module_manifests(spec: str, *attrs: str) -> None:
+    import importlib
+    import json
+
+    mod = importlib.import_module(spec)
+
+    out = {}
+    for attr in attrs:
+        manifest = getattr(mod, attr)
+
+        manifest_json = json.dumps(manifest)
+        rt_manifest = json.loads(manifest_json)
+
+        if rt_manifest != manifest:
+            raise Exception(f'Manifest failed to roundtrip: {manifest} != {rt_manifest}')
+
+        out[attr] = rt_manifest
+
+    out_json = json.dumps(out, indent=None, separators=(',', ':'))
+    print(out_json)
+
+
+@cached_nullary
+def _payload_src() -> str:
+    return inspect.getsource(_dump_module_manifests)
+
+
+def build_module_manifests(
+        file: str,
+        base: str,
+        *,
+        shell_wrap: bool = True,
+) -> ta.Sequence[Manifest]:
+    print((file, base))
+
+    if not file.endswith('.py'):
+        raise Exception(file)
+
+    mod_name = file.rpartition('.')[0].replace(os.sep, '.')
+
+    with open(os.path.join(base, file)) as f:
+        src = f.read()
+
+    origins: ta.List[ManifestOrigin] = []
+    lines = src.splitlines(keepends=True)
+    for i, l in enumerate(lines):
+        if l.startswith(MANIFEST_MAGIC):
+            if (m := _MANIFEST_GLOBAL_PAT.match(nl := lines[i + 1])) is None:
+                raise Exception(nl)
+
+            origins.append(ManifestOrigin(
+                module=mod_name,
+                attr=m.groupdict()['name'],
+
+                file=file,
+                line=i + 1,
+            ))
+
+    if not origins:
+        raise Exception('no manifests found')
+
+    if (dups := [k for k, v in collections.Counter(o.attr for o in origins).items() if v > 1]):
+        raise Exception(f'Duplicate attrs: {dups}')
+
+    attrs = [o.attr for o in origins]
+
+    subproc_src = '\n\n'.join([
+        _payload_src(),
+        f'_dump_module_manifests({mod_name!r}, {", ".join(repr(a) for a in attrs)})\n',
+    ])
+
+    args = [
+        sys.executable,
+        '-c',
+        subproc_src,
+    ]
+
+    if shell_wrap:
+        args = ['sh', '-c', ' '.join(map(shlex.quote, args))]
+
+    subproc_out = subprocess.check_output(args)
+
+    sp_lines = subproc_out.decode().strip().splitlines()
+    if len(sp_lines) != 1:
+        raise Exception('Unexpected subprocess output')
+
+    dct = json.loads(sp_lines[0])
+    if set(dct) != set(attrs):
+        raise Exception('Unexpected subprocess output keys')
+
+    out: ta.List[Manifest] = []
+
+    for o in origins:
+        manifest = dct[o.attr]
+
+        out.append(Manifest(
+            **dc.asdict(o),
+            value=manifest,
+        ))
+
+    return out
+
+
+def build_package_manifests(
+        name: str,
+        base: str,
+        *,
+        write: bool = False,
+) -> ta.List[Manifest]:
+    pkg_dir = os.path.join(base, name)
+    if not os.path.isdir(pkg_dir) or not os.path.isfile(os.path.join(pkg_dir, '__init__.py')):
+        raise Exception(pkg_dir)
+
+    manifests: ta.List[Manifest] = []
+
+    for file in findmagic.find_magic(
+            [pkg_dir],
+            [MANIFEST_MAGIC],
+            ['py'],
+    ):
+        manifests.extend(build_module_manifests(os.path.relpath(file, base), base))
+
+    if write:
+        with open(os.path.join(pkg_dir, '_manifests.json'), 'w') as f:
+            f.write(json_dumps_pretty([dc.asdict(m) for m in manifests]))
+            f.write('\n')
+
+    return manifests
+
+
+##
+
+
+if __name__ == '__main__':
+    def _gen_cmd(args) -> None:
+        if args.base is not None:
+            base = args.base
+        else:
+            base = os.getcwd()
+        base = os.path.abspath(base)
+        if not os.path.isdir(base):
+            raise RuntimeError(base)
+
+        for pkg in args.package:
+            ms = build_package_manifests(
+                pkg,
+                base,
+                write=args.write or False,
+            )
+            if not args.quiet:
+                print(json_dumps_pretty(ms))
+
+    def _main(argv=None) -> None:
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers()
+
+        parser_gen = subparsers.add_parser('gen')
+        parser_gen.add_argument('-b', '--base')
+        parser_gen.add_argument('-w', '--write', action='store_true')
+        parser_gen.add_argument('-q', '--quiet', action='store_true')
+        parser_gen.add_argument('package', nargs='*')
+
+        parser_gen.set_defaults(func=_gen_cmd)
+
+        args = parser.parse_args(argv)
+        if not getattr(args, 'func', None):
+            parser.print_help()
+        else:
+            args.func(args)
+
+    _main()

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/omdev/pyproject/cli.py

@@ -243,18 +243,30 @@ def _venv_cmd(args) -> None:
             f'--_docker_container={shlex.quote(sd)}',
             *map(shlex.quote, sys.argv[1:]),
         ])
+
+        docker_env = {
+            'DOCKER_HOST_PLATFORM': os.environ.get('DOCKER_HOST_PLATFORM', sys.platform),
+        }
+        for e in args.docker_env or []:
+            if '=' in e:
+                k, _, v = e.split('=')
+                docker_env[k] = v
+            else:
+                docker_env[e] = os.environ.get(e, '')
+
         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 [])
+                ('-e', f'{k}={v}')
+                for k, v in docker_env.items()
             ),
             '-it', sd,
             'bash', '--login', '-c', script,
         )
+
         return
 
     cmd = args.cmd

{omdev-0.0.0.dev23 → omdev-0.0.0.dev25}/omdev/pyproject/pkg.py

@@ -255,6 +255,7 @@ class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
         st.pop('cexts', None)
 
         self._move_dict_key(st, 'find_packages', pyp_dct, 'tool.setuptools.packages.find')
+        self._move_dict_key(st, 'package_data', pyp_dct, 'tool.setuptools.package-data')
 
         mani_in = st.pop('manifest_in', None)
 
@@ -337,9 +338,14 @@ class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
         st = specs.setuptools
         pyp_dct['tool.setuptools'] = st
 
-        st.pop('cexts', None)
-        st.pop('find_packages', None)
-        st.pop('manifest_in', None)
+        for k in [
+            'cexts',
+
+            'find_packages',
+            'package_data',
+            'manifest_in',
+        ]:
+            st.pop(k, None)
 
         pyp_dct['tool.setuptools.packages.find'] = {
             'include': [],