calkit-python 0.41.7__py3-none-any.whl → 0.41.8__py3-none-any.whl

calkit/cli/main/core.py

@@ -2418,7 +2418,16 @@ def run_in_env(
             )
         # TODO: Prefix should only be in the env file or calkit.yaml, not both?
         prefix = env.get("prefix")
-        conda_cmd = ["conda", "run"]
+        # Conda is often not on the PATH (especially on Windows), so search
+        # typical install locations rather than relying on the bare name,
+        # which would fail with a confusing FileNotFoundError traceback.
+        conda_exe = calkit.conda.find_conda_exe()
+        if conda_exe is None:
+            raise_error(
+                "Cannot find Conda executable; "
+                "ensure Conda is installed and on the PATH"
+            )
+        conda_cmd = [conda_exe, "run"]
         if prefix is not None:
             conda_cmd += ["--prefix", os.path.abspath(prefix)]
         else:

calkit/cli/new.py

@@ -7,6 +7,7 @@ import os
 import pathlib
 import shutil
 import subprocess
+import time
 from enum import Enum
 
 import typer
@@ -3325,22 +3326,23 @@ def new_release(
                 f"/records/{record_id}/draft/files/{filename}/commit",
                 service=to,  # type: ignore
             )
-        # Conditionally publish or reserve DOI based on --draft flag
-        if draft_only:
-            # Reserve a DOI for the draft record
-            typer.echo(f"Reserving DOI for {to} draft record ID {record_id}")
-            doi_resp = calkit.invenio.post(
-                f"/records/{record_id}/draft/pids/doi",
-                service=to,  # type: ignore
+        # Reserve a DOI on the draft before publishing. The publish action's
+        # response only echoes back the DOI under "pids" if one was reserved
+        # on the draft first (otherwise "pids" comes back empty), so always
+        # reserve here to get a stable identifier.
+        typer.echo(f"Reserving DOI for {to} draft record ID {record_id}")
+        doi_resp = calkit.invenio.post(
+            f"/records/{record_id}/draft/pids/doi",
+            service=to,  # type: ignore
+        )
+        if verbose:
+            typer.echo(f"DOI reservation response:\n{doi_resp}")
+        doi = calkit.invenio.extract_doi(doi_resp)
+        if doi is None:
+            raise_error(
+                f"Failed to reserve DOI for {to} draft record {record_id}"
             )
-            if verbose:
-                typer.echo(f"DOI response for draft:\n{doi_resp}")
-            try:
-                doi = doi_resp["pids"]["doi"]["identifier"]
-            except KeyError:
-                doi = doi_resp["doi"]
-            except Exception as e:
-                raise_error(f"Failed to reserve DOI for draft: {e}")
+        if draft_only:
             url = f"https://doi.org/{doi}"
             typer.echo(f"Created {to} draft with reserved DOI: {doi}")
         else:
@@ -3350,8 +3352,37 @@ def new_release(
                 f"/records/{record_id}/draft/actions/publish",
                 service=to,  # type: ignore
             )
+            if verbose:
+                typer.echo(f"Publish response:\n{invenio_dep}")
             record_id = invenio_dep["id"]
-            doi = invenio_dep["pids"]["doi"]["identifier"]
+            # Prefer the DOI from the publish response, but fall back to the
+            # reserved DOI (and a fetch of the published record) since the
+            # publish action returns 202 and may not echo "pids" immediately.
+            # Polling failures are tolerated: we already have the reserved DOI,
+            # so a transient error while the record settles should not abort
+            # the release.
+            published_doi = calkit.invenio.extract_doi(invenio_dep)
+            for _ in range(10):
+                if published_doi is not None:
+                    break
+                time.sleep(1)
+                try:
+                    record = calkit.invenio.get(
+                        f"/records/{record_id}",
+                        service=to,  # type: ignore
+                    )
+                except Exception as e:
+                    if verbose:
+                        typer.echo(f"Polling for published DOI failed: {e}")
+                    continue
+                published_doi = calkit.invenio.extract_doi(record)
+            if published_doi is not None:
+                doi = published_doi
+            else:
+                typer.echo(
+                    "Could not confirm minted DOI from published record; "
+                    f"falling back to reserved DOI {doi}"
+                )
             url = f"https://doi.org/{doi}"
             typer.echo(f"Published to {to} with DOI: {doi}")
     else:

calkit/core.py

@@ -341,6 +341,14 @@ def check_dep_exists(
         return True
     if system_info is not None and system_info.get(f"{name}_version"):
         return True
+    # Conda and mamba are frequently installed but not on the PATH (most
+    # commonly on Windows), so search their typical install locations
+    # rather than relying on the bare name being directly executable.
+    if name in ("conda", "mamba"):
+        from calkit.conda import find_conda_exe, find_mamba_exe
+
+        exe = find_conda_exe() if name == "conda" else find_mamba_exe()
+        return exe is not None
     cmd = [name]
     # Executables with non-conventional CLIs
     if name == "matlab":

calkit/invenio.py

@@ -107,6 +107,26 @@ put = partial(_request, "put")
 delete = partial(_request, "delete")
 
 
+def extract_doi(record: dict) -> str | None:
+    """Extract the DOI identifier from an InvenioRDM record or response.
+
+    Depending on the endpoint and whether the DOI has been minted yet, the
+    identifier can live in different places, so check all known locations and
+    return ``None`` if it isn't present yet.
+    """
+    pids = record.get("pids")
+    if isinstance(pids, dict):
+        doi = pids.get("doi")
+        if isinstance(doi, dict) and doi.get("identifier"):
+            return doi["identifier"]
+    if record.get("doi"):
+        return record["doi"]
+    metadata = record.get("metadata")
+    if isinstance(metadata, dict) and metadata.get("doi"):
+        return metadata["doi"]
+    return None
+
+
 def get_download_urls(
     record_id: int | str,
     service: ServiceName = DEFAULT_SERVICE,

calkit/pipeline.py

@@ -96,10 +96,14 @@ class PipelineStatus(BaseModel):
     def always_run_stage_names(self) -> list[str]:
         # Only list stages whose sole change indicator is always_run; stages
         # that also have real changes are reported under stale_stage_names.
+        # Subproject stages are excluded: their always-changed status is a
+        # delegation detail, not a user-meaningful always-run stage of the
+        # parent project.
         return [
             name
             for name, stage in self.stale_stages.items()
             if stage.always_run
+            and not stage.is_subproject
             and not stage.modified_command
             and not stage.modified_inputs
             and not stage.modified_outputs
@@ -145,6 +149,12 @@ class StaleStage(BaseModel):
     modified_outputs: list[str] = Field(default_factory=list)
     modified_command: bool = False
     always_run: bool = False
+    # True for stages that originate from a subproject (either an individual
+    # "{sp}:{stage}" stage or a kept "{sp} (subproject)" wrapper). Subproject
+    # wrapper stages are marked always-changed purely as a delegation
+    # mechanism, so they should not be advertised as always-run stages of the
+    # parent project.
+    is_subproject: bool = False
 
     @staticmethod
     def _as_path_list(paths: object) -> list[str]:
@@ -227,6 +237,7 @@ class StaleStage(BaseModel):
         status_data: list | dict | str,
         configured_outputs: list[str] | None = None,
         path_prefix: str | None = None,
+        is_subproject: bool = False,
     ) -> "StaleStage":
         modified_inputs = []
         output_paths = []
@@ -312,6 +323,7 @@ class StaleStage(BaseModel):
             modified_outputs=modified_outputs,
             modified_command=modified_command,
             always_run=always_run,
+            is_subproject=is_subproject,
         )
 
 
@@ -546,6 +558,74 @@ def collapse_dvc_stages(
     return stage
 
 
+def _status_target_matches(
+    target: str,
+    display_name: str,
+    bare_name: str,
+    subproject: str | None,
+    stale_stage: StaleStage,
+) -> bool:
+    """Return True if a status ``target`` selects this stage.
+
+    Because the full DVC status is now computed and filtered locally (rather
+    than asking DVC to filter by target), this is where each ``target`` passed
+    to :func:`get_status` is resolved against a single stage. A ``target`` may
+    be a stage name in any of calkit's forms (``stage``, ``dvc.yaml:stage``,
+    ``subproject:stage``, or a whole ``subproject``) or a repo path, which is
+    matched against the stage's stale/modified inputs and outputs.
+
+    Iterated/matrix stages use a ``name@param`` key in DVC status, so the base
+    name (the part before ``@``) is matched too — targeting the base name
+    selects every iteration, consistent with how ``calkit run`` expands matrix
+    targets.
+    """
+    base_name = bare_name.split("@")[0]
+    # Stage-name matching is done against the raw target so it covers all of
+    # calkit's stage-target forms as well as DVC's native ``dvc.yaml:stage``
+    # and ``<subproject>/dvc.yaml:stage`` forms (the latter is what
+    # translate_run_targets emits for inline subprojects).
+    stage_aliases = {display_name, bare_name, base_name}
+    if subproject is not None:
+        subproject_name = Path(subproject).name
+        if target in {subproject, subproject_name}:
+            return display_name.startswith(
+                f"{subproject}:"
+            ) or display_name == (f"{subproject} (subproject)")
+        stage_aliases |= {
+            f"{subproject}:{bare_name}",
+            f"{subproject_name}:{bare_name}",
+            f"{subproject}:{base_name}",
+            f"{subproject_name}:{base_name}",
+            f"{subproject}/dvc.yaml:{bare_name}",
+            f"{subproject}/dvc.yaml:{base_name}",
+        }
+    else:
+        stage_aliases |= {
+            f"dvc.yaml:{bare_name}",
+            f"dvc.yaml:{base_name}",
+        }
+    if target in stage_aliases:
+        return True
+    # Otherwise treat the target as a repo path and match it against the
+    # stage's stale/modified inputs and outputs. A target is path-like if it
+    # exists on disk or contains a separator; this keeps root-level paths
+    # without separators (e.g. ``data`` or ``out.csv``) selectable, which a
+    # separator-only heuristic would miss. A target that looks like a stage
+    # selector (contains ``:``) but matched no stage above is not a path.
+    if ":" in target and not os.path.exists(target):
+        return False
+    is_pathlike = os.path.exists(target) or "/" in target or "\\" in target
+    if not is_pathlike:
+        return False
+    norm_target = Path(target).as_posix().rstrip("/")
+    candidate_paths = (
+        stale_stage.stale_outputs
+        + stale_stage.modified_inputs
+        + stale_stage.modified_outputs
+    )
+    return any(_paths_overlap(norm_target, p) for p in candidate_paths)
+
+
 def get_status(
     ck_info: dict | None = None,
     targets: list[str] | None = None,
@@ -628,7 +708,11 @@ def get_status(
             dvc_repo = calkit.dvc.get_dvc_repo()
             # calkit.dvc.core installs a filter on dvc.repo.status that drops
             # the noisy frozen-stage warning, so the call here stays quiet.
-            raw_status = dvc_repo.status(targets=targets)
+            # Ask DVC for the complete stale set, then filter locally.
+            # DVC's own target filtering can miss stale propagation from
+            # isolated subprojects, which makes targeted status disagree with
+            # the full-project status view.
+            raw_status = dvc_repo.status()
             raw_status = calkit.dvc.status_as_posix(raw_status)
         except Exception as e:
             result["errors"].append(
@@ -794,20 +878,47 @@ def get_status(
                 for output in stage_cfg.get("outputs", [])
             ]
             if subproject:
+                # Use posix separators so these match DVC's reported paths
+                # (which are always forward-slash, repo-root-relative). Using
+                # the OS-native separator here would, on Windows, produce a
+                # backslash variant that escapes path dedup and shows up as a
+                # duplicate stale output alongside DVC's posix path.
                 configured_outputs = [
-                    str(Path(subproject) / p) for p in raw_outputs
+                    (Path(subproject) / p).as_posix() for p in raw_outputs
                 ]
             else:
                 configured_outputs = raw_outputs
             # For isolated subprojects, DVC reports paths relative to the
             # subproject dir; prefix them so all paths are parent-relative.
+            # A stage is subproject-originating if it carries a subproject
+            # path ("{sp}:{stage}") or is a kept wrapper for a subproject
+            # ("{sp} (subproject)", whose bare name is a known subproject).
+            is_subproject = (
+                subproject is not None or bare_name in sp_by_stage_name
+            )
             ordered_stale_stages[display_name] = StaleStage.from_status_data(
                 status_data=status_data,
                 configured_outputs=configured_outputs,
                 path_prefix=subproject
                 if subproject in isolated_sp_paths
                 else None,
+                is_subproject=is_subproject,
             )
+        if targets:
+            ordered_stale_stages = {
+                display_name: stale_stage
+                for display_name, stale_stage in ordered_stale_stages.items()
+                if any(
+                    _status_target_matches(
+                        target,
+                        display_name,
+                        raw_stale_stages[display_name][0],
+                        raw_stale_stages[display_name][1],
+                        stale_stage,
+                    )
+                    for target in targets
+                )
+            }
         result["stale_stages"] = ordered_stale_stages
         return PipelineStatus(
             has_pipeline=result["has_pipeline"],

calkit/tests/cli/main/test_subprojects.py

@@ -296,3 +296,56 @@ def test_isolated_subproject_external_dep(tmp_dir):
         check_environments=False, compile_to_dvc=False
     )
     assert not status.is_stale
+
+
+def test_targeted_status_uses_full_subproject_status_for_stage_targets(
+    tmp_dir, monkeypatch
+):
+    os.makedirs("solver/.dvc", exist_ok=True)
+    root_ck = {
+        "subprojects": [{"path": "solver"}],
+        "pipeline": {
+            "stages": {
+                "post-process": {
+                    "outputs": [{"path": "final.txt", "storage": "git"}]
+                }
+            }
+        },
+    }
+    solver_ck = {
+        "pipeline": {
+            "stages": {
+                "package-paper": {
+                    "outputs": [{"path": "paper.txt", "storage": "git"}]
+                }
+            }
+        }
+    }
+
+    class FakeRepo:
+        def status(self, targets=None):
+            if targets is None:
+                return {
+                    "solver/dvc.yaml:package-paper": ["always changed"],
+                    "post-process": [
+                        {"changed deps": {"solver/docs/figs": "modified"}}
+                    ],
+                }
+            return {}
+
+    monkeypatch.setattr(
+        calkit,
+        "load_calkit_info",
+        lambda wdir=None: solver_ck if wdir == "solver" else root_ck,
+    )
+    monkeypatch.setattr(calkit.dvc, "get_dvc_repo", lambda *args: FakeRepo())
+    monkeypatch.setattr(calkit.dvc, "status_as_posix", lambda status: status)
+    status = calkit.pipeline.get_status(
+        ck_info=root_ck,
+        targets=["post-process"],
+        check_environments=False,
+        clean_notebooks=False,
+        compile_to_dvc=False,
+    )
+    assert status.is_stale
+    assert status.stale_stage_names == ["post-process"]

calkit/tests/cli/test_new.py

@@ -853,6 +853,322 @@ def test_new_release(tmp_dir, monkeypatch, httpserver):
     # )
 
 
+def test_new_release_publish_empty_pids(tmp_dir, monkeypatch, httpserver):
+    """Regression test for issue #927.
+
+    Zenodo's publish action returns 202 and its body may come back with an
+    empty ``pids`` payload, so the DOI cannot be read from the publish
+    response. We must not assume ``pids.doi.identifier`` is present: instead we
+    reserve the DOI on the draft beforehand and recover the minted DOI by
+    polling ``GET /records/{id}``. This mocks exactly that shape so a
+    regression back to ``resp["pids"]["doi"]["identifier"]`` would fail here.
+    """
+    record_id = "test-record-empty-pids"
+    reserved_doi = "10.5072/zenodo.reserved999"
+    monkeypatch.setenv(
+        "CALKIT_INVENIO_BASE_URL_ZENODO",
+        httpserver.url_for("").rstrip("/"),
+    )
+    monkeypatch.setenv("ZENODO_TOKEN", "test-token")
+    # Create draft
+    httpserver.expect_request(
+        re.compile(r"^/records$"), method="POST"
+    ).respond_with_json({"id": record_id, "pids": {}})
+    # File upload slot + content + commit
+    httpserver.expect_request(
+        re.compile(rf"^/records/{record_id}/draft/files$"), method="POST"
+    ).respond_with_json({"entries": []})
+    httpserver.expect_request(
+        re.compile(rf"^/records/{record_id}/draft/files/.+/content$"),
+        method="PUT",
+    ).respond_with_data("", status=200)
+    httpserver.expect_request(
+        re.compile(rf"^/records/{record_id}/draft/files/.+/commit$"),
+        method="POST",
+    ).respond_with_json({"key": "file", "status": "completed"})
+    # Reserve a DOI on the draft – this is where the identifier actually comes
+    # from in the #927 scenario
+    httpserver.expect_request(
+        re.compile(rf"^/records/{record_id}/draft/pids/doi$"), method="POST"
+    ).respond_with_json({"pids": {"doi": {"identifier": reserved_doi}}})
+    # Publish returns an EMPTY pids payload (the bug scenario)
+    httpserver.expect_request(
+        re.compile(rf"^/records/{record_id}/draft/actions/publish$"),
+        method="POST",
+    ).respond_with_json({"id": record_id, "pids": {}})
+    # The published record echoes the minted DOI, recovered by the poll
+    httpserver.expect_request(
+        re.compile(rf"^/records/{record_id}$"), method="GET"
+    ).respond_with_json(
+        {"id": record_id, "pids": {"doi": {"identifier": reserved_doi}}}
+    )
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "project",
+            ".",
+            "--title",
+            "Test project",
+            "--name",
+            "test-project",
+        ]
+    )
+    subprocess.check_call(
+        [
+            "git",
+            "remote",
+            "add",
+            "origin",
+            "https://github.com/calkit/test-project.git",
+        ]
+    )
+    calkit.releases.set_cff_authors(
+        [{"first_name": "Alice", "last_name": "Smith", "affiliation": "SomeU"}]
+    )
+    subprocess.check_call(
+        ["calkit", "update", "license", "--copyright-holder", "Some Person"]
+    )
+    # One-shot publish (no --draft) so the new.py publish/poll path runs
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "release",
+            "--name",
+            "v0.1.0",
+            "--description",
+            "First release.",
+            "--no-github",
+            "--no-push",
+            "--verbose",
+        ]
+    )
+    release = calkit.load_calkit_info()["releases"]["v0.1.0"]
+    # Despite the empty pids in the publish response, the DOI is recovered
+    assert release["doi"] == reserved_doi
+    assert release["url"] == f"https://doi.org/{reserved_doi}"
+
+
+def _setup_zenodo_sandbox_project(monkeypatch):
+    """Shared setup for the live Zenodo sandbox tests.
+
+    Skips unless the test is explicitly opted into via
+    ``CALKIT_TEST_ZENODO_SANDBOX=1`` (so it never runs in CI -- GitHub Actions
+    doesn't set that variable) and a sandbox token is available. Resolves the
+    token (allowing it to live in a local ``.env``), points the client at the
+    sandbox, and creates a project with authors and a license ready to be
+    released. Must be called from within a ``tmp_dir`` test.
+    """
+    if os.getenv("CALKIT_TEST_ZENODO_SANDBOX") != "1":
+        pytest.skip(
+            "Live Zenodo sandbox test; set CALKIT_TEST_ZENODO_SANDBOX=1 "
+            "(and provide a sandbox ZENODO_TOKEN) to run it"
+        )
+    # Allow the token to live in a local .env file (the usual way calkit
+    # resolves credentials). The calkit subprocesses run in tmp_dir, outside
+    # the repo, so their own load_dotenv() won't find it -- we load it here and
+    # export it below so they inherit it.
+    import dotenv
+
+    dotenv.load_dotenv()
+    token = (
+        os.getenv("ZENODO_TOKEN")
+        or os.getenv("CALKIT_TEST_ZENODO_TOKEN")
+        or os.getenv("CALKIT_ZENODO_TOKEN")
+    )
+    if not token:
+        pytest.skip(
+            "No sandbox Zenodo token found; set ZENODO_TOKEN (or "
+            "CALKIT_TEST_ZENODO_TOKEN) to a sandbox.zenodo.org token"
+        )
+    # Export the token as ZENODO_TOKEN so every calkit subprocess picks it up,
+    # and make sure nothing forces us onto the production base URL.
+    monkeypatch.setenv("ZENODO_TOKEN", token)
+    monkeypatch.delenv("CALKIT_USE_PROD_FOR_TESTS", raising=False)
+    monkeypatch.delenv("CALKIT_INVENIO_BASE_URL_ZENODO", raising=False)
+    # Sanity check: in the test env we should be pointed at the sandbox
+    assert (
+        calkit.invenio.get_base_url("zenodo")
+        == "https://sandbox.zenodo.org/api"
+    )
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "project",
+            ".",
+            "--title",
+            "Test project",
+            "--name",
+            "test-project",
+        ]
+    )
+    subprocess.check_call(
+        [
+            "git",
+            "remote",
+            "add",
+            "origin",
+            "https://github.com/calkit/test-project.git",
+        ]
+    )
+    calkit.releases.set_cff_authors(
+        [
+            {
+                "first_name": "Alice",
+                "last_name": "Smith",
+                "affiliation": "SomeU",
+                "orcid": "0000-0001-2345-6789",
+            },
+            {
+                "first_name": "Bob",
+                "last_name": "Jones",
+                "affiliation": None,
+                "orcid": None,
+            },
+        ]
+    )
+    subprocess.check_call(
+        ["calkit", "update", "license", "--copyright-holder", "Some Person"]
+    )
+
+
+def test_new_release_zenodo_sandbox(tmp_dir, monkeypatch):
+    """Live integration test against the real Zenodo sandbox API.
+
+    Unlike ``test_new_release`` (which mocks the Invenio API), this exercises
+    the full release flow against ``sandbox.zenodo.org`` so we can catch
+    regressions the mock can't -- e.g. metadata our client builds that the
+    real API rejects. It is deliberately gated behind
+    ``CALKIT_TEST_ZENODO_SANDBOX=1`` so it never runs in CI (GitHub Actions
+    does not set that variable); it's only for occasional manual local
+    verification.
+
+    Requirements to run locally::
+
+        CALKIT_TEST_ZENODO_SANDBOX=1
+        ZENODO_TOKEN=<a sandbox.zenodo.org personal access token with the
+                      deposit:write and deposit:actions scopes>
+
+    The test only ever creates (and then deletes) a *draft* record -- it never
+    publishes, because a published sandbox record cannot be removed via the
+    API and would litter the account.
+    """
+    _setup_zenodo_sandbox_project(monkeypatch)
+    record_id = None
+    try:
+        subprocess.check_call(
+            [
+                "calkit",
+                "new",
+                "release",
+                "--name",
+                "v0.1.0",
+                "--description",
+                "First release.",
+                "--draft",
+                "--no-github",
+                "--verbose",
+            ]
+        )
+        ck_info = calkit.load_calkit_info()
+        assert "v0.1.0" in ck_info["releases"]
+        release = ck_info["releases"]["v0.1.0"]
+        record_id = release["record_id"]
+        assert record_id is not None
+        # A DOI should have been reserved for the draft
+        assert release["doi"] is not None
+        # The draft really exists on the sandbox with the metadata we sent;
+        # fetching it confirms our client and the real API agree on shape
+        draft = calkit.invenio.get(f"/records/{record_id}/draft")
+        metadata = draft["metadata"]
+        assert metadata["title"] == "Test project"
+        # NOTE: our client POSTs the InvenioRDM metadata schema (creators with
+        # person_or_org/given_name/family_name), but the Zenodo draft GET
+        # endpoint echoes back the *legacy* Zenodo serialization, where each
+        # creator is a "Last, First" name string. Asserting on the real shape
+        # here is the whole point of this test -- the mock can't reveal it.
+        creators = metadata["creators"]
+        assert creators[0]["name"] == "Smith, Alice"
+        assert creators[0]["affiliation"] == "SomeU"
+        assert creators[1]["name"] == "Jones, Bob"
+        # License and the GitHub related-identifier round-trip correctly
+        assert metadata["license"]["id"] == "cc-by-4.0"
+        related = metadata["related_identifiers"]
+        assert (
+            related[0]["identifier"]
+            == "https://github.com/calkit/test-project"
+        )
+        # Reuploading the draft should also succeed against the real API
+        subprocess.check_call(
+            ["calkit", "update", "release", "--name", "v0.1.0", "--reupload"]
+        )
+    finally:
+        # Always clean up the draft so we don't accumulate records on the
+        # sandbox, even if an assertion above failed.
+        if record_id is not None:
+            try:
+                calkit.invenio.delete(
+                    f"/records/{record_id}/draft", as_json=False
+                )
+            except Exception as e:
+                print(f"Warning: failed to clean up sandbox draft: {e}")
+
+
+def test_new_release_zenodo_sandbox_publish(tmp_dir, monkeypatch):
+    """Live test of the full *publish* path against the Zenodo sandbox.
+
+    This is the companion to ``test_new_release_zenodo_sandbox``: instead of a
+    draft, it runs a one-shot ``new release`` (no ``--draft``), which is the
+    only path that exercises the DOI-minting logic this branch hardens --
+    reserving a DOI on the draft, publishing, and then (because the publish
+    action returns 202 and may not echo the DOI immediately) retrying a fetch
+    of the published record and pulling the DOI out with
+    ``invenio.extract_doi``.
+
+    Same opt-in gate as the draft test (``CALKIT_TEST_ZENODO_SANDBOX=1``), so
+    it never runs in CI. WARNING: unlike the draft test, this PUBLISHES a real
+    sandbox record, which cannot be deleted via the API, so each run leaves one
+    behind on the sandbox account. It is intentionally separate so the draft
+    test can stay self-cleaning.
+    """
+    _setup_zenodo_sandbox_project(monkeypatch)
+    # No --draft: reserve + publish + mint DOI in one shot. --no-push skips the
+    # git push and GitHub release entirely.
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "release",
+            "--name",
+            "v0.1.0",
+            "--description",
+            "First release.",
+            "--no-github",
+            "--no-push",
+            "--verbose",
+        ]
+    )
+    ck_info = calkit.load_calkit_info()
+    assert "v0.1.0" in ck_info["releases"]
+    release = ck_info["releases"]["v0.1.0"]
+    record_id = release["record_id"]
+    assert record_id is not None
+    # The minted DOI should have been resolved and saved (this is exactly what
+    # the publish-path fix is about)
+    doi = release["doi"]
+    assert doi is not None
+    assert doi.startswith("10.")
+    print(f"Published sandbox record {record_id} with DOI {doi}")
+    # The published record really exists and exposes the same DOI via the API,
+    # confirming extract_doi agrees with the real published record
+    record = calkit.invenio.get(f"/records/{record_id}")
+    assert calkit.invenio.extract_doi(record) == doi
+    # A Git tag for the release should have been created locally
+    assert "v0.1.0" in [tag.name for tag in git.Repo().tags]
+
+
 def test_new_release_is_runnable(tmp_dir, monkeypatch):
     # Provide a dummy Zenodo token so `new_release` can pass its early
     # token-validation step even in dry-run mode.

