calkit-python 0.41.21__tar.gz → 0.41.22__tar.gz

{calkit_python-0.41.21 → calkit_python-0.41.22}/AGENTS.md

@@ -34,6 +34,12 @@ a feature in one function over many different test functions.
 
 Do not write docstrings in test functions.
 
+Do not put blank lines inside function bodies; separate logical sections with
+comments instead. This only applies to blank lines we write, not ones the
+formatter inserts, e.g., ruff-format adds one after an in-function import
+block. Don't hoist imports to module scope just to avoid those; imports are
+kept inside functions to keep CLI startup fast.
+
 For prose, only use one space after punctuation.
 
 Don't overzealously split up functions just because they're long.

{calkit_python-0.41.21 → calkit_python-0.41.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.41.21
+Version: 0.41.22
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.41.21 → calkit_python-0.41.22}/calkit/cli/main/core.py

@@ -1419,6 +1419,39 @@ def _stage_run_info_from_log_content(log_content: str) -> dict:
     return res
 
 
+def _run_dvc_repro(argv: list[str]) -> int | None:
+    """Run ``dvc repro`` via the DVC CLI, tolerating teardown failures.
+
+    Returns DVC's exit code, or ``None`` if the command ran but DVC's
+    post-command teardown failed to import a module. After ``do_run`` finishes,
+    ``dvc.cli.main`` reports anonymous analytics and cleans up cached repos,
+    importing ``dvc.daemon`` and ``dvc.repo.open_repo`` only at that point. In
+    some broken or mixed installs those submodules can't be imported, so the
+    teardown raises a ``ModuleNotFoundError`` that escapes DVC entirely and
+    crashes the run with a confusing traceback once the pipeline has already
+    finished (see issue #1018). That doesn't affect the pipeline result, so
+    swallow it and signal ``None`` so the caller derives success/failure from
+    the run log instead of a lost exit code.
+
+    Only those two modules are tolerated, and deliberately so. ``dvc.cli.main``
+    runs the command inside a broad ``except Exception`` that turns any failure
+    into an exit code, so nothing from the command itself reaches here; but it
+    also imports ``dvc._debug``/``dvc.config``/``dvc.logger`` *before* that
+    block, and a broken install can fail there too. Swallowing those would leave
+    an empty run log and report a pipeline that never ran as successful, so
+    anything but a teardown module must propagate and fail loudly.
+    """
+    from dvc.cli import main as dvc_cli_main
+
+    try:
+        return int(dvc_cli_main(argv))
+    except ModuleNotFoundError as e:
+        if e.name not in ("dvc.daemon", "dvc.repo.open_repo"):
+            raise
+        warn(f"DVC post-run teardown failed and was ignored ({e})")
+        return None
+
+
 def _prune_run_logs(
     logs_dir: str, keep: int = 10, protect: str | None = None
 ) -> None:
