calkit-python 0.41.16__py3-none-any.whl → 0.41.18__py3-none-any.whl

calkit/cli/notebooks.py

@@ -490,7 +490,17 @@ def execute_notebook(
         typer.echo(f"Using {language} as notebook language")
     # First, ensure the specified environment has a kernel we can use
     # We need to check the environment type and create the kernel if needed
-    if language.lower() in ["python", "julia", "r"]:
+    docker_env = env.get("kind") == "docker"
+    if docker_env:
+        # Docker environments run the kernel inside the container, so there is
+        # no host kernel to register. Use the container's own kernel (default
+        # 'python3', overridable with the env's 'jupyter_kernel' key) and
+        # execute with Papermill inside the container further below.
+        kernel_name = env.get("jupyter_kernel") or {"r": "ir"}.get(
+            language.lower(), "python3"
+        )
+        display_name = kernel_name
+    elif language.lower() in ["python", "julia", "r"]:
         kernel_name, display_name = check_env_kernel(
             env_name=env_name,
             no_check=no_check,
@@ -563,10 +573,70 @@ def execute_notebook(
         typer.echo(f"Using kernel: {kernel_name}")
         typer.echo(f"Running with cwd: {notebook_dir}")
         typer.echo(f"Output will be saved to: {fpath_out_exec}")
-    # If this is a Python, Julia, or R notebook, we can use Papermill
+    # If this is a Python, Julia, or R notebook, we can use Papermill.
     # If it's a MATLAB notebook, we need to use the MATLAB kernel inside the
-    # specified environment
-    if language.lower() in ["python", "julia", "r"]:
+    # specified environment.
+    # Exception: If the environment is a Docker environment, we run Papermill
+    # inside the container so the kernel (which lives in the image) and
+    # Papermill share a process namespace---this avoids registering a host
+    # kernel and cross-container networking entirely
+    if docker_env:
+        # run_in_env mounts the project at the working directory and applies
+        # the env's user/platform/args, so we only need to invoke Papermill
+        # ipykernel is in the image, but Papermill may not be, so install it
+        # on demand (warning the user) before executing. We install into a
+        # writable temp dir on PYTHONPATH rather than the image's site-packages:
+        # run_in_env maps the host user into the container, so writing to the
+        # system location is typically denied, but /tmp is world-writable
+        pm_target = "/tmp/calkit-papermill"
+        pythonpath = f"PYTHONPATH={pm_target}"
+        pm_cmd = [
+            pythonpath,
+            "python",
+            "-c",
+            "import papermill",
+            "2>/dev/null",
+            "||",
+            "(",
+            "echo",
+            "papermill not found in image; installing it with pip...",
+            "&&",
+            "python",
+            "-m",
+            "pip",
+            "install",
+            "-q",
+            "--target",
+            pm_target,
+            "papermill",
+            ")",
+            "&&",
+            pythonpath,
+            "python",
+            "-m",
+            "papermill",
+            path,
+            fpath_out_exec,
+            "-k",
+            kernel_name,
+            "--log-output",
+        ]
+        if notebook_dir:
+            pm_cmd += ["--cwd", notebook_dir]
+        if parsed_params:
+            # JSON is valid YAML, so pass parameters as base64-encoded JSON to
+            # avoid shell-quoting issues across the container boundary
+            params_b64 = base64.b64encode(
+                json.dumps(parsed_params).encode()
+            ).decode()
+            pm_cmd += ["-b", params_b64]
+        run_in_env(
+            pm_cmd,
+            env_name=env_name,
+            no_check=no_check,
+            verbose=verbose,
+        )
+    elif language.lower() in ["python", "julia", "r"]:
         papermill.execute_notebook(
             input_path=path,
             output_path=fpath_out_exec,

calkit/cli/scheduler.py

@@ -304,6 +304,25 @@ def _slurm_exit_code(job_id: str) -> int | None:
     return None
 
 
+def _parse_pbs_state(stdout: str) -> tuple[str | None, int | None]:
+    # `qstat -f` output is a flat list of `key = value` lines; pull out the
+    # job's state and, for a finished job, its exit status. The status field is
+    # spelled `Exit_status` on PBS Pro and `exit_status` on some Torque builds,
+    # so match it case-insensitively.
+    state = None
+    exit_code = None
+    for line in stdout.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("job_state"):
+            state = stripped.split("=", 1)[-1].strip()
+        elif stripped.lower().startswith("exit_status"):
+            try:
+                exit_code = int(stripped.split("=", 1)[-1].strip())
+            except ValueError:
+                exit_code = None
+    return state, exit_code
+
+
 def _poll_job(kind: str, job_id: str) -> tuple[bool, int | None]:
     """Return ``(active, exit_code)`` for a scheduler job.
 
@@ -339,39 +358,51 @@ def _poll_job(kind: str, job_id: str) -> tuple[bool, int | None]:
         if "invalid job id" in stderr:
             return False, _slurm_exit_code(job_id)
         return True, None
-    # Use `qstat -f` and parse job_state: on Torque/OpenPBS, plain `qstat
-    # <id>` returns exit 0 even for completed (C) jobs, so checking the
-    # return code alone would cause `calkit sched batch` to hang forever
-    # after a PBS job finishes.  States C and F mean the job is done, and a
-    # finished job's record carries its `Exit_status`.
+    # PBS reports a finished job differently across variants, so poll in two
+    # steps that mirror the SLURM path above. First consult the active-queue
+    # view with `qstat -f`: every live state (R, Q, H, E) shows here, and on
+    # Torque a completed job lingers here in state `C` carrying its
+    # `Exit_status`. `qstat -f` is used rather than plain `qstat <id>` because
+    # the latter exits 0 even for completed jobs, so the return code alone
+    # could not tell running from done.
     p = subprocess.run(
         ["qstat", "-f", job_id], capture_output=True, text=True, check=False
     )
-    if p.returncode != 0:
-        # A non-zero exit is ambiguous: either the job is gone (completed and
-        # purged from history) or `qstat` itself failed transiently---a busy
-        # PBS server periodically refuses connections or times out. Treating a
-        # transient failure as completion would stop the wait while the job is
-        # still running and writing its log, so only conclude the job is done
-        # when qstat positively reports it is unknown; otherwise keep waiting.
-        # A purged job (unknown to qstat) is done but with an unknowable exit
-        # status; any other error is transient, so report the job as active.
-        stderr = (p.stderr or "").lower()
-        return ("unknown job" not in stderr), None
-    state = None
-    exit_code = None
-    for line in p.stdout.splitlines():
-        stripped = line.strip()
-        if stripped.startswith("job_state"):
-            state = stripped.split("=", 1)[-1].strip()
-        elif stripped.lower().startswith("exit_status"):
-            try:
-                exit_code = int(stripped.split("=", 1)[-1].strip())
-            except ValueError:
-                exit_code = None
-    if state in ("C", "F"):
-        return False, exit_code
-    return True, None
+    if p.returncode == 0:
+        state, exit_code = _parse_pbs_state(p.stdout)
+        if state in ("C", "F"):
+            return False, exit_code
+        if state is not None:
+            return True, None
+    # The job is no longer in the active queue---on PBS Pro a finished job is
+    # hidden from plain `qstat` and shows (as state `F` with its `Exit_status`)
+    # only under `qstat -x`---or qstat failed. Ask the history view for the
+    # finished record. Without this, a PBS Pro job that has finished is never
+    # seen as done and the wait hangs forever. `-x` means "include finished
+    # jobs" on PBS Pro; on Torque it switches qstat to XML output, which simply
+    # won't parse here, leaving the stderr check below to settle it (Torque
+    # already reported completion above via state `C`).
+    hist = subprocess.run(
+        ["qstat", "-x", "-f", job_id],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if hist.returncode == 0:
+        state, exit_code = _parse_pbs_state(hist.stdout)
+        if state in ("C", "F"):
+            return False, exit_code
+        if state is not None:
+            return True, None
+    # Neither view resolved a state. A non-zero exit is ambiguous: either the
+    # job is gone (finished and purged from history) or qstat failed
+    # transiently---a busy PBS server periodically refuses connections or times
+    # out. Treating a transient failure as completion would stop the wait while
+    # the job is still running and writing its log, so only conclude the job is
+    # done when qstat positively reports it is unknown; otherwise keep waiting.
+    # A purged job is done but with an unknowable exit status.
+    stderr = (p.stderr or "").lower()
+    return ("unknown job" not in stderr), None
 
 
 def _is_active(kind: str, job_id: str) -> bool:

calkit/models/core.py

@@ -96,8 +96,6 @@ class Environment(BaseModel):
     # without a spec file (e.g. Matlab/Slurm/PBS) don't carry an unused field
     # and a required ``path`` doesn't conflict with the base's optional one.
     description: str | None = None
-    stage: str | None = None
-    default: bool | None = None
 
 
 class CondaEnvironment(Environment):
@@ -112,6 +110,8 @@ class VenvEnvironment(Environment):
     # If unset, the prefix is resolved on the fly (defaults to .venv next to
     # the spec file, nesting under .calkit/envs/{name}/.venv on conflict)
     prefix: str | None = None
+    # Python version to use when creating the environment
+    python: str | None = None
 
 
 class UvEnvironment(Environment):
@@ -125,6 +125,8 @@ class UvVenvEnvironment(Environment):
     # If unset, the prefix is resolved on the fly (defaults to .venv next to
     # the spec file, nesting under .calkit/envs/{name}/.venv on conflict)
     prefix: str | None = None
+    # Python version to use when creating the environment
+    python: str | None = None
 
 
 class PixiEnvironment(Environment):
@@ -153,6 +155,24 @@ class DockerEnvironment(Environment):
     shell: Literal["bash", "sh"] = "sh"
     command_mode: Literal["shell", "entrypoint"] = "shell"
     platform: str | None = None
+    # Working directory inside the container; defaults to ``/work`` at run time
+    wdir: str | None = None
+    # User to run the container as; defaults to the host user at run time
+    user: str | None = None
+    # Files added to the container as dependencies
+    deps: list[str] | None = None
+    # Environment variables to set in the container
+    env_vars: dict[str, str] | None = None
+    # Ports to expose, e.g. ``"8080:80"``
+    ports: list[str] | None = None
+    # GPUs to make available, passed to ``docker run --gpus``
+    gpus: str | None = None
+    # Extra arguments passed to ``docker run``
+    args: list[str] | None = None
+    # Name of the Jupyter kernel inside the image, used when executing
+    # notebooks with ``calkit nb execute``; defaults to ``python3`` (or ``ir``
+    # for R images)
+    jupyter_kernel: str | None = None
 
 
 class REnvironment(Environment):
@@ -195,6 +215,7 @@ class SSHEnvironment(BaseModel):
     key: str | None = None
     send_paths: list[str] = ["./*"]
     get_paths: list[str] = ["*"]
+    description: str | None = None
 
 
 class Software(BaseModel):

calkit/tests/cli/test_notebooks.py

@@ -10,6 +10,7 @@ import sys
 import pytest
 
 import calkit
+import calkit.notebooks
 
 
 def test_clean_notebook_outputs(tmp_dir):
@@ -264,3 +265,87 @@ def test_execute_notebook_auto_env(tmp_dir):
     # TODO: Check if the notebook is saved in the project and if it
     # has an environment specified, either in the notebooks section or a
     # pipeline stage
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="Docker Linux images are unavailable on windows-latest GHA runners",
+)
+def test_execute_notebook_docker(tmp_dir):
+    # A Docker environment runs the kernel inside the container, so we execute
+    # with Papermill inside the container rather than registering a host kernel
+    if shutil.which("docker") is None:
+        pytest.skip("Docker is not available")
+    image = "calkit-nb-docker-test:latest"
+    # Bake ipykernel and Papermill into the image so execution is deterministic
+    with open("Dockerfile", "w") as f:
+        f.write(
+            "FROM python:3.10-slim\n"
+            "RUN pip install --no-cache-dir ipykernel papermill\n"
+            "WORKDIR /work\n"
+        )
+    subprocess.check_call(["docker", "build", "-t", image, "."])
+    subprocess.check_call(["calkit", "init"])
+    ck_info = {
+        "environments": {
+            "docker-env": {"kind": "docker", "image": image, "wdir": "/work"}
+        }
+    }
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
+    # A notebook with a 'parameters' cell so we can verify injection
+    nb = {
+        "cells": [
+            {
+                "cell_type": "code",
+                "execution_count": None,
+                "id": "params",
+                "metadata": {"tags": ["parameters"]},
+                "outputs": [],
+                "source": ["a = 1\n"],
+            },
+            {
+                "cell_type": "code",
+                "execution_count": None,
+                "id": "compute",
+                "metadata": {},
+                "outputs": [],
+                "source": ["result = a * 10\n", "print('result =', result)\n"],
+            },
+        ],
+        "metadata": {},
+        "nbformat": 4,
+        "nbformat_minor": 5,
+    }
+    os.makedirs("notebooks")
+    with open(os.path.join("notebooks", "main.ipynb"), "w") as f:
+        json.dump(nb, f)
+    subprocess.check_call(
+        [
+            "calkit",
+            "nb",
+            "exec",
+            "-e",
+            "docker-env",
+            "--no-check",
+            "-p",
+            "a=4",
+            "notebooks/main.ipynb",
+        ]
+    )
+    # The injected parameter should have produced result = 40 in the executed
+    # notebook saved under .calkit/notebooks/executed
+    exec_path = calkit.notebooks.get_executed_notebook_path(
+        notebook_path="notebooks/main.ipynb",
+        to="notebook",
+        parameters={"a": 4},
+    )
+    with open(exec_path) as f:
+        executed = json.load(f)
+    text = "".join(
+        "".join(o.get("text", []))
+        for cell in executed["cells"]
+        for o in cell.get("outputs", [])
+        if o.get("name") == "stdout"
+    )
+    assert "result = 40" in text

calkit/tests/cli/test_scheduler.py

@@ -215,44 +215,75 @@ def test_poll_job_pbs(monkeypatch):
 
     import calkit.cli.scheduler as sched
 
-    outcomes: dict = {}
+    # PBS is polled in two steps: plain `qstat -f` for the active queue, then
+    # `qstat -x -f` for the finished-job history view. The fake dispatches on
+    # whether `-x` is present so each step can be simulated independently, the
+    # way a real PBS Pro server answers them.
+    active: dict = {}
+    history: dict = {}
 
-    def _fake_run(*args, **kwargs):
+    def _fake_run(cmd, *args, **kwargs):
+        outcomes = history if "-x" in cmd else active
         return subprocess.CompletedProcess(
-            args=args[0],
+            cmd,
             returncode=outcomes["returncode"],
             stdout=outcomes.get("stdout", ""),
             stderr=outcomes.get("stderr", ""),
         )
 
     monkeypatch.setattr(sched.subprocess, "run", _fake_run)
-    # A running job (state R) is active with no exit code yet.
-    outcomes.update(returncode=0, stdout="    job_state = R\n", stderr="")
+    # A running job (state R) is active with no exit code yet, and resolves
+    # from the active queue alone---the history view is never consulted.
+    active.update(returncode=0, stdout="    job_state = R\n", stderr="")
+    history.clear()
     assert _poll_job("pbs", "1.pbs") == (True, None)
-    # Terminal states C (Torque) and F (PBS Pro) mean the job is done; qstat
-    # still exits 0 while the record lingers in history and carries the exit
-    # status, which is reported back so the caller can fail a bad job.
-    outcomes.update(
+    # The reported bug: on PBS Pro a finished job leaves the active queue and
+    # is shown only under `qstat -x`, where it appears as state F with its
+    # Exit_status. Plain `qstat -f` errors with a message that is NOT "unknown
+    # job", which used to be read as "still active" and hang the wait forever.
+    active.update(
+        returncode=1,
+        stdout="",
+        stderr="qstat: 1.pbs Job has finished, use -x to obtain historical "
+        "job information\n",
+    )
+    history.update(
         returncode=0, stdout="    job_state = F\n    Exit_status = 0\n"
     )
     assert _poll_job("pbs", "1.pbs") == (False, 0)
-    outcomes.update(
+    # A non-zero exit code from the finished job is reported back so the caller
+    # can fail the stage.
+    history.update(
+        returncode=0, stdout="    job_state = F\n    Exit_status = 137\n"
+    )
+    assert _poll_job("pbs", "1.pbs") == (False, 137)
+    # On Torque a completed job lingers in the active queue as state C with its
+    # exit status, so it is done without ever needing the history view.
+    active.update(
         returncode=0, stdout="    job_state = C\n    exit_status = 137\n"
     )
+    history.update(returncode=1, stdout="", stderr="should not be reached\n")
     assert _poll_job("pbs", "1.pbs") == (False, 137)
     # A finished job whose record lacks an exit status yields an unknown code.
-    outcomes.update(returncode=0, stdout="    job_state = F\n")
+    active.update(returncode=1, stdout="", stderr="qstat: Unknown Job Id\n")
+    history.update(returncode=0, stdout="    job_state = F\n")
     assert _poll_job("pbs", "1.pbs") == (False, None)
-    # Once purged, qstat exits non-zero and reports the job unknown: done, but
-    # with no way to recover the exit status.
-    outcomes.update(
+    # Once purged from history too, both views error with "unknown job": done,
+    # but with no way to recover the exit status.
+    active.update(
+        returncode=1, stdout="", stderr="qstat: Unknown Job Id 1.pbs\n"
+    )
+    history.update(
         returncode=1, stdout="", stderr="qstat: Unknown Job Id 1.pbs\n"
     )
     assert _poll_job("pbs", "1.pbs") == (False, None)
-    # A transient qstat failure (busy/unreachable server) is NOT completion:
-    # treating it as done would stop the wait while the job still runs, so the
-    # job is reported active and the caller keeps polling.
-    outcomes.update(
+    # A transient qstat failure (busy/unreachable server) on both views is NOT
+    # completion: treating it as done would stop the wait while the job still
+    # runs, so the job is reported active and the caller keeps polling.
+    active.update(
+        returncode=1, stdout="", stderr="qstat: cannot connect to server\n"
+    )
+    history.update(
         returncode=1, stdout="", stderr="qstat: cannot connect to server\n"
     )
     assert _poll_job("pbs", "1.pbs") == (True, None)

{calkit_python-0.41.16.dist-info → calkit_python-0.41.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.41.16
+Version: 0.41.18
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -78,35 +78,30 @@ Description-Content-Type: text/markdown
 
 <!-- INCLUDE: docs/index.md -->
 
-Calkit helps you manage and automate research projects like a software
-engineer.
-
-Define computational environments,
-steps that process your data, create figures,
-presentations, and publications, connect to external tools,
-then iterate quickly and painlessly until your research questions are
-answered, tracking changes to all files along the way.
-At the end, deliver your entire project as a self-contained, self-documenting,
-version-controlled, and
-[single button reproducible](https://doi.org/10.1190/1.1822162)
-"calculation kit" so you and others can easily verify
-and build upon the results.
-
-## Guiding principles
-
-- Quality comes from iteration. Automation reduces the time and effort
-  needed to iterate, thereby increasing iteration and quality.
-- Automating a step can and should take roughly
-  the same amount of time as doing it once manually,
-  therefore it's almost always worth it.
-- Working in a "quick and dirty" way can easily become _not quick_ when
-  the dirtiness results in mistakes and/or discourages working in small steps.
+It's six months since you submitted your paper,
+do you know exactly how your figures and results were generated?
+
+You will if they're part of a Calkit project.
+
+Calkit helps you integrate code, data, figures, results, publications,
+and more into a cohesive, traceable, and portable _knowledge creation system_,
+so every output can be traced back to its source and reproduced with a
+single command.
+
+With industry standard tools combined into a unified and simplified experience
+tailored for research,
+you can reap the rewards of reproducibility and automation
+without the cognitive overhead.
+
+<!-- https://docs.google.com/drawings/d/1XMGnbgYYNFAVUBDyUaCyLfRB7efvJdrnrKmFlNmT19o/edit -->
+
+![pipeline](docs/img/pipeline.png)
 
 ## Features
 
 - A simplified [version control](https://docs.calkit.org/version-control)
   interface that unifies Git and DVC (Data Version Control),
-  so all materials can be kept in the same project repository.
+  so everything can be kept in the same project repository.
   This way, code doesn't need to be siloed away from other
   important artifacts like datasets, models, figures, or article PDFs,
   allowing you to work on all parts of a project without hopping around to
@@ -129,9 +124,10 @@ and build upon the results.
 - [Overleaf integration](https://docs.calkit.org/overleaf/), so
   analysis, visualization, and writing can all stay in sync
   (no more manual uploads!)
-- Support for running on high performance computing (HPC) systems that use
-  [SLURM schedulers](https://docs.calkit.org/pipeline/slurm).
-- Support for running with [GitHub Actions](https://docs.calkit.org/tutorials/github-actions).
+- Support for running on [high performance computing (HPC)](https://docs.calkit.org/hpc) systems
+  that use PBS or SLURM schedulers.
+- Support for automated running with
+  [GitHub Actions](https://docs.calkit.org/tutorials/github-actions).
 - Extensions for doing all of the above graphically in
   [JupyterLab](https://docs.calkit.org/jupyterlab) and
   [VS Code](https://marketplace.visualstudio.com/items?itemName=Calkit.calkit-vscode).
@@ -373,9 +369,37 @@ To back up or save the project, call:
 calkit save -am "Run pipeline"
 ```
 
+### With an AI coding agent
+
+Simply tell the [AI agent](https://docs.calkit.org/ai-tools):
+
+> Turn this folder into a Calkit project
+
+or
+
+> Create me a new Calkit project for investigating...
+
 <!-- END INCLUDE -->
 
 ## Get involved
 
 We welcome all kinds of contributions!
 See [CONTRIBUTING.md](CONTRIBUTING.md) to learn how to get involved.
+
+## Acknowledgements
+
+<!-- INCLUDE: docs/acknowledgements.md +1 -->
+
+Calkit is supported by the
+[Caltech Schmidt Academy of Software Engineering](https://sase.caltech.edu).
+
+<p align="center">
+  <a href="https://sase.caltech.edu" target="_blank">
+    <img width="40%" src="docs/img/caltech.png" alt="Caltech SASE">
+  </a>
+<a href="https://schmidtsciences.org/" target="_blank">
+    <img width="40%" src="docs/img/schmidt-sciences.png" alt="Schmidt Sciences">
+  </a>
+</p>
+
+<!-- END INCLUDE -->

{calkit_python-0.41.16.dist-info → calkit_python-0.41.18.dist-info}/RECORD

@@ -41,10 +41,10 @@ calkit/cli/import_.py,sha256=5j2ANLq6v7HOku9kJUWylwvQnJfkb_OUKCNOdv1BQXU,18264
 calkit/cli/latex.py,sha256=dhcbVNcR3YjVSD5mo-OBtZN1FhH4mv4mlGnuP19EbjU,6220
 calkit/cli/list.py,sha256=rV3gCVvoZ4CkUYXYfNRow11-AV99b98w7sabcDq08uk,10521
 calkit/cli/new.py,sha256=OtXcXmhtywXM54dgyjxQgtYEfCYBAi_UVKvMlPjSI8k,129111
-calkit/cli/notebooks.py,sha256=QV3_0wwgIm9cdTBM7CwlUth1xbTnPGp2LJUFVSAoBm4,21941
+calkit/cli/notebooks.py,sha256=mMNHE8yT0BDN0iJE07GCBFAseyDF0jSRshIm1CQjgrY,24645
 calkit/cli/office.py,sha256=jVSTvbl91TCzlglST5O2b8hdApZA_QHw_UiEQFJqxdc,1754
 calkit/cli/overleaf.py,sha256=bS-SkYsSqqhC9YsP-NCzpYJCGS3820w18w_s8JOFihg,25216
-calkit/cli/scheduler.py,sha256=Mn_G2tx78A_wJ3XYE0hRtTkPj376sKTWpSxMZKirHuA,38660
+calkit/cli/scheduler.py,sha256=Nt1wQMJzuY3ZNkq1KVEV0dZk4T8Gr0XPLQ6mJpXPrZE,40125
 calkit/cli/update.py,sha256=KaO-VbUxMpR_a9FV42HG8d9p-iaA4-2-L-fAgb2LiYI,43499
 calkit/cli/main/__init__.py,sha256=qu1POZPyqs33ZKfasOxv_Wc-EzVcEgK3Dt_vwFL8Bi8,65
 calkit/cli/main/core.py,sha256=MMKEAI4bAJm1YJcS4E5MTQAR-XluwtGn3wlsNYjK-NE,123878
@@ -55,7 +55,7 @@ calkit/dvc/zip.py,sha256=nsAkcTLinH5S2UyZMdoYrBESKPb7s-PARmnuY9dyWVQ,21256
 calkit/jupyterlab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/jupyterlab/routes.py,sha256=jnNd289CpNQFY6am5p3qaiL_Tcnkd6J_vDVdjIXlb1A,51465
 calkit/models/__init__.py,sha256=vGYF4MZBGzDk1BPBzpp1bRb59RCJ2Bj2kzHuVVRacug,120
-calkit/models/core.py,sha256=QYbnHHOjd1Y-ublDE-hBL7WzqNIAAGW9e5H1BLIJvyg,11833
+calkit/models/core.py,sha256=m6r0R-6loWet_O0nU5Su3wIm3BTONaaTUE4qVWbU3fQ,12829
 calkit/models/io.py,sha256=FgItZDxrSyph91YRMOEfJo9xWmy3drMin_632vy9WhA,1087
 calkit/models/iteration.py,sha256=lodRMjj818ysec303PkuepOUr3dMPOa0cwKmTUaw9Ok,2947
 calkit/models/pipeline.py,sha256=Ov0vDogxe4PjWath80cmUR9uVx3XfoAT66PAuNYxUMo,46069
@@ -101,9 +101,9 @@ calkit/tests/cli/test_import.py,sha256=e2BToVPebf4NalFQuIgyTNJHwbc9VMc6AYO-FAhYb
 calkit/tests/cli/test_latex.py,sha256=SqDbenoFtnsgkfqFjR2Jhw6TJsYQBtLqIGjM3PJmddc,3604
 calkit/tests/cli/test_list.py,sha256=ejMg6q8vtjCbKxvS9zZ32rv_oeKH94JbvpEiVjnw5QA,3859
 calkit/tests/cli/test_new.py,sha256=_-lQH53OkKC-nyLPrdnwndTDyzXv8-aGnXOaDQ_bu-s,46568
-calkit/tests/cli/test_notebooks.py,sha256=pJX6KV45tNBd-ZpqyoayDzNop9-maRIN_fC2j3EcPf0,7899
+calkit/tests/cli/test_notebooks.py,sha256=2t1KiGhEz9H9LcIdWy4jGM05REUxJpWiIg6fSpX12ME,10678
 calkit/tests/cli/test_overleaf.py,sha256=Y-ud4kZHh3nhyoZlXrtMfx61z-GPNytUpfDHMad3tuA,16474
-calkit/tests/cli/test_scheduler.py,sha256=MY2tmhcDLPypNS2yFONUeLjvQog37iw2XGHc9c2wtCY,15715
+calkit/tests/cli/test_scheduler.py,sha256=UBJCcZzx9lvPwymFi3SOt5bdwuNZ8wzDy2obMZ-Qn5E,17205
 calkit/tests/cli/test_update.py,sha256=bwRF0kpqbCVxNvGH777LHFX3oUP2DyN3XXUBDCEKNoc,6356
 calkit/tests/cli/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/cli/main/test_core.py,sha256=lowrbL1WCUPAEQjzMWFLPTbrARyFGEQKtVWGp2Lqrpg,63418
@@ -123,23 +123,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.16.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/package.json,sha256=39PQEWOzw0qtqD7Kep3OPbUR113vI7CG5TeD84v7clM,6224
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=NBG3t7gFYb6_2J-yPU29qS7Ck9pYgm8-wC5Q1LrzQeI,6082
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.ac9035764d5b2adbb542.js,sha256=rJA1dk1bKtu1QkURrp5HEC2WCxzZppPV1SCYz-35GTc,8737
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
-calkit_python-0.41.16.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
-calkit_python-0.41.16.dist-info/METADATA,sha256=tUnzT2-o6dU9IUfQO05ysFgxfISBJ4ws9pUnrNGZU9Q,12071
-calkit_python-0.41.16.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-calkit_python-0.41.16.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
-calkit_python-0.41.16.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
-calkit_python-0.41.16.dist-info/RECORD,,
+calkit_python-0.41.18.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/package.json,sha256=39PQEWOzw0qtqD7Kep3OPbUR113vI7CG5TeD84v7clM,6224
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=NBG3t7gFYb6_2J-yPU29qS7Ck9pYgm8-wC5Q1LrzQeI,6082
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.ac9035764d5b2adbb542.js,sha256=rJA1dk1bKtu1QkURrp5HEC2WCxzZppPV1SCYz-35GTc,8737
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
+calkit_python-0.41.18.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
+calkit_python-0.41.18.dist-info/METADATA,sha256=zexxBw6ZYpD61wV5bcv8i25G0lGpGxrhJ0HKM3CAh1s,12437
+calkit_python-0.41.18.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+calkit_python-0.41.18.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
+calkit_python-0.41.18.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
+calkit_python-0.41.18.dist-info/RECORD,,