calkit/tests/test_core.py

@@ -108,6 +108,25 @@ def test_check_system_deps(tmp_dir):
         calkit.check_system_deps()
 
 
+def test_check_dep_exists_conda_off_path(monkeypatch):
+    # Conda is frequently installed but not on the PATH (especially on
+    # Windows). check_dep_exists should locate it via find_conda_exe rather
+    # than relying on ``conda --version`` being directly runnable.
+    import calkit.conda
+
+    # Simulate conda being absent from the PATH but present in a typical
+    # install location that find_conda_exe discovers.
+    monkeypatch.setattr(
+        calkit.conda, "find_conda_exe", lambda: "/opt/miniconda3/bin/conda"
+    )
+    monkeypatch.setattr(calkit.conda, "find_mamba_exe", lambda: None)
+    assert calkit.check_dep_exists("conda", "app")
+    assert not calkit.check_dep_exists("mamba", "app")
+    # When neither is findable, it should report missing.
+    monkeypatch.setattr(calkit.conda, "find_conda_exe", lambda: None)
+    assert not calkit.check_dep_exists("conda", "app")
+
+
 def test_get_md5(tmp_dir):
     with open("file1.txt", "w") as f:
         f.write("Hello world")

calkit/tests/test_invenio.py

@@ -13,3 +13,23 @@ def test_get_base_url():
 def test_get_token():
     token = calkit.invenio.get_token("zenodo")
     assert isinstance(token, str)
+
+
+def test_extract_doi():
+    extract_doi = calkit.invenio.extract_doi
+    # DOI under pids (e.g. publish response or reserved draft)
+    assert (
+        extract_doi({"pids": {"doi": {"identifier": "10.5281/zenodo.1"}}})
+        == "10.5281/zenodo.1"
+    )
+    # DOI at the top level
+    assert extract_doi({"doi": "10.5281/zenodo.2"}) == "10.5281/zenodo.2"
+    # DOI under metadata
+    assert (
+        extract_doi({"metadata": {"doi": "10.5281/zenodo.3"}})
+        == "10.5281/zenodo.3"
+    )
+    # Empty pids (publish response without a reserved DOI) returns None
+    assert extract_doi({"pids": {}}) is None
+    assert extract_doi({"pids": {"doi": {}}}) is None
+    assert extract_doi({}) is None

calkit/tests/test_pipeline.py

@@ -10,7 +10,9 @@ import calkit
 import calkit.pipeline
 from calkit.environments import get_env_lock_fpath
 from calkit.pipeline import (
+    StaleStage,
     _expand_dep_excluding_subprojects,
+    _status_target_matches,
     collapse_dvc_stages,
     stages_are_similar,
 )
@@ -1595,6 +1597,115 @@ def test_stale_stage_path_prefix():
     assert stale_cross.modified_inputs == ["shared.txt"]
 
 
