omdev 0.0.36__tar.gz → 0.0.38__tar.gz

omdev-0.0.38/MANIFEST.in

@@ -0,0 +1 @@
+global-exclude **/conftest.py

{omdev-0.0.36/omdev.egg-info → omdev-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.36
+Version: 0.0.38
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -13,10 +13,10 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omcore==0.0.36
+Requires-Dist: omcore==0.0.38
 Provides-Extra: all
-Requires-Dist: ominfra==0.0.36; extra == "all"
-Requires-Dist: omllm==0.0.36; extra == "all"
+Requires-Dist: ominfra==0.0.38; extra == "all"
+Requires-Dist: omllm==0.0.38; extra == "all"
 Requires-Dist: black~=26.5; extra == "all"
 Requires-Dist: pycparser~=3.0; extra == "all"
 Requires-Dist: pcpp~=1.30; extra == "all"
@@ -35,9 +35,9 @@ Requires-Dist: textual~=8.2; extra == "all"
 Requires-Dist: textual-dev~=1.8; extra == "all"
 Requires-Dist: textual-speedups~=0.2; extra == "all"
 Provides-Extra: ominfra
-Requires-Dist: ominfra==0.0.36; extra == "ominfra"
+Requires-Dist: ominfra==0.0.38; extra == "ominfra"
 Provides-Extra: omllm
-Requires-Dist: omllm==0.0.36; extra == "omllm"
+Requires-Dist: omllm==0.0.38; extra == "omllm"
 Provides-Extra: black
 Requires-Dist: black~=26.5; extra == "black"
 Provides-Extra: c

{omdev-0.0.36 → omdev-0.0.38}/omdev/.om-manifests.json

@@ -27,7 +27,7 @@
     "module": ".cexts.cmake",
     "attr": "_CLI_MODULE",
     "file": "omdev/cexts/cmake.py",
-    "line": 374,
+    "line": 449,
     "value": {
       "!.cli.types.CliModule": {
         "name": "cmake",

{omdev-0.0.36 → omdev-0.0.38}/omdev/cexts/cmake.py

@@ -1,10 +1,8 @@
 """
 FIXME:
  - debug tables don't handle symlinks
- - use relapths in cml.txt
 
 TODO:
- - symlink headers, included src files (hamt_impl, ...)
  - point / copy output to dst dirs
  - libs
   - FindPackages? FetchContent? built_ext won't have that
@@ -40,11 +38,14 @@ import typing as ta
 
 from omcore import check
 from omcore import lang
+from omcore.lite.marshal import unmarshal_obj
 from omcore.logs import all as logs
 
 from .. import cmake
 from .. import magic
 from ..cli import CliModule
+from .configs import CextConfig
+from .configs import expand_cext_config_files
 from .magic import CextMagic
 
 
@@ -211,11 +212,75 @@ class CmakeProjectGen:
         def py(self) -> CmakeProjectGen.PyInfo:
             return self.p.py_info()
 
+        def _get_ext_file_config(self, src_file: str) -> CextConfig:
+            source_file = os.path.join(self.p.prj_root, src_file)
+            with open(source_file) as f:
+                src = f.read()
+
+            src_magics = magic.find_magic(
+                magic.C_MAGIC_STYLE,
+                src.splitlines(),
+                file=source_file,
+                preparer=magic.json_magic_preparer,
+            )
+
+            cext_magic = check.single(m for m in src_magics if m.key == CextMagic.KEY)
+
+            if cext_magic.prepared is None:
+                return CextConfig()
+
+            return unmarshal_obj(cext_magic.prepared, CextConfig)
+
+        def _expand_ext_config_files(
+                self,
+                ext_src: str,
+                config_files: ta.Sequence[str],
+                *,
+                exclude_files: ta.Sequence[str] = (),
+        ) -> list[str]:
+            return expand_cext_config_files(
+                ext_src,
+                config_files,
+                exclude_files=exclude_files,
+                root_dir=self.p.prj_root,
+            )
+
+        def _symlink_source_file(self, src_file: str) -> str:
+            source_file = os.path.abspath(os.path.join(self.p.prj_root, src_file))
+            if not os.path.isfile(source_file):
+                raise FileNotFoundError(source_file)
+
+            link_file = os.path.join(self.p.cmake_dir(), src_file)
+            link_dir = os.path.dirname(link_file)
+            os.makedirs(link_dir, exist_ok=True)
+
+            if os.path.lexists(link_file):
+                if os.path.realpath(link_file) != source_file:
+                    raise FileExistsError(link_file)
+            else:
+                os.symlink(os.path.relpath(source_file, link_dir), link_file)
+
+            return src_file
+
+        @staticmethod
+        def _get_ext_libraries(ext_cfg: CextConfig) -> list[str]:
+            out = []
+            for ext_lib in ext_cfg.libraries or ():
+                if isinstance(ext_lib, str):
+                    out.append(ext_lib)
+                else:
+                    ext_lib_name, ext_lib_platform = ext_lib
+                    if ext_lib_platform == sys.platform:
+                        out.append(ext_lib_name)
+            return out
+
         def _add_ext(self, ext_src: str) -> None:
             ext_name = ext_src.rpartition('.')[0].replace('/', '__')
 
             log.info('Adding cmake c extension: %s -> %s', ext_src, ext_name)
 
+            ext_cfg = self._get_ext_file_config(ext_src)  # noqa
+
             so_name = ''.join([
                 os.path.basename(ext_src).split('.')[0],
                 '.',
@@ -223,29 +288,39 @@ class CmakeProjectGen:
                 sysconfig.get_config_var('SHLIB_SUFFIX'),
             ])
 
-            sl = os.path.join(self.p.cmake_dir(), ext_src)
-            sal = os.path.abspath(sl)
-            sd = os.path.dirname(sal)
-            os.makedirs(sd, exist_ok=True)
-            rp = os.path.relpath(os.path.abspath(ext_src), sd)
-            os.symlink(rp, sal)
+            extra_sources = self._expand_ext_config_files(
+                ext_src,
+                ext_cfg.extra_sources or (),
+                exclude_files=[ext_src],
+            )
+            extra_headers = self._expand_ext_config_files(ext_src, ext_cfg.extra_headers or ())
+
+            src_files = [
+                self._symlink_source_file(src_file)
+                for src_file in [ext_src, *extra_sources, *extra_headers]
+            ]
 
             ml = cmake.ModuleLibrary(
                 ext_name,
-                src_files=[
-                    sl,
-                ],
+                src_files=src_files,
                 include_dirs=[
                     f'${{{self.var_prefix}_INCLUDE_DIRECTORIES}}',
                 ],
+                compile_defs=[
+                    f'{name}={value}'
+                    for name, value in (ext_cfg.define_macros or {}).items()
+                ],
                 compile_opts=[
                     f'${{{self.var_prefix}_COMPILE_OPTIONS}}',
+                    *(ext_cfg.extra_compile_args or ()),
                 ],
                 link_dirs=[
                     f'${{{self.var_prefix}_LINK_DIRECTORIES}}',
                 ],
+                link_opts=ext_cfg.extra_link_args,
                 link_libs=[
                     f'${{{self.var_prefix}_LINK_LIBRARIES}}',
+                    *self._get_ext_libraries(ext_cfg),
                 ],
                 extra_cmds=[
                     cmake.Command(

omdev-0.0.38/omdev/cexts/configs.py

@@ -0,0 +1,64 @@
+# ruff: noqa: UP006 UP045
+# @om-lite
+import dataclasses as dc
+import glob
+import os.path
+import typing as ta
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CextConfig:
+    extra_sources: ta.Optional[ta.Sequence[str]] = None
+    extra_headers: ta.Optional[ta.Sequence[str]] = None
+
+    extra_compile_args: ta.Optional[ta.Sequence[str]] = None
+    extra_link_args: ta.Optional[ta.Sequence[str]] = None
+
+    define_macros: ta.Optional[ta.Mapping[str, str]] = None
+
+    libraries: ta.Optional[ta.Sequence[ta.Any]] = None  # list[str | tuple[str, str]] | None
+
+
+def resolve_cext_config_file(ext_src: str, config_file: str) -> str:
+    if os.path.isabs(config_file):
+        raise ValueError(config_file)
+
+    ext_src = os.path.normpath(ext_src)
+    package_dir = ext_src.partition(os.sep)[0]
+    resolved_file = os.path.normpath(os.path.join(os.path.dirname(ext_src), config_file))
+    if os.path.commonpath([package_dir, resolved_file]) != package_dir:
+        raise ValueError(config_file)
+
+    return resolved_file
+
+
+def expand_cext_config_files(
+        ext_src: str,
+        config_files: ta.Sequence[str],
+        *,
+        exclude_files: ta.Sequence[str] = (),
+        root_dir: ta.Optional[str] = None,
+) -> ta.List[str]:
+    if root_dir is None:
+        root_dir = os.getcwd()
+    root_dir = os.path.abspath(root_dir)
+
+    out: ta.Set[str] = set()
+    for config_file in config_files:
+        resolved_pattern = resolve_cext_config_file(ext_src, config_file)
+        matched_files = [
+            matched_file
+            for matched_file in glob.glob(os.path.join(root_dir, resolved_pattern), recursive=True)
+            if os.path.isfile(matched_file)
+        ]
+        if not matched_files:
+            raise FileNotFoundError(resolved_pattern)
+
+        out.update(os.path.relpath(matched_file, root_dir) for matched_file in matched_files)
+
+    out.difference_update(os.path.normpath(exclude_file) for exclude_file in exclude_files)
+
+    return sorted(out)

{omdev-0.0.36 → omdev-0.0.38}/omdev/cmake.py

@@ -27,6 +27,7 @@ class Target(lang.Abstract):
     src_files: ta.Sequence[str]
 
     include_dirs: ta.Sequence[str] | None = None
+    compile_defs: ta.Sequence[str] | None = None
     compile_opts: ta.Sequence[str] | None = None
     link_dirs: ta.Sequence[str] | None = None
     link_opts: ta.Sequence[str] | None = None
@@ -135,6 +136,8 @@ class CmakeGen:
 
         if target.include_dirs:
             self.write_cmd(Command('target_include_directories', [target.name, 'PRIVATE'], target.include_dirs))
+        if target.compile_defs:
+            self.write_cmd(Command('target_compile_definitions', [target.name, 'PRIVATE'], target.compile_defs))
         if target.compile_opts:
             self.write_cmd(Command('target_compile_options', [target.name, 'PRIVATE'], target.compile_opts))
 

omdev-0.0.38/omdev/git/vendor/aborting.py

@@ -0,0 +1,72 @@
+import os
+import os.path
+
+from ..status import GitStatusState
+from ..status import get_git_status
+from .errors import GitVendorNoMergeInProgressError
+from .journals import GitVendorJournal
+from .journals import delete_vendor_journal
+from .journals import load_live_vendor_journal
+from .paths import is_path_under
+from .runners import GitRunner
+from .specs import vendor_spec_path
+
+
+##
+
+
+class GitVendorAborter:
+    """
+    Rolls back an in-progress vendor pull, restoring the vendored directory - index and working tree - to its
+    pre-pull state. Only paths under the vendored directory are ever touched: edits made anywhere else in the repo,
+    staged or not, are preserved untouched. A pull that has already been committed is no longer in progress and cannot
+    be aborted - that's what `git revert` is for.
+    """
+
+    def __init__(
+            self,
+            repo_dir: str,
+            vendor_dir: str,
+    ) -> None:
+        super().__init__()
+
+        self._repo_dir = repo_dir
+        self._vendor_dir = vendor_dir.rstrip('/')
+
+        self._repo = GitRunner(repo_dir)
+
+    def _try_unlink(self, rel_path: str) -> None:
+        try:
+            os.unlink(os.path.join(self._repo_dir, rel_path))
+        except FileNotFoundError:
+            pass
+
+    def abort(self) -> GitVendorJournal:
+        git_dir = self._repo.output_str('rev-parse', '--absolute-git-dir')
+
+        journal = load_live_vendor_journal(self._repo, git_dir, self._vendor_dir)
+        if journal is None:
+            raise GitVendorNoMergeInProgressError(f'No vendor pull of {self._vendor_dir} is in progress')
+
+        rel_paths = [os.path.join(self._vendor_dir, e.path) for e in journal.entries]
+        rel_paths.append(vendor_spec_path(self._vendor_dir))
+
+        for rel_path in rel_paths:
+            if self._repo.has_object(f'{journal.pre_head}:{rel_path}'):
+                # Restores both index and working tree, clearing any conflict stages for the path as it goes.
+                self._repo.run('checkout', journal.pre_head, '--', rel_path)
+            else:
+                self._repo.run('update-index', '--force-remove', '--', rel_path)
+                self._try_unlink(rel_path)
+
+        # The clean-tree gate at pull time means anything untracked under the vendor dir appeared during the merge
+        # (mergetool backups and the like) - sweep them.
+        for it in get_git_status(cwd=self._repo_dir):
+            if it.x is GitStatusState.UNTRACKED and is_path_under(it.a, self._vendor_dir):
+                self._try_unlink(it.a)
+
+        self._repo.run('update-index', '--clear-resolve-undo', check_rc=False)
+
+        delete_vendor_journal(git_dir, self._vendor_dir)
+
+        return journal

omdev-0.0.38/omdev/git/vendor/diffing.py

@@ -0,0 +1,64 @@
+import difflib
+import os.path
+
+from .errors import GitVendorUpstreamRevError
+from .specs import load_vendor_spec
+from .upstreams import git_upstream_source
+
+
+##
+
+
+class GitVendorDiffer:
+    """
+    Renders a unified diff of the local vendored files against their pristine upstream contents at the spec's recorded
+    rev - that is, the accumulated local patches. Requires upstream access (a local clone via `from_path`, or a
+    temporary clone of the spec url) since pristine content is deliberately not stored in the repo.
+    """
+
+    def __init__(
+            self,
+            repo_dir: str,
+            vendor_dir: str,
+            *,
+            from_path: str | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._repo_dir = repo_dir
+        self._vendor_dir = vendor_dir.rstrip('/')
+        self._from_path = from_path
+
+        self._abs_vendor_dir = os.path.join(repo_dir, self._vendor_dir)
+
+    def diff(self) -> str:
+        spec = load_vendor_spec(self._abs_vendor_dir)
+        if spec.rev is None:
+            raise GitVendorUpstreamRevError(f'{self._vendor_dir} has no recorded rev - it has never been pulled')
+
+        out: list[str] = []
+
+        with git_upstream_source(spec.url, from_path=self._from_path) as upstream:
+            if not upstream.has_object(spec.rev + '^{commit}'):
+                raise GitVendorUpstreamRevError(f'Base rev {spec.rev!r} is not present in upstream {upstream.dir}')
+
+            for path in spec.files:
+                base = upstream.try_read_blob(spec.rev, path)
+
+                try:
+                    with open(os.path.join(self._abs_vendor_dir, path), 'rb') as f:
+                        ours = f.read()
+                except FileNotFoundError:
+                    ours = None
+
+                if base == ours:
+                    continue
+
+                out.extend(difflib.unified_diff(
+                    (base or b'').decode('utf-8', errors='replace').splitlines(keepends=True),
+                    (ours or b'').decode('utf-8', errors='replace').splitlines(keepends=True),
+                    fromfile=f'a/{path}',
+                    tofile=f'b/{path}',
+                ))
+
+        return ''.join(out)

omdev-0.0.38/omdev/git/vendor/errors.py

@@ -0,0 +1,40 @@
+import typing as ta
+
+
+##
+
+
+class GitVendorError(Exception):
+    pass
+
+
+class GitVendorSubprocessError(GitVendorError):
+    """Raised when an underlying git invocation fails unexpectedly."""
+
+    def __init__(self, cmd: ta.Sequence[str], returncode: int, stderr: str) -> None:
+        super().__init__(f'git command {list(cmd)!r} failed with returncode {returncode}: {stderr}')
+
+        self.cmd = cmd
+        self.returncode = returncode
+        self.stderr = stderr
+
+
+class GitVendorDirtyError(GitVendorError):
+    """Raised when the containing repo has changes which preclude beginning a vendor operation."""
+
+    def __init__(self, paths: ta.Sequence[str]) -> None:
+        super().__init__(f'Repo has blocking changes: {", ".join(paths)}')
+
+        self.paths = paths
+
+
+class GitVendorMergeInProgressError(GitVendorError):
+    pass
+
+
+class GitVendorNoMergeInProgressError(GitVendorError):
+    pass
+
+
+class GitVendorUpstreamRevError(GitVendorError):
+    pass

omdev-0.0.38/omdev/git/vendor/journals.py

@@ -0,0 +1,124 @@
+import enum
+import os
+import os.path
+import typing as ta
+import urllib.parse
+
+from omcore import dataclasses as dc
+from omcore import lang
+from omcore.formats.json import all as json
+
+from .runners import GitRunner
+
+
+with lang.auto_proxy_import(globals()):
+    from omcore import marshal as msh
+
+
+##
+
+
+class GitVendorFileDisposition(enum.Enum):
+    UNCHANGED = 'unchanged'
+    LOCAL_ONLY = 'local-only'
+    ADDED = 'added'
+    DELETED = 'deleted'
+    FAST_FORWARDED = 'fast-forwarded'
+    AUTO_MERGED = 'auto-merged'
+    CONFLICTED = 'conflicted'
+    DELETE_CONFLICTED = 'delete-conflicted'
+
+
+CHANGING_GIT_VENDOR_FILE_DISPOSITIONS: ta.AbstractSet[GitVendorFileDisposition] = frozenset([
+    GitVendorFileDisposition.ADDED,
+    GitVendorFileDisposition.DELETED,
+    GitVendorFileDisposition.FAST_FORWARDED,
+    GitVendorFileDisposition.AUTO_MERGED,
+    GitVendorFileDisposition.CONFLICTED,
+    GitVendorFileDisposition.DELETE_CONFLICTED,
+])
+
+CONFLICTED_GIT_VENDOR_FILE_DISPOSITIONS: ta.AbstractSet[GitVendorFileDisposition] = frozenset([
+    GitVendorFileDisposition.CONFLICTED,
+    GitVendorFileDisposition.DELETE_CONFLICTED,
+])
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class GitVendorJournalEntry:
+    path: str
+    disposition: GitVendorFileDisposition
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class GitVendorJournal:
+    """
+    A record of an in-progress vendor pull, written before any repo mutation is performed.
+
+    Stored under the repo's git dir (never the worktree) so it can never be staged, committed, or pushed. `vendor_dir`
+    is relative to the repo root, `pre_head` is the commit HEAD pointed at when the pull began, and entry paths are
+    relative to the vendor dir.
+    """
+
+    vendor_dir: str
+    pre_head: str
+    old_rev: str | None = None
+    new_rev: str
+    new_ref: str | None = None
+    entries: ta.Sequence[GitVendorJournalEntry] = ()
+
+    @property
+    def conflicted_entries(self) -> ta.Sequence[GitVendorJournalEntry]:
+        return [e for e in self.entries if e.disposition in CONFLICTED_GIT_VENDOR_FILE_DISPOSITIONS]
+
+
+##
+
+
+def vendor_journal_path(git_dir: str, vendor_dir: str) -> str:
+    return os.path.join(git_dir, 'om-vendor', urllib.parse.quote(vendor_dir, safe='') + '.json')
+
+
+def load_vendor_journal(git_dir: str, vendor_dir: str) -> GitVendorJournal | None:
+    try:
+        with open(vendor_journal_path(git_dir, vendor_dir)) as f:
+            buf = f.read()
+    except FileNotFoundError:
+        return None
+
+    return msh.unmarshal(json.loads(buf), GitVendorJournal)
+
+
+def save_vendor_journal(git_dir: str, journal: GitVendorJournal) -> None:
+    path = vendor_journal_path(git_dir, journal.vendor_dir)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, 'w') as f:
+        f.write(json.dumps_pretty(msh.marshal(journal)) + '\n')
+
+
+def delete_vendor_journal(git_dir: str, vendor_dir: str) -> None:
+    try:
+        os.unlink(vendor_journal_path(git_dir, vendor_dir))
+    except FileNotFoundError:
+        pass
+
+
+def load_live_vendor_journal(repo: GitRunner, git_dir: str, vendor_dir: str) -> GitVendorJournal | None:
+    """
+    Loads the journal for a genuinely in-progress pull, if any. A journal whose pull was subsequently committed -
+    detected by commits since its pre_head touching the vendor dir - is stale, and is deleted rather than returned.
+    """
+
+    journal = load_vendor_journal(git_dir, vendor_dir)
+    if journal is None:
+        return None
+
+    head = repo.rev_parse('HEAD')
+    if (
+            head != journal.pre_head and
+            bool(repo.output_str('diff', '--name-only', journal.pre_head, head, '--', vendor_dir))
+    ):
+        delete_vendor_journal(git_dir, vendor_dir)
+        return None
+
+    return journal

omdev-0.0.38/omdev/git/vendor/merging.py

@@ -0,0 +1,70 @@
+import os.path
+import subprocess
+import tempfile
+
+from omcore import dataclasses as dc
+from omcore.subprocesses.wrap import subprocess_maybe_shell_wrap_exec
+
+from .errors import GitVendorSubprocessError
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class GitMergeFileResult:
+    content: bytes
+    conflicted: bool
+
+
+def run_git_merge_file(
+        base: bytes,
+        ours: bytes,
+        theirs: bytes,
+        *,
+        labels: tuple[str, str, str] = ('ours', 'base', 'theirs'),
+        timeout: float = 5. * 60.,
+) -> GitMergeFileResult:
+    """
+    Three-way merges the given file contents via `git merge-file -p`, returning the merged content - with standard
+    conflict markers if conflicted. An empty `base` yields a two-way whole-file conflict, matching git's 'both added'
+    behavior.
+    """
+
+    ours_label, base_label, theirs_label = labels
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        names = []
+        for name, data in [('ours', ours), ('base', base), ('theirs', theirs)]:
+            file_path = os.path.join(tmp_dir, name)
+            with open(file_path, 'wb') as f:
+                f.write(data)
+            names.append(file_path)
+
+        proc = subprocess.run(  # noqa
+            subprocess_maybe_shell_wrap_exec(
+                'git',
+                'merge-file',
+                '-p',
+                '-L', ours_label,
+                '-L', base_label,
+                '-L', theirs_label,
+                *names,
+            ),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=timeout,
+        )
+
+    # merge-file's returncode is the number of conflicts, or negative (observed as >127) on error.
+    if proc.returncode > 127:
+        raise GitVendorSubprocessError(
+            ['git', 'merge-file'],
+            proc.returncode,
+            proc.stderr.decode(errors='replace').strip(),
+        )
+
+    return GitMergeFileResult(
+        content=proc.stdout,
+        conflicted=proc.returncode != 0,
+    )

omdev-0.0.38/omdev/git/vendor/paths.py

@@ -0,0 +1,5 @@
+##
+
+
+def is_path_under(path: str, dir: str) -> bool:  # noqa
+    return path == dir or path.startswith(dir + '/')