@@ -1828,7 +1861,6 @@ def run(
     import dvc.repo
     import dvc.repo.reproduce
     import dvc.ui
-    from dvc.cli import main as dvc_cli_main
     from git.exc import InvalidGitRepositoryError
 
     import calkit.dvc.zip
@@ -2080,13 +2112,21 @@ def run(
                 with calkit.dvc.dvc_lock_timeout(
                     calkit.dvc.DEFAULT_RUN_LOCK_TIMEOUT
                 ):
-                    sp_res = dvc_cli_main(["repro"] + sp_args)
+                    sp_res = _run_dvc_repro(["repro"] + sp_args)
             finally:
                 os.chdir(original_dir)
-            if sp_res != 0:
+            # ``None`` means the stage ran but DVC's teardown failed; treat that
+            # as success since the exit code is unrecoverable here.
+            if sp_res is not None and sp_res != 0:
                 failed = True
         if not args or all(a.startswith("--") for a in args):
-            # Only isolated subproject stage targets were given; skip parent run
+            # Only isolated subproject stage targets were given; skip the parent
+            # run, but still report failure the way the parent path does below,
+            # else a failing subproject stage would exit zero.
+            os.environ.pop("CALKIT_PIPELINE_RUNNING", None)
+            if failed:
+                raise_error("Pipeline failed")
+            calkit.echo("Pipeline completed successfully ✅")
             return {}
     if pipeline is not None:
         args += ["--pipeline", pipeline]
@@ -2157,14 +2197,21 @@ def run(
         # the instant it finishes) can all hold it momentarily. Without this,
         # such a collision aborts the whole run with "Unable to acquire lock".
         with calkit.dvc.dvc_lock_timeout(calkit.dvc.DEFAULT_RUN_LOCK_TIMEOUT):
-            res = dvc_cli_main(["repro"] + args)
+            res = _run_dvc_repro(["repro"] + args)
     finally:
         os.environ.pop("CALKIT_FORCE", None)
-    failed = failed or res != 0
     # Parse log to get timing and which stages ran
     with open(log_fpath, "r") as f:
         log_content = f.read()
         stage_run_info = _stage_run_info_from_log_content(log_content)
+    if res is None:
+        # DVC's exit code was lost to a teardown failure; fall back to the log,
+        # which records any stage that failed to reproduce.
+        failed = failed or any(
+            info.get("status") == "failed" for info in stage_run_info.values()
+        )
+    else:
+        failed = failed or res != 0
     # Zip dvc-zip outputs for stages that actually ran
     if stage_run_info:
         from calkit.models.io import PathOutput

{calkit_python-0.41.21 → calkit_python-0.41.22}/calkit/tests/cli/main/test_core.py

@@ -8,6 +8,7 @@ import sys
 from datetime import datetime
 from pathlib import Path
 from pprint import pprint
+from unittest.mock import Mock
 
 import dvc.repo
 import git
@@ -22,6 +23,7 @@ from calkit.cli.core import complete_stage_names
 from calkit.cli.main.core import (
     _get_running_pipeline_status,
     _prune_run_logs,
+    _run_dvc_repro,
     _stage_run_info_from_log_content,
     _stage_target_from_cmd,
     _to_shell_cmd,
@@ -915,6 +917,83 @@ def test_run(tmp_dir):
     assert "stage_run_info" in res
 
 
+def test_run_dvc_repro_tolerates_teardown_failure(monkeypatch, capsys):
+    import dvc.cli
+
+    # Normal invocation returns DVC's exit code unchanged
+    monkeypatch.setattr(dvc.cli, "main", Mock(return_value=7))
+    assert _run_dvc_repro(["repro", "my-stage"]) == 7
+    # DVC lazily imports ``dvc.daemon`` and ``dvc.repo.open_repo`` for
+    # analytics/cleanup only after the command has already run. On a broken
+    # install those imports fail (issue #1018), crashing the run once the
+    # pipeline has finished, so tolerate them and report ``None`` instead.
+    for missing in ["dvc.daemon", "dvc.repo.open_repo"]:
+        monkeypatch.setattr(
+            dvc.cli,
+            "main",
+            Mock(
+                side_effect=ModuleNotFoundError(
+                    f"No module named {missing!r}", name=missing
+                )
+            ),
+        )
+        assert _run_dvc_repro(["repro"]) is None
+        assert "teardown failed" in capsys.readouterr().out
+    # A module DVC imports *before* running the command (dvc._debug, dvc.config,
+    # dvc.logger) failing means the pipeline never ran at all. Swallowing that
+    # would leave an empty log and report success, so it must propagate.
+    monkeypatch.setattr(
+        dvc.cli,
+        "main",
+        Mock(
+            side_effect=ModuleNotFoundError(
+                "No module named 'dvc._debug'", name="dvc._debug"
+            )
+        ),
+    )
+    with pytest.raises(ModuleNotFoundError, match="dvc._debug"):
+        _run_dvc_repro(["repro"])
+    # Non-import errors are unexpected too -- DVC turns real command failures
+    # into an exit code -- so they must propagate rather than be masked.
+    monkeypatch.setattr(
+        dvc.cli, "main", Mock(side_effect=RuntimeError("boom"))
+    )
+    with pytest.raises(RuntimeError, match="boom"):
+        _run_dvc_repro(["repro"])
+
+
+def test_run_isolated_subproject_stage_exit_code(tmp_dir):
+    subprocess.check_call(["calkit", "init"])
+    # An isolated subproject is its own Git/DVC repo, so its stage targets run
+    # directly inside it rather than through the parent pipeline
+    os.makedirs("isolated-sp", exist_ok=True)
+    subprocess.check_call(["git", "init"], cwd="isolated-sp")
+    subprocess.check_call(["calkit", "init"], cwd="isolated-sp")
+    ck_info = calkit.load_calkit_info()
+    ck_info["subprojects"] = [{"path": "isolated-sp"}]
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
+    # A failing subproject stage must exit nonzero; the isolated-target path
+    # returns before the parent pipeline runs, and used to skip raising
+    with open("isolated-sp/dvc.yaml", "w") as f:
+        yaml.dump(
+            {
+                "stages": {
+                    "stage-b": {"cmd": 'python -c "import sys; sys.exit(1)"'}
+                }
+            },
+            f,
+        )
+    result = subprocess.run(["calkit", "run", "isolated-sp:stage-b"])
+    assert result.returncode != 0
+    # A passing one still exits zero
+    with open("isolated-sp/dvc.yaml", "w") as f:
+        yaml.dump(
+            {"stages": {"stage-b": {"cmd": "python -c \"print('ok')\""}}}, f
+        )
+    subprocess.check_call(["calkit", "run", "isolated-sp:stage-b"])
+
+
 def test_run_ignore_errors(tmp_dir):
     subprocess.check_call(["calkit", "init"])
     # Create a pipeline with a failing stage and an independent stage