+def test_subproject_configured_outputs_posix_no_duplicate():
+    # A non-isolated subproject stage's configured outputs are prefixed with
+    # the subproject path. DVC reports those same outputs as repo-root-relative
+    # posix paths. Building the configured path with the OS-native separator
+    # produced, on Windows, a backslash variant ("sub\out.csv") that escaped
+    # path dedup and showed up as a duplicate stale output alongside DVC's
+    # posix path ("sub/out.csv"). The configured path must therefore be posix.
+    from pathlib import PureWindowsPath
+
+    # The exact construction get_status performs; as_posix() normalizes the
+    # separator regardless of platform (PureWindowsPath stands in for Windows).
+    configured_output = (
+        PureWindowsPath("example-basic") / "data/raw/data.csv"
+    ).as_posix()
+    assert configured_output == "example-basic/data/raw/data.csv"
+    # DVC flagged the stage via a changed command and reports the output as a
+    # modified out using the same posix, repo-root-relative path.
+    stale_stage = calkit.pipeline.StaleStage.from_status_data(
+        status_data=[
+            {"changed outs": {"example-basic/data/raw/data.csv": "modified"}},
+            "changed command",
+        ],
+        configured_outputs=[configured_output],
+    )
+    # The configured output and the DVC-reported output are the same file, so
+    # it must appear exactly once -- no separator-variant duplicate.
+    assert stale_stage.stale_outputs == ["example-basic/data/raw/data.csv"]
+
+
+def test_always_run_excludes_subproject_stages():
+    # A subproject wrapper stage is marked always-changed purely as a
+    # delegation mechanism, so it must not be advertised as an always-run
+    # stage of the parent project. A genuine root always-run stage still is.
+    status = calkit.pipeline.PipelineStatus(
+        has_pipeline=True,
+        stale_stages={
+            "ticker": StaleStage(always_run=True),
+            "example-basic (subproject)": StaleStage(
+                always_run=True, is_subproject=True
+            ),
+        },
+    )
+    assert status.always_run_stage_names == ["ticker"]
+    # The subproject wrapper isn't stale either (pure always-run delegation).
+    assert "example-basic (subproject)" not in status.stale_stage_names
+    assert not status.is_stale
+
+
+def test_status_target_matches():
+    ss = StaleStage(
+        stale_outputs=["data/out.csv"],
+        modified_inputs=["data/in.csv"],
+    )
+    # Root stage selected by its name, the dvc.yaml: form, but not by an
+    # unrelated name.
+    assert _status_target_matches("build", "build", "build", None, ss)
+    assert _status_target_matches("dvc.yaml:build", "build", "build", None, ss)
+    assert not _status_target_matches("other", "build", "build", None, ss)
+    # A path target (one containing a separator, so it isn't mistaken for a
+    # bare stage name) matches a stage with overlapping stale/modified paths.
+    assert _status_target_matches("data/out.csv", "build", "build", None, ss)
+    assert _status_target_matches("data/in.csv", "build", "build", None, ss)
+    assert not _status_target_matches(
+        "other/path.csv", "build", "build", None, ss
+    )
+    # Iterated/matrix stages use a name@param key — targeting the base name
+    # (or its dvc.yaml: form) must select each iteration, matching how DVC
+    # filtered matrix targets before status was filtered locally.
+    assert _status_target_matches("sim", "sim@a", "sim@a", None, ss)
+    assert _status_target_matches("dvc.yaml:sim", "sim@a", "sim@a", None, ss)
+    assert _status_target_matches("sim@a", "sim@a", "sim@a", None, ss)
+    # Subproject stages selected by sp:stage, the whole subproject, and the
+    # matrix base name in either form.
+    assert _status_target_matches("sp:run", "sp:run", "run", "sp", ss)
+    assert _status_target_matches("sp", "sp:run", "run", "sp", ss)
+    assert _status_target_matches("sp:sim", "sp:sim@a", "sim@a", "sp", ss)
+    assert not _status_target_matches("sp:other", "sp:run", "run", "sp", ss)
+    # DVC's native inline-subproject stage form (what translate_run_targets
+    # emits for inline subprojects) must also select the stage.
+    assert _status_target_matches("sp/dvc.yaml:run", "sp:run", "run", "sp", ss)
+    assert _status_target_matches(
+        "sp/dvc.yaml:sim", "sp:sim@a", "sim@a", "sp", ss
+    )
+    assert not _status_target_matches(
+        "sp/dvc.yaml:other", "sp:run", "run", "sp", ss
+    )
+
+
+def test_status_target_matches_root_level_path(tmp_path, monkeypatch):
+    # A root-level path target without any separator (e.g. ``out.csv`` or a
+    # directory ``data``) must still be selectable when it exists on disk; a
+    # separator-only heuristic would wrongly treat it as a bare stage name.
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "out.csv").write_text("x")
+    (tmp_path / "data").mkdir()
+    ss = StaleStage(
+        stale_outputs=["out.csv"],
+        modified_inputs=["data/in.csv"],
+    )
+    assert _status_target_matches("out.csv", "build", "build", None, ss)
+    assert _status_target_matches("./out.csv", "build", "build", None, ss)
+    # A directory target overlaps a modified input nested under it.
+    assert _status_target_matches("data", "build", "build", None, ss)
+    assert _status_target_matches("data/", "build", "build", None, ss)
+    # A separator-less target that is neither a stage name nor an existing
+    # path is not selected.
+    assert not _status_target_matches("missing", "build", "build", None, ss)
+
+
 def test_collapse_dvc_stages():
     def out_paths(stage):
         return {

{calkit_python-0.41.7.dist-info → calkit_python-0.41.8.dist-info}/METADATA

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

{calkit_python-0.41.7.dist-info → calkit_python-0.41.8.dist-info}/RECORD

@@ -5,7 +5,7 @@ calkit/check.py,sha256=VVJErHeCzX-bcdRtu0dgMpLLMU7M38SZI_wqyMgdzwg,9080
 calkit/cloud.py,sha256=65380HbUVEINxXue9YZnbOX5PsnszdgR9ZCli0DR2Wg,15772
 calkit/conda.py,sha256=Jb1Fz3jwkk4SZ0NgoWXd4lf50gEC8d8U87ElrYjdiwk,30752
 calkit/config.py,sha256=tkrdAQU1m3__B9efpYgK6IhtLtS3WWFcVpY2zEQpBio,7573
-calkit/core.py,sha256=ykT1CPzaCnUruErEHCl-UawLYFUxtUPdcFgTD1qBstY,27457
+calkit/core.py,sha256=NbuNHcSRzmvovSIuCKB05aX_XZj3Hl38Szk-VQXCuM4,27873
 calkit/datasets.py,sha256=9lOlOreey2aJGMw6MiV9MDzSHp-fYkCf1k1AZbWTdQE,2235
 calkit/dependencies.py,sha256=y5N_4ctwp9rFZVg82Si9_2x8Yh64Ex-WqP0iiN5NNBE,13276
 calkit/detect.py,sha256=w8H8r2p0R38645TUWFz9xtmeinKic_T8E6eTuldN6OM,62418
@@ -16,7 +16,7 @@ calkit/git.py,sha256=rHAWdI13vA35m7q-MhlHj2KHMa42s4ecisTvKbdXKMw,13321
 calkit/github.py,sha256=8_yZ0ej8TKM4qk8iPeGq47R1I4MHdSoJ_Zpr1gRwNEM,1701
 calkit/gui.py,sha256=2UCrMyosc5v4CLlDcHO7oDwW9eLn5_WbNaLaG5bjMTc,23
 calkit/install.py,sha256=n989NLyZSTndj_rEaHceSip5aXP7zZIlG9QwbFs8kTc,7913
-calkit/invenio.py,sha256=ZCFCikrYLCffhbahwvVclPcFX4XdKJtfa8k4p9yK-jI,3580
+calkit/invenio.py,sha256=aJH04-X9eFzxnrnbrPs71XBeFYBgKYYPiVM2KtyCXEE,4294
 calkit/julia.py,sha256=fYj4KuwEPDianrDf6k5DHvfMYqs09v4ts7MOQTWa3OI,3329
 calkit/jupyter.py,sha256=lE8kKmauHqspY7aPOiNpLGQyw9jSn4taGZScm6aR87I,1157
 calkit/licenses.py,sha256=3ZNBFxwRrfSjx3poG3G07z7GRCKAkdWiZ1AFe1yr8Gg,6853
@@ -26,7 +26,7 @@ calkit/notebooks.py,sha256=obKRJaVf-rrQslcu76yx8lP18QKWGJOD_Irw7yHw9ek,8913
 calkit/office.py,sha256=mZqCxkIsmWthBAeJZ5SiGe21fn5zD2zXsy1E6nQIpWE,1291
 calkit/ops.py,sha256=lLlZAFeplU8uLeMavr99d__Iof-YYwKijus74WfLipk,854
 calkit/overleaf.py,sha256=5SI8HwglLVtVlzj7d15Bft_3ZC6AHn3IrAbqMKOAPX0,30170
-calkit/pipeline.py,sha256=7w1bN9rCUcqTfakEFHAJGIlk9aSHJr66_cPFgHSsHrQ,57994
+calkit/pipeline.py,sha256=PYOk_RHQAQL_SiSh-nV69OFxQ6Da7zbC4mBd2dw5rCo,63212
 calkit/releases.py,sha256=YK-PLD5fQ7Zapw0lrYP0tY_QRPTfKf9-8rkwHnK-1Nk,13742
 calkit/server.py,sha256=GQm1bI5Q1NLFNwQL-iP6j4iWKUpKpP3cLEyfj5IMwe4,22009
 calkit/cli/__init__.py,sha256=pP_1wFuewdUUvEWTtaEcdKblPaSYuTvthQb2Ef08UMo,1921
@@ -39,14 +39,14 @@ calkit/cli/dev.py,sha256=cu4QsfDiA_KurGx4WJcgA2qgfghMoZutE8kl4IZbUcM,1070
 calkit/cli/import_.py,sha256=5j2ANLq6v7HOku9kJUWylwvQnJfkb_OUKCNOdv1BQXU,18264
 calkit/cli/latex.py,sha256=dhcbVNcR3YjVSD5mo-OBtZN1FhH4mv4mlGnuP19EbjU,6220
 calkit/cli/list.py,sha256=iWP3gfXnl13ZciXVpbZQlcu4hAQkBnfvp_D--4T08-0,6084
-calkit/cli/new.py,sha256=8S_3nT-oiXK1_QT8oPmU3xxaPwnnK_oMzeU30s71CGY,124018
+calkit/cli/new.py,sha256=i3_kaWAW78vhSEdbdoGyMj0sqkaZcvFPQPBiQqKJMbQ,125465
 calkit/cli/notebooks.py,sha256=dEjJ1qeh6SG99chhgUaxe_Cpv9hGERR98fBE6dscZmo,21381
 calkit/cli/office.py,sha256=jVSTvbl91TCzlglST5O2b8hdApZA_QHw_UiEQFJqxdc,1754
 calkit/cli/overleaf.py,sha256=bS-SkYsSqqhC9YsP-NCzpYJCGS3820w18w_s8JOFihg,25216
 calkit/cli/scheduler.py,sha256=cxWpXJ71O8Wx4afEKkxoUPTK0RTJLLmvls2UlYVTS9E,28971
 calkit/cli/update.py,sha256=GX8vcO46JDCDRrDK4YmZJ2ODLgGz6_s5pTjao7S_trI,25543
 calkit/cli/main/__init__.py,sha256=qu1POZPyqs33ZKfasOxv_Wc-EzVcEgK3Dt_vwFL8Bi8,65
-calkit/cli/main/core.py,sha256=6KWgCgAgV8MTm8EEd5NujVCCrQc9A33vpjtaXt8TwVI,120681
+calkit/cli/main/core.py,sha256=_QgV8c-9LDd3xZyFQQhZ6JRITVKadQ2U4tzAZnuenGc,121134
 calkit/cli/main/xr.py,sha256=Bug5qJuiIq0tusmdu30t-ZdyaT_Sy5RwPSTiHvCtIqE,25600
 calkit/dvc/__init__.py,sha256=-B6tilCb_jw7QFmJ2srILez24wDhNKUzIBhZUMt01dE,381
 calkit/dvc/core.py,sha256=54s-LwttJ6GWWwkwhAkBcwJBXpVajEoYPcJGxLD5zlc,23780
@@ -73,7 +73,7 @@ calkit/tests/test_calc.py,sha256=h-wOUIRqfyi06LTzhY_rS-a1xChZTkmwdEfBybMUM7E,203
 calkit/tests/test_check.py,sha256=ngRZq1_dSRQoa0oSjcx_QpR94omG9Bpas_h0wqjwrK0,1475
 calkit/tests/test_cloud.py,sha256=583oy2zH0fLexBBB_cmrxCgu7qsouBe7tKY-kkbzhXE,10227
 calkit/tests/test_conda.py,sha256=t-Oy1mL3Vb5njj_t3LQ8HwMhsmLN64HAzSlebnN1A9s,14204
-calkit/tests/test_core.py,sha256=MDSQCsUI4RkZ6VZGWhDELdebZujLuLn8o6BLBSaBb5w,4607
+calkit/tests/test_core.py,sha256=qZ090GbIu-gqu-0qJqwPj47t7k1Q_N_5mv0sT2VAeZc,5496
 calkit/tests/test_dependencies.py,sha256=HskXLzbvvRJz2TXnKPpPAo9lPhoZGYQFy4BmEF31nvk,11139
 calkit/tests/test_detect.py,sha256=1QLei1SjLdxy3IWwFZi3PIz8WHpKmG50Hjygc_HxYxg,32907
 calkit/tests/test_docker.py,sha256=27d0K1GOWiCNv_5TkZSob6EaC0EtQ9DSBIDfkEAEzGk,2077
@@ -81,14 +81,14 @@ calkit/tests/test_environments.py,sha256=KlIQ7tZhhPSFlJ3cM4nLCpCxShB18MCHUBW0y2K
 calkit/tests/test_fs.py,sha256=8XFlC6bsw_aGodhmDq87OnI60L2licz459yUlDcAieY,9448
 calkit/tests/test_git.py,sha256=bxPVTn-0DD9mhlarBjEnm6V8XSJHfvm2etl9Z5Pq-qg,15076
 calkit/tests/test_install.py,sha256=Yh7-OFQ2L4S0uRkYPfQpqe4V2y1A9DwZddMEi8pQbMU,9228
-calkit/tests/test_invenio.py,sha256=RpiwgcYu0yIpl2gOMTkAQNsSStYPZGa2ReFnA4KCt94,296
+calkit/tests/test_invenio.py,sha256=aDI8cFOUUQEkfgHSK_Nv1cMNMsnmNr2W2weuZhrxshI,998
 calkit/tests/test_julia.py,sha256=fw8pTkXJEUYow3B8q-_oWw859MH4UDy9AuDk6nNaDQA,3188
 calkit/tests/test_jupyter.py,sha256=YTL6zI740UM2KUjskSipzvSKxsyQ8rVPFQIX5cb2tMQ,114
 calkit/tests/test_licenses.py,sha256=AxoydeUG1Z6rDVeJJ64YXZ8xCJeyQyJdq6GSkDjlwJE,4001
 calkit/tests/test_magics.py,sha256=1O_hYPLMBVQJj8rLCFV3sU2DejlLLnk6Tv4_Tr-FZHQ,2101
 calkit/tests/test_matlab.py,sha256=7yFKOYDCtxYIkRyFOwTIxlvzx03Pac0FKGIUT4Zx7zA,7589
 calkit/tests/test_notebooks.py,sha256=6xUpHjCbCv08oJkArj-NkTUMlz9zzm8pf1qam3s27M0,2692
-calkit/tests/test_pipeline.py,sha256=TYBzuywlHFjpwI7CZOoXKZZCroDWilSmjd4ZmTSE6OY,78119
+calkit/tests/test_pipeline.py,sha256=crqI5YJcSb0_-imFubxv-ZWnRJ1j8NYgsuNjI-z9iUg,83661
 calkit/tests/test_releases.py,sha256=_sh7s3hjfAAw5vJ7Zdjp5CRfE8uv4j63jZu_I-N_CPc,10338
 calkit/tests/test_templates.py,sha256=RN4RIgmuFlmFYQFgfJUYS-KaLmie8fnWzmfg5Ay1egk,430
 calkit/tests/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -98,14 +98,14 @@ calkit/tests/cli/test_config.py,sha256=Tl4LWfi81eQo6fUgJsoZRNPj_LfkKH-s42HRg5Mxh
 calkit/tests/cli/test_import.py,sha256=e2BToVPebf4NalFQuIgyTNJHwbc9VMc6AYO-FAhYbQ0,663
 calkit/tests/cli/test_latex.py,sha256=SqDbenoFtnsgkfqFjR2Jhw6TJsYQBtLqIGjM3PJmddc,3604
 calkit/tests/cli/test_list.py,sha256=vwPGDANLzFR9neWmeT4idS8vaYS2w7UoZZ0Q3ItF9kw,1801
-calkit/tests/cli/test_new.py,sha256=mH1l6o75Z0541SJNF_WtW58fioJN_V7yKIOCT3d7IfA,32148
+calkit/tests/cli/test_new.py,sha256=aFIoqLSPF43rOU9zend6NDhjP3CylerF0y23fwq2dwk,44448
 calkit/tests/cli/test_notebooks.py,sha256=pJX6KV45tNBd-ZpqyoayDzNop9-maRIN_fC2j3EcPf0,7899
 calkit/tests/cli/test_overleaf.py,sha256=Y-ud4kZHh3nhyoZlXrtMfx61z-GPNytUpfDHMad3tuA,16474
 calkit/tests/cli/test_scheduler.py,sha256=orCXPBbn9Mx4moemWNSfsil5cGCOcNgRgw6Yy5zDwjk,6061
 calkit/tests/cli/test_update.py,sha256=68Dzrm4eO4lZZ0zcpdQCo-1mgwrxE6n9lQao0UJx9ag,3212
 calkit/tests/cli/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/cli/main/test_core.py,sha256=Zv0Vyt6WZbJP9Z2PdP4ZTwtQ6WckoeTGfNSO9lE8dZA,59106
-calkit/tests/cli/main/test_subprojects.py,sha256=l08ZS4Dah4TqtnupFBBJbgSBJu-xBgOj5EJIH05OHWs,11146
+calkit/tests/cli/main/test_subprojects.py,sha256=ZR2ZQvZ4XZOi-iW8nlZEYu_2CUyUWoc0MABmnFrF9DQ,12730
 calkit/tests/cli/main/test_xr.py,sha256=shk8LHS33bZpr_iAW5eA5sMD3nQDKm8fIwXlE6dA2uI,22527
 calkit/tests/dvc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/dvc/test_core.py,sha256=YkN0VsB8wB68K5N_L3V-Wq9EyGxOaZil4_FISf6iuB0,10623
@@ -118,23 +118,23 @@ calkit/tests/models/test_pipeline.py,sha256=AJsMAX4928U3_Omt0_8K96U5LU_KoNErgpHe
 calkit/agent_skills/add-pipeline-stage/SKILL.md,sha256=kpYYb-rJsS4B9p1Ub3gL21irCG5ZZ4DvWZpdJeEwPZk,3772
 calkit/agent_skills/conventions/SKILL.md,sha256=nAM2FjSMk6ED56Dr5zh2bL_dhfzDra-h2ZgzHU7ruS4,9524
 calkit/agent_skills/create-pipeline/SKILL.md,sha256=2FGw1iDQVRk5FUq79GP3lPdgvgof2Wi1O9O-abGGtgs,5422
-calkit_python-0.41.7.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/package.json,sha256=INxx8QhvSl7KP6yL7A7-m2-FIsnB__mYEWG_Eq5RP-c,6651
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=6w0b5y8LztEv2tErajJ5d39yBryld02crX0CG3zZFNs,6509
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.65469af996e7a96aa983.js,sha256=ZUaa-ZbnqWqpgxIpcQcRX7auvhOBkPH2YHNID5udGQs,8737
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
-calkit_python-0.41.7.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
-calkit_python-0.41.7.dist-info/METADATA,sha256=l95iwXq8XVINTdV00PGTPu9NmrpwxY-wV5mq6QjuH5c,12070
-calkit_python-0.41.7.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-calkit_python-0.41.7.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
-calkit_python-0.41.7.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
-calkit_python-0.41.7.dist-info/RECORD,,
+calkit_python-0.41.8.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/package.json,sha256=INxx8QhvSl7KP6yL7A7-m2-FIsnB__mYEWG_Eq5RP-c,6651
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=6w0b5y8LztEv2tErajJ5d39yBryld02crX0CG3zZFNs,6509
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.65469af996e7a96aa983.js,sha256=ZUaa-ZbnqWqpgxIpcQcRX7auvhOBkPH2YHNID5udGQs,8737
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
+calkit_python-0.41.8.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
+calkit_python-0.41.8.dist-info/METADATA,sha256=rQxTqA_zGG2rCn-JWp5zyi1w5RrBRIk0FVfH3zfaWUU,12070
+calkit_python-0.41.8.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+calkit_python-0.41.8.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
+calkit_python-0.41.8.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
+calkit_python-0.41.8.dist-info/RECORD,,