calkit-python 0.41.19__py3-none-any.whl → 0.41.21__py3-none-any.whl

calkit/cli/list.py

@@ -174,6 +174,40 @@ def list_presentations(
     _list_artifacts("presentations", json_output, declared_only)
 
 
+def _echo_question(n: int, question: str | dict) -> None:
+    """Print a single question in the human-readable YAML-ish listing format.
+
+    String questions are shown as a numbered line. Rich (dict) questions are
+    shown with their text on the first line followed by hypothesis, answer,
+    evidence, and any other fields in YAML-like indented form.
+    """
+    if isinstance(question, str):
+        typer.echo(f"{n}. {question}")
+        return
+    # Copy so popping 'question' doesn't mutate the caller's dict.
+    question = dict(question)
+    text = question.pop("question", "")
+    typer.echo(f"{n}. question: {text}")
+    for k, v in question.items():
+        if isinstance(v, dict):
+            typer.echo(f"    {k}:")
+            for k1, v1 in v.items():
+                typer.echo(f"      {k1}: {v1}")
+        elif isinstance(v, list):
+            typer.echo(f"    {k}:")
+            for item in v:
+                if isinstance(item, dict):
+                    for n1, (k1, v1) in enumerate(item.items()):
+                        if n1 == 0:
+                            typer.echo(f"      - {k1}: {v1}")
+                        else:
+                            typer.echo(f"        {k1}: {v1}")
+                else:
+                    typer.echo(f"        - {item}")
+        else:
+            typer.echo(f"    {k}: {v}")
+
+
 @list_app.command(name="questions")
 def list_questions(
     json_output: Annotated[
@@ -186,7 +220,7 @@ def list_questions(
         typer.echo(json.dumps(questions))
         return
     for n, question in enumerate(questions, start=1):
-        typer.echo(f"{n}. {question}")
+        _echo_question(n, question)
 
 
 @list_app.command(name="publications|pubs")

calkit/cli/main/core.py

@@ -179,11 +179,26 @@ def init(
         typer.Option(
             "--force",
             "-f",
-            help="Force reinitializing DVC if already initialized.",
+            help="Re-initialize even if the project is already initialized.",
         ),
     ] = False,
 ):
     """Initialize the current working directory."""
+    import git
+    from git.exc import InvalidGitRepositoryError
+
+    def _project_is_initialized() -> bool:
+        try:
+            git.Repo(".", search_parent_directories=False)
+        except InvalidGitRepositoryError:
+            return False
+        return os.path.isfile(".dvc/config") and os.path.isfile("calkit.yaml")
+
+    if _project_is_initialized() and not force:
+        raise_error(
+            "This project is already initialized. "
+            "Use --force to re-initialize."
+        )
     subprocess.run(["git", "init"])
     result = calkit.dvc.run_dvc_command(
         ["init"] + (["--force"] if force else [])
@@ -197,13 +212,15 @@ def init(
     # Commit the newly created .dvc directory
     repo = calkit.git.get_repo()
     repo.git.add(".dvc")
-    repo.git.commit("-m", "Initialize DVC")
+    if calkit.git.get_staged_files(repo=repo):
+        repo.git.commit("-m", "Initialize DVC")
     # Create an empty calkit.yaml if one doesn't already exist
     if not os.path.isfile("calkit.yaml"):
         with open("calkit.yaml", "w"):
             pass
         repo.git.add("calkit.yaml")
-        repo.git.commit("-m", "Initialize Calkit")
+        if calkit.git.get_staged_files(repo=repo):
+            repo.git.commit("-m", "Initialize Calkit")
     # TODO: Initialize `dvc.yaml`
     # TODO: Add a sane .gitignore file
     # TODO: Add a sane LICENSE file?
@@ -769,6 +786,8 @@ def add(
         elif to == "git":
             subprocess.call(["git", "add"] + paths)
         elif to == "dvc":
+            for path in paths:
+                calkit.git.ensure_dvc_pointer_is_not_ignored(repo, path)
             calkit.dvc.run_dvc_command(["add"] + paths)
         elif to == "dvc-zip":
             for path in paths:
@@ -882,6 +901,7 @@ def add(
                         f"Adding {path} to DVC since it's already tracked "
                         "with DVC"
                     )
+                    calkit.git.ensure_dvc_pointer_is_not_ignored(repo, path)
                     calkit.dvc.run_dvc_command(["add", path])
             elif posix_path in pipeline_output_storage:
                 # Respect storage explicitly set in the pipeline definition
@@ -926,6 +946,7 @@ def add(
                     typer.echo(f"Would add {path} to DVC (per extension)")
                 else:
                     typer.echo(f"Adding {path} to DVC per its extension")
+                    calkit.git.ensure_dvc_pointer_is_not_ignored(repo, path)
                     calkit.dvc.run_dvc_command(["add", path])
             elif calkit.dvc.zip.is_zip_candidate(path):
                 if dry_run:
@@ -946,6 +967,7 @@ def add(
                     typer.echo(
                         f"Adding {path} to DVC since it's greater than 1 MB"
                     )
+                    calkit.git.ensure_dvc_pointer_is_not_ignored(repo, path)
                     calkit.dvc.run_dvc_command(["add", path])
             else:
                 if dry_run:
@@ -3201,6 +3223,14 @@ def call_dvc(
     and DVC is not installed.
     """
     result = calkit.dvc.run_dvc_command(sys.argv[2:])
+    if result != 0 and len(sys.argv) > 2 and sys.argv[2] == "add":
+        typer.secho(
+            "Hint: If DVC failed because a .dvc pointer file is git-ignored, "
+            "use `calkit add --to=dvc <path>` instead so Calkit can "
+            "automatically manage the gitignore exception.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
     sys.exit(result)
 
 

calkit/cli/new.py

@@ -3174,7 +3174,7 @@ def new_release(
         detected_kind, artifact = calkit.releases.find_artifact(path, ck_info)
         if detected_kind is None:
             detected_kind = calkit.detect.detect_artifact_kind(
-                pathlib.Path(path).as_posix()
+                pathlib.Path(path).as_posix(),
             )
         if release_kind is None:
             if detected_kind is None:
@@ -3258,16 +3258,12 @@ def new_release(
         # stored as-is (renamed); folders and whole-project releases are
         # zipped.
         project_name = calkit.detect_project_name(prepend_owner=False)
-        if path == ".":
+        if path == "." or os.path.isdir(path):
             stored_filename = f"{project_name}-{name}.zip"
             is_zip = True
-        elif os.path.isdir(path):
-            folder_name = os.path.basename(os.path.normpath(path))
-            stored_filename = f"{project_name}-{folder_name}-{name}.zip"
-            is_zip = True
         elif os.path.isfile(path):
-            stem, ext = os.path.splitext(os.path.basename(path))
-            stored_filename = f"{project_name}-{stem}-{name}{ext}"
+            _, ext = os.path.splitext(os.path.basename(path))
+            stored_filename = f"{project_name}-{name}{ext}"
             is_zip = False
         else:
             raise_error(f"Release path '{path}' does not exist")

calkit/cli/overleaf.py

@@ -437,7 +437,12 @@ def sync(
         raise_error("No Overleaf sync info found")
     overleaf_sync_dirs = list(overleaf_info.keys())
     if paths is not None:
-        paths = [os.path.dirname(p) if os.path.isfile(p) else p for p in paths]
+        paths = [
+            (os.path.dirname(p) if os.path.isfile(p) else p)
+            .strip()
+            .rstrip("/\\")
+            for p in paths
+        ]
         for path in paths:
             if path not in overleaf_sync_dirs:
                 raise_error(f"Path '{path}' is not synced with Overleaf")
@@ -611,7 +616,12 @@ def get_status(
         raise_error("No Overleaf sync info found")
     overleaf_sync_dirs = list(overleaf_info.keys())
     if paths is not None:
-        paths = [os.path.dirname(p) if os.path.isfile(p) else p for p in paths]
+        paths = [
+            (os.path.dirname(p) if os.path.isfile(p) else p)
+            .strip()
+            .rstrip("/\\")
+            for p in paths
+        ]
         for path in paths:
             if path not in overleaf_sync_dirs:
                 raise_error(f"Path '{path}' is not synced with Overleaf")

calkit/detect.py

@@ -13,6 +13,8 @@ import sys
 from pathlib import Path
 from typing import Literal
 
+import pathspec
+
 NotebookLanguage = Literal["python", "julia", "r"]
 
 
@@ -1549,6 +1551,20 @@ def _is_stdlib_module(module_name: str) -> bool:
     return base_module in common_stdlib
 
 
+_PYTHON_IMPORT_TO_DISTRIBUTION = {
+    "sklearn": "scikit-learn",
+    "skimage": "scikit-image",
+    "cv2": "opencv-python",
+    "PIL": "Pillow",
+    "bs4": "beautifulsoup4",
+    "yaml": "PyYAML",
+    "dateutil": "python-dateutil",
+    "dotenv": "python-dotenv",
+    "serial": "pyserial",
+    "git": "GitPython",
+}
+
+
 def detect_python_dependencies(
     script_path: str | None = None,
     code: str | None = None,
@@ -1614,13 +1630,21 @@ def detect_python_dependencies(
                 if not _is_stdlib_module(module_name):
                     # Get the top-level package name
                     top_level = module_name.split(".")[0]
-                    dependencies.add(top_level)
+                    dependencies.add(
+                        _PYTHON_IMPORT_TO_DISTRIBUTION.get(
+                            top_level, top_level
+                        )
+                    )
         elif isinstance(node, ast.ImportFrom):
             if node.module and node.level == 0:
                 module_name = node.module
                 if not _is_stdlib_module(module_name):
                     top_level = module_name.split(".")[0]
-                    dependencies.add(top_level)
+                    dependencies.add(
+                        _PYTHON_IMPORT_TO_DISTRIBUTION.get(
+                            top_level, top_level
+                        )
+                    )
     return sorted(list(dependencies))
 
 
@@ -1927,6 +1951,21 @@ PRESENTATION_NAMES = {
     "talk.pdf",
 }
 
+DETECTION_IGNORE_FPATH = os.path.join(".calkit", "ignore")
+
+
+def load_detection_ignore(wdir: str | None = None) -> pathspec.PathSpec | None:
+    """Load ``.calkit/ignore`` artifact detection exclusions."""
+    import pathspec
+
+    fpath = DETECTION_IGNORE_FPATH
+    if wdir is not None:
+        fpath = os.path.join(wdir, fpath)
+    if not os.path.isfile(fpath):
+        return None
+    with open(fpath, encoding="utf-8") as f:
+        return pathspec.PathSpec.from_lines("gitwildmatch", f)
+
 
 def _ancestor_dir_names(rel_path: str) -> set[str]:
     """Lower-cased names of the ancestor directories of a "/"-separated path."""
@@ -1938,8 +1977,12 @@ def _path_ext(rel_path: str) -> str:
     return ("." + name.rsplit(".", 1)[-1].lower()) if "." in name else ""
 
 
-def is_figure_path(rel_path: str) -> bool:
+def is_figure_path(
+    rel_path: str, *, ignore: pathspec.PathSpec | None = None
+) -> bool:
     """Whether a repo-relative path looks like an auto-detectable figure."""
+    if ignore is not None and ignore.match_file(rel_path):
+        return False
     ancestors = _ancestor_dir_names(rel_path)
     ext = _path_ext(rel_path)
     if ext in FIGURE_EXTENSIONS and ancestors & FIGURE_DIRS:
@@ -1951,37 +1994,49 @@ def is_figure_path(rel_path: str) -> bool:
     return False
 
 
-def is_dataset_path(rel_path: str) -> bool:
+def is_dataset_path(
+    rel_path: str, *, ignore: pathspec.PathSpec | None = None
+) -> bool:
     """Whether a repo-relative path looks like an auto-detectable dataset."""
+    if ignore is not None and ignore.match_file(rel_path):
+        return False
     return (
         _path_ext(rel_path) in DATASET_EXTENSIONS
         and bool(_ancestor_dir_names(rel_path) & DATA_DIRS)
-        and not is_figure_path(rel_path)
+        and not is_figure_path(rel_path, ignore=ignore)
     )
 
 
-def is_result_path(rel_path: str) -> bool:
+def is_result_path(
+    rel_path: str, *, ignore: pathspec.PathSpec | None = None
+) -> bool:
     """Whether a repo-relative path looks like an auto-detectable result.
 
     A result is a data-like file (JSON, CSV, etc.) under a ``results``-style
     directory. Anything already detected as a figure or dataset is excluded.
     """
+    if ignore is not None and ignore.match_file(rel_path):
+        return False
     return (
         _path_ext(rel_path) in RESULT_EXTENSIONS
         and bool(_ancestor_dir_names(rel_path) & RESULT_DIRS)
-        and not is_figure_path(rel_path)
-        and not is_dataset_path(rel_path)
+        and not is_figure_path(rel_path, ignore=ignore)
+        and not is_dataset_path(rel_path, ignore=ignore)
     )
 
 
-def is_presentation_path(rel_path: str) -> bool:
+def is_presentation_path(
+    rel_path: str, *, ignore: pathspec.PathSpec | None = None
+) -> bool:
     """Whether a repo-relative path looks like an auto-detectable presentation.
 
     Either a slide-deck file (PDF/PPTX/KEY) under a ``slides``/``presentations``
     directory, or a file with a presentation-like name (e.g. ``slides.pdf``,
     ``presentation.pdf``) anywhere. Figures are excluded.
     """
-    if is_figure_path(rel_path):
+    if ignore is not None and ignore.match_file(rel_path):
+        return False
+    if is_figure_path(rel_path, ignore=ignore):
         return False
     name = rel_path.rsplit("/", 1)[-1].lower()
     if name in PRESENTATION_NAMES:
@@ -2018,7 +2073,9 @@ PUBLICATION_NAMES = {
 }
 
 
-def is_publication_path(rel_path: str) -> bool:
+def is_publication_path(
+    rel_path: str, *, ignore: pathspec.PathSpec | None = None
+) -> bool:
     """Whether a repo-relative path looks like an auto-detectable publication.
 
     Either a document (PDF/TeX/DOCX) under a ``paper``/``publication``/
@@ -2026,7 +2083,11 @@ def is_publication_path(rel_path: str) -> bool:
     ``manuscript.pdf``, ``main.tex``) anywhere. Figures and presentations are
     excluded.
     """
-    if is_figure_path(rel_path) or is_presentation_path(rel_path):
+    if ignore is not None and ignore.match_file(rel_path):
+        return False
+    if is_figure_path(rel_path, ignore=ignore) or is_presentation_path(
+        rel_path, ignore=ignore
+    ):
         return False
     name = rel_path.rsplit("/", 1)[-1].lower()
     if name in PUBLICATION_NAMES:
@@ -2036,19 +2097,21 @@ def is_publication_path(rel_path: str) -> bool:
     )
 
 
-def detect_artifact_kind(rel_path: str) -> str | None:
+def detect_artifact_kind(
+    rel_path: str, *, ignore: pathspec.PathSpec | None = None
+) -> str | None:
     """Infer an artifact's release kind from its repo-relative path.
 
     Returns one of ``"figure"``, ``"presentation"``, ``"publication"``, or
     ``"dataset"``, or ``None`` if the path doesn't look like any of these.
     """
-    if is_figure_path(rel_path):
+    if is_figure_path(rel_path, ignore=ignore):
         return "figure"
-    if is_presentation_path(rel_path):
+    if is_presentation_path(rel_path, ignore=ignore):
         return "presentation"
-    if is_publication_path(rel_path):
+    if is_publication_path(rel_path, ignore=ignore):
         return "publication"
-    if is_dataset_path(rel_path):
+    if is_dataset_path(rel_path, ignore=ignore):
         return "dataset"
     return None
 
@@ -2090,6 +2153,7 @@ def _collapse_dataset_folders(paths: list[str]) -> list[str]:
 def detect_figures(
     candidate_paths: list[str],
     reserved_paths: list[str] | tuple[str, ...] = (),
+    ignore: pathspec.PathSpec | None = None,
 ) -> list[str]:
     """Auto-detected figure paths among ``candidate_paths``.
 
@@ -2103,7 +2167,7 @@ def detect_figures(
             for p in candidate_paths
             if not _is_hidden_path(p)
             and not _is_under_any_dir(p, reserved)
-            and is_figure_path(p)
+            and is_figure_path(p, ignore=ignore)
         }
     )
 
@@ -2112,6 +2176,7 @@ def detect_datasets(
     candidate_paths: list[str],
     reserved_paths: list[str] | tuple[str, ...] = (),
     figure_paths: list[str] | tuple[str, ...] = (),
+    ignore: pathspec.PathSpec | None = None,
 ) -> list[str]:
     """Auto-detected dataset paths among ``candidate_paths``.
 
@@ -2126,7 +2191,7 @@ def detect_datasets(
         if not _is_hidden_path(p)
         and not _is_under_any_dir(p, reserved)
         and p not in figset
-        and is_dataset_path(p)
+        and is_dataset_path(p, ignore=ignore)
     }
     return _collapse_dataset_folders(sorted(files))
 
@@ -2134,6 +2199,7 @@ def detect_datasets(
 def detect_results(
     candidate_paths: list[str],
     reserved_paths: list[str] | tuple[str, ...] = (),
+    ignore: pathspec.PathSpec | None = None,
 ) -> list[str]:
     """Auto-detected result paths among ``candidate_paths``.
 
@@ -2147,7 +2213,7 @@ def detect_results(
             for p in candidate_paths
             if not _is_hidden_path(p)
             and not _is_under_any_dir(p, reserved)
-            and is_result_path(p)
+            and is_result_path(p, ignore=ignore)
         }
     )
 
@@ -2155,6 +2221,7 @@ def detect_results(
 def detect_presentations(
     candidate_paths: list[str],
     reserved_paths: list[str] | tuple[str, ...] = (),
+    ignore: pathspec.PathSpec | None = None,
 ) -> list[str]:
     """Auto-detected presentation paths among ``candidate_paths``."""
     reserved = list(reserved_paths)
@@ -2164,7 +2231,7 @@ def detect_presentations(
             for p in candidate_paths
             if not _is_hidden_path(p)
             and not _is_under_any_dir(p, reserved)
-            and is_presentation_path(p)
+            and is_presentation_path(p, ignore=ignore)
         }
     )
 
@@ -2254,18 +2321,28 @@ def detect_project_artifacts(
 
     if ck_info is None:
         ck_info = calkit.load_calkit_info(wdir=wdir)
+    ignore = load_detection_ignore(wdir=wdir)
     reserved = _reserved_artifact_paths(wdir=wdir, ck_info=ck_info)
     candidates = list(
         dict.fromkeys(
             [*list_repo_files(wdir=wdir), *list_dvc_tracked_files(wdir=wdir)]
         )
     )
-    figures = detect_figures(candidates, reserved_paths=reserved)
+    figures = detect_figures(
+        candidates, reserved_paths=reserved, ignore=ignore
+    )
     datasets = detect_datasets(
-        candidates, reserved_paths=reserved, figure_paths=figures
+        candidates,
+        reserved_paths=reserved,
+        figure_paths=figures,
+        ignore=ignore,
+    )
+    results = detect_results(
+        candidates, reserved_paths=reserved, ignore=ignore
+    )
+    presentations = detect_presentations(
+        candidates, reserved_paths=reserved, ignore=ignore
     )
-    results = detect_results(candidates, reserved_paths=reserved)
-    presentations = detect_presentations(candidates, reserved_paths=reserved)
     return {
         "figures": figures,
         "datasets": datasets,

calkit/dvc/zip.py

@@ -499,6 +499,23 @@ def _sync_one(
     # pipeline output that hasn't been produced yet on a fresh run)
     if workspace_hash is None and zip_hash is None:
         return None
+    # Workspace doesn't exist with no prior sync record while syncing to-zip —
+    # there's nothing to push into the zip (e.g., the zip was pulled but
+    # never unzipped into the workspace)
+    if (
+        workspace_hash is None
+        and last_sync_record is None
+        and direction == "to-zip"
+    ):
+        return None
+    # Zip doesn't exist with no prior sync record while syncing to-workspace —
+    # there's nothing to pull into the workspace
+    if (
+        zip_hash is None
+        and last_sync_record is None
+        and direction == "to-workspace"
+    ):
+        return None
     # Deletion + change on the other side is a conflict
     if workspace_deleted and zip_changed and direction == "both":
         raise RuntimeError(

calkit/git.py

@@ -337,3 +337,32 @@ def ensure_path_is_not_ignored(
     if target_repo.ignored(target_path) and _depth < 10:
         ensure_path_is_not_ignored(target_repo, target_path, _depth + 1)
     return True
+
+
+def ensure_dvc_pointer_is_not_ignored(repo, path: str) -> None:
+    """Ensure the .dvc pointer for ``path`` will not be Git-ignored.
+
+    A broad pattern in a ``.gitignore`` (e.g. ``*.pdf*``) can also match the
+    ``<path>.dvc`` pointer DVC commits to Git, causing ``dvc add`` to fail with
+    "bad DVC file name ... is git-ignored". This appends a ``!*.dvc`` negation
+    to the ``.gitignore`` in the pointer's own directory (which wins under Git
+    precedence) so pointers stay tracked. Idempotent.
+    """
+    path = path.replace("\\", "/").rstrip("/")
+    pointer = path + ".dvc"
+    if pointer not in repo.ignored(pointer):
+        return
+    pointer_dir = os.path.dirname(pointer)
+    gitignore_path = os.path.join(repo.working_dir, pointer_dir, ".gitignore")
+    exception = "!*.dvc"
+    existing_lines = []
+    if os.path.isfile(gitignore_path):
+        with open(gitignore_path, "r", encoding="utf-8") as f:
+            existing_lines = f.read().splitlines()
+    if exception in existing_lines:
+        return  # Already present
+    os.makedirs(os.path.dirname(gitignore_path), exist_ok=True)
+    with open(gitignore_path, "a", encoding="utf-8") as f:
+        if existing_lines and existing_lines[-1] != "":
+            f.write("\n")
+        f.write(exception + "\n")

calkit/models/core.py

@@ -351,13 +351,23 @@ class ResultsEvidence(BaseModel):
     explanation: str | None = None
 
 
+class PublicationEvidence(BaseModel):
+    """Evidence in the form of a publication."""
+
+    kind: Literal["publication"] = "publication"
+    path: str
+    explanation: str | None = None
+
+
 class Question(BaseModel):
     """A question the project hopes to answer."""
 
     question: str
     hypothesis: str | None = None
     answer: str | None = None
-    evidence: list[FigureEvidence | ResultsEvidence] | None = None
+    evidence: (
+        list[FigureEvidence | ResultsEvidence | PublicationEvidence] | None
+    ) = None
 
 
 class Dependency(BaseModel):

calkit/tests/cli/main/test_core.py

@@ -60,6 +60,16 @@ def test_init(tmp_dir):
     subprocess.check_call(["calkit", "init"])
     assert os.path.isfile("calkit.yaml")
     assert calkit.load_calkit_info() == {}
+    # Already initialized: init without --force fails and does not clobber
+    result = subprocess.run(
+        ["calkit", "init"],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode != 0
+    assert "already initialized" in result.stderr.lower()
+    assert "use --force" in result.stderr.lower()
+    assert calkit.load_calkit_info() == {}
     # init must not clobber a pre-existing calkit.yaml
     os.makedirs("sub")
     ck_info = {"name": "test-project"}
@@ -67,6 +77,19 @@ def test_init(tmp_dir):
         calkit.ryaml.dump(ck_info, f)
     subprocess.check_call(["calkit", "init"], cwd="sub")
     assert calkit.load_calkit_info(wdir="sub") == ck_info
+    # Fully initialized project blocks init without --force
+    result = subprocess.run(
+        ["calkit", "init"],
+        cwd="sub",
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode != 0
+    assert "already initialized" in result.stderr.lower()
+    assert calkit.load_calkit_info(wdir="sub") == ck_info
+    # --force allows re-initialization without clobbering calkit.yaml
+    subprocess.check_call(["calkit", "init", "--force"], cwd="sub")
+    assert calkit.load_calkit_info(wdir="sub") == ck_info
 
 
 @skipif_windows_docker
@@ -1813,3 +1836,70 @@ def test_run_downstream_does_not_submit_unrelated_sweep(tmp_dir):
     assert os.path.exists("other.txt")
     assert not os.path.exists("out-1.txt")
     assert not os.path.exists("out-2.txt")
+
+
+def test_add_dvc_pointer_unignored(tmp_dir):
+    """Test that calkit add --to=dvc ensures the .dvc pointer is unignored."""
+    subprocess.check_call(["git", "init"])
+    subprocess.check_call(["calkit", "init"])
+    os.makedirs("pubs/defense/ppt")
+    with open("pubs/defense/ppt/.gitignore", "w") as f:
+        f.write("*.pdf*\n")
+    pdf_path = "pubs/defense/ppt/McCabe.pdf"
+    with open(pdf_path, "w") as f:
+        f.write("dummy pdf content")
+    subprocess.check_call(["calkit", "add", "--to=dvc", pdf_path])
+    # Assert pointer exists
+    dvc_file = f"{pdf_path}.dvc"
+    assert os.path.exists(dvc_file)
+    # Assert pointer is NOT ignored (should return 1)
+    res = subprocess.run(["git", "check-ignore", "-q", dvc_file])
+    assert res.returncode == 1
+    # Assert data file IS still ignored
+    res_data = subprocess.run(["git", "check-ignore", "-q", pdf_path])
+    assert res_data.returncode == 0
+    # Assert it was staged
+    staged = calkit.git.get_staged_files()
+    assert dvc_file in staged
+
+
+def test_add_dvc_pointer_unignored_idempotent(tmp_dir):
+    """Test that the unignore logic does not duplicate lines."""
+    subprocess.check_call(["git", "init"])
+    subprocess.check_call(["calkit", "init"])
+    os.makedirs("data")
+    with open("data/.gitignore", "w") as f:
+        f.write("*.pdf*\n")
+    pdf_path = "data/doc.pdf"
+    with open(pdf_path, "w") as f:
+        f.write("doc")
+    subprocess.check_call(["calkit", "add", "--to=dvc", pdf_path])
+    with open("data/.gitignore") as f:
+        content1 = f.read()
+    # Second add should not duplicate
+    subprocess.check_call(["calkit", "add", "--to=dvc", pdf_path])
+    with open("data/.gitignore") as f:
+        content2 = f.read()
+    assert content1 == content2
+    assert content1.count("!*.dvc") == 1
+
+
+def test_call_dvc_passthrough_hint(tmp_dir):
+    """Test that calkit dvc add prints a hint if .dvc is ignored."""
+    subprocess.check_call(["git", "init"])
+    subprocess.check_call(["calkit", "init"])
+    os.makedirs("data")
+    with open("data/.gitignore", "w") as f:
+        f.write("*.pdf*\n")
+    pdf_path = "data/doc.pdf"
+    with open(pdf_path, "w") as f:
+        f.write("doc")
+    # Run the passthrough dvc add which will fail because it's ignored
+    res = subprocess.run(
+        ["calkit", "dvc", "add", pdf_path], capture_output=True, text=True
+    )
+    assert res.returncode != 0
+    assert (
+        "Hint: If DVC failed because a .dvc pointer file is git-ignored"
+        in res.stderr
+    )

calkit/tests/cli/test_list.py

@@ -91,12 +91,52 @@ def test_list_presentations(tmp_dir):
 def test_list_questions(tmp_dir):
     subprocess.check_call(["calkit", "init"])
     subprocess.check_call(["calkit", "new", "question", "Does it work?"])
+    ck_info = calkit.load_calkit_info()
+    ck_info["questions"].append(
+        {
+            "question": "What is the effect?",
+            "hypothesis": "It improves performance.",
+            "answer": "It improves performance by 10%.",
+            "evidence": [
+                {"kind": "figure", "path": "figures/performance.png"},
+                {
+                    "kind": "result",
+                    "path": "results/metrics.json",
+                    "key": "accuracy",
+                },
+                {
+                    "kind": "publication",
+                    "path": "paper/paper.pdf",
+                    "explanation": "See the results section.",
+                },
+            ],
+        }
+    )
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
     out = subprocess.check_output(
         ["calkit", "list", "questions", "--json"], text=True
     )
-    assert json.loads(out) == ["Does it work?"]
+    questions = json.loads(out)
+    assert questions[0] == "Does it work?"
+    assert questions[1]["question"] == "What is the effect?"
+    assert questions[1]["hypothesis"] == "It improves performance."
+    assert questions[1]["evidence"][2]["kind"] == "publication"
+    assert questions[1]["evidence"][2]["path"] == "paper/paper.pdf"
     out = subprocess.check_output(["calkit", "list", "questions"], text=True)
     assert "1. Does it work?" in out
+    assert "2. question: What is the effect?" in out
+    assert "hypothesis: It improves performance." in out
+    assert "answer: It improves performance by 10%." in out
+    assert "evidence:" in out
+    assert "- kind: figure" in out
+    assert "path: figures/performance.png" in out
+    assert "- kind: result" in out
+    assert "path: results/metrics.json" in out
+    assert "key: accuracy" in out
+    assert "- kind: publication" in out
+    assert "path: paper/paper.pdf" in out
+    assert "explanation: See the results section." in out
 
 
 def test_list_remotes(tmp_dir):

calkit/tests/cli/test_new.py

@@ -760,7 +760,7 @@ def test_new_nix_env_stages_flake(tmp_dir):
     )
     assert os.path.isfile("flake.nix")
     repo = git.Repo(".")
-    head_files = [item.path for item in repo.head.commit.tree.traverse()]
+    head_files = [item.path for item in repo.head.commit.tree.traverse()]  # type: ignore
     assert "flake.nix" in head_files
     assert "calkit.yaml" in head_files
 
@@ -991,26 +991,26 @@ def test_new_internal_release(tmp_dir):
             "--to",
             "none",
             "--name",
-            "v0",
+            "slides-v0",
             "--desc",
-            "First version sent to Mo for review.",
+            "First version sent for review.",
             "--no-push",
         ]
     )
     ck_info = calkit.load_calkit_info()
-    assert "v0" in ck_info["releases"]
-    release = ck_info["releases"]["v0"]
+    assert "slides-v0" in ck_info["releases"]
+    release = ck_info["releases"]["slides-v0"]
     assert release["internal"] is True
     assert release["kind"] == "presentation"
     assert release["doi"] is None
     assert release["calkit_version"] == calkit.__version__
-    assert release["description"] == "First version sent to Mo for review."
+    assert release["description"] == "First version sent for review."
     assert (
         release["stored_path"]
-        == ".calkit/releases/v0/test-project-slides-v0.pdf"
+        == ".calkit/releases/slides-v0/test-project-slides-v0.pdf"
     )
     assert os.path.isfile(release["stored_path"])
-    assert "v0" in [t.name for t in git.Repo().tags]
+    assert "slides-v0" in [t.name for t in git.Repo().tags]
     # Internal release of a folder: zipped with a self-describing name
     subprocess.check_call(
         [
@@ -1020,14 +1020,15 @@ def test_new_internal_release(tmp_dir):
             "data/raw",
             "--internal",
             "--name",
-            "v1",
+            "raw-data-v1",
             "--no-push",
         ]
     )
-    release = calkit.load_calkit_info()["releases"]["v1"]
+    release = calkit.load_calkit_info()["releases"]["raw-data-v1"]
     assert release["kind"] == "dataset"
     assert (
-        release["stored_path"] == ".calkit/releases/v1/test-project-raw-v1.zip"
+        release["stored_path"]
+        == ".calkit/releases/raw-data-v1/test-project-raw-data-v1.zip"
     )
     assert os.path.isfile(release["stored_path"])
     # Internal release of the whole project: zipped archive
@@ -1068,10 +1069,7 @@ def test_new_internal_release(tmp_dir):
     )
     release = calkit.load_calkit_info()["releases"]["v3"]
     assert release["kind"] == "figure"
-    assert (
-        release["stored_path"]
-        == ".calkit/releases/v3/test-project-plot-v3.png"
-    )
+    assert release["stored_path"] == ".calkit/releases/v3/test-project-v3.png"
     # A path that isn't a defined artifact should fail kind detection
     with open("notes.txt", "w") as f:
         f.write("hello\n")
@@ -1110,10 +1108,7 @@ def test_new_internal_release(tmp_dir):
     )
     release = calkit.load_calkit_info()["releases"]["v5"]
     assert release["kind"] == "dataset"
-    assert (
-        release["stored_path"]
-        == ".calkit/releases/v5/test-project-notes-v5.txt"
-    )
+    assert release["stored_path"] == ".calkit/releases/v5/test-project-v5.txt"
     # Listing releases must not warn about publication status for internal
     # releases, which have no publisher or record ID
     result = subprocess.run(

calkit/tests/cli/test_overleaf.py

@@ -362,3 +362,50 @@ def test_extract_title_from_tex(tmp_dir):
         f.write(tex)
     title = _extract_title_from_tex("test.tex")
     assert title == "My Cool Paper"
+
+
+def test_overleaf_sync_trailing_slash_or_space(tmp_dir):
+    pid = str(uuid.uuid4())
+    ol_repo = _make_temp_overleaf_project(pid)
+    ol_repo.git.config(["receive.denyCurrentBranch", "ignore"])
+    subprocess.run(["calkit", "init"], check=True)
+    repo = git.Repo()
+    tmp_remote = (
+        Path(tempfile.gettempdir()) / "overleaf-sync-remotes" / pid
+    ).as_posix()
+    os.makedirs(tmp_remote, exist_ok=True)
+    remote_repo = git.Repo.init(path=tmp_remote, bare=True)
+    remote_repo.git.config(["receive.denyCurrentBranch", "ignore"])
+    repo.git.config(["push.autoSetupRemote", "true"])
+    repo.git.remote(["add", "origin", tmp_remote])
+    ol_url = calkit.overleaf.get_git_remote_url(pid, "no token")
+    assert os.environ["CALKIT_ENV"] == "test"
+    assert os.environ["CALKIT_TEST_OVERLEAF_TOKEN"] == "none"
+    config = calkit.config.read()
+    assert config.overleaf_token == "none"
+    subprocess.run(
+        [
+            "calkit",
+            "overleaf",
+            "import",
+            ol_url,
+            "pubs/applied-ocean-research",
+            "--title",
+            "Test Pub",
+        ],
+        check=True,
+    )
+    # Try syncing with a trailing slash
+    res = subprocess.run(
+        ["calkit", "overleaf", "sync", "pubs/applied-ocean-research/"],
+        capture_output=True,
+        text=True,
+    )
+    assert res.returncode == 0, f"Trailing slash sync failed: {res.stderr}"
+    # Try syncing with a trailing space
+    res2 = subprocess.run(
+        ["calkit", "overleaf", "sync", "pubs/applied-ocean-research "],
+        capture_output=True,
+        text=True,
+    )
+    assert res2.returncode == 0, f"Trailing space sync failed: {res2.stderr}"

calkit/tests/dvc/test_zip.py

@@ -303,3 +303,28 @@ def test_sync_one(tmp_dir, monkeypatch):
     assert result is not None
     assert (src7 / "a.txt").read_text() == "hello"
     assert get_sync_record(str(src7.as_posix())) is not None
+    # Zip exists but workspace was never unzipped (no sync record) with
+    # direction=to-zip: nothing to push, skip without error
+    src8 = tmp_dir / "src8"
+    src8.mkdir()
+    (src8 / "a.txt").write_text("hello")
+    zip_out8 = str(tmp_dir / calkit.dvc.zip.ZIPS_DIR / "src8.zip")
+    zip_(str(src8), zip_out8)
+    shutil.rmtree(str(src8))
+    write_zip_path_map({str(src8.as_posix()): zip_out8})
+    result = sync_one(str(src8), zip_out8, direction="to-zip")
+    assert result is None
+    assert os.path.isfile(zip_out8)
+    assert not os.path.exists(str(src8))
+    # Workspace exists but zip was never created (no sync record) with
+    # direction=to-workspace: nothing to pull, skip without error
+    src9 = tmp_dir / "src9"
+    src9.mkdir()
+    (src9 / "a.txt").write_text("hello")
+    zip_out9 = str(tmp_dir / calkit.dvc.zip.ZIPS_DIR / "src9.zip")
+    write_zip_path_map({str(src9.as_posix()): zip_out9})
+    result = sync_one(str(src9), zip_out9, direction="to-workspace")
+    assert result is None
+    assert not os.path.exists(zip_out9)
+    assert get_sync_record(str(src9.as_posix())) is None
+    assert (src9 / "a.txt").read_text() == "hello"

calkit/tests/models/test_core.py

@@ -3,7 +3,7 @@
 import pytest
 from pydantic import ValidationError
 
-from calkit.models.core import ProjectInfo, Publication
+from calkit.models.core import ProjectInfo, Publication, Question
 
 
 def test_publication_kind_no_longer_allows_presentation():
@@ -23,3 +23,24 @@ def test_project_info_has_results_and_presentations():
     )
     assert info.results[0].path == "results/metrics.json"
     assert info.presentations[0].path == "slides/talk.pdf"
+
+
+def test_question_accepts_publication_evidence():
+    q = Question.model_validate(
+        {
+            "question": "Does the paper support this?",
+            "answer": "Yes.",
+            "evidence": [
+                {"kind": "publication", "path": "paper/paper.pdf"},
+                {
+                    "kind": "publication",
+                    "path": "paper/supplement.pdf",
+                    "explanation": "See Table 1.",
+                },
+            ],
+        }
+    )
+    assert q.evidence is not None
+    assert q.evidence[0].kind == "publication"
+    assert q.evidence[0].path == "paper/paper.pdf"
+    assert q.evidence[1].explanation == "See Table 1."

calkit/tests/test_detect.py

@@ -821,7 +821,7 @@ data = pd.read_csv("data.csv")
     deps = detect_python_dependencies(script_path="script.py")
     assert "numpy" in deps
     assert "pandas" in deps
-    assert "sklearn" in deps
+    assert "scikit-learn" in deps
     assert "matplotlib" in deps
     # stdlib modules should not be included
     assert "os" not in deps
@@ -841,6 +841,19 @@ import json  # stdlib
     assert "json" not in deps
 
 
+def test_detect_python_dependencies_distribution_mapping():
+    """Test mapping of Python import names to distribution names."""
+    code = """
+import sklearn
+import cv2
+"""
+    deps = detect_python_dependencies(code=code)
+    assert "scikit-learn" in deps
+    assert "opencv-python" in deps
+    assert "sklearn" not in deps
+    assert "cv2" not in deps
+
+
 def test_detect_r_dependencies_from_script(tmp_dir):
     """Test detection of R dependencies from a script."""
     script_content = """
@@ -1025,7 +1038,7 @@ def test_detect_dependencies_from_python_notebook(tmp_dir):
     deps = detect_dependencies_from_notebook("notebook.ipynb")
     assert "numpy" in deps
     assert "pandas" in deps
-    assert "sklearn" in deps
+    assert "scikit-learn" in deps
     assert "matplotlib" in deps
     assert "requests" in deps
 
@@ -1296,3 +1309,47 @@ def test_detect_project_artifacts_includes_results_and_presentations(tmp_dir):
     out = calkit.detect.detect_project_artifacts(ck_info={})
     assert "results/metrics.json" in out["results"]
     assert "slides/deck.pdf" in out["presentations"]
+
+
+def test_detection_ignore(tmp_dir):
+    from calkit.detect import (
+        detect_artifact_kind,
+        detect_figures,
+        load_detection_ignore,
+    )
+
+    # (e) No ignore file -> unchanged detection.
+    assert load_detection_ignore() is None
+    assert detect_figures(["figures/a.png"]) == ["figures/a.png"]
+    os.makedirs(".calkit", exist_ok=True)
+    with open(".calkit/ignore", "w") as f:
+        f.write(
+            "\n".join(
+                [
+                    "# this is a comment",
+                    "",
+                    "paper/figs/report.pdf",
+                    "*.ipynb",
+                    "*.csv",
+                    "notebooks/scratch/",
+                ]
+            )
+        )
+    ignore = load_detection_ignore()
+    # (a) a path listed in .calkit/ignore is not detected as ANY artifact type
+    path = "paper/figs/report.pdf"
+    assert detect_artifact_kind(path) == "figure"
+    assert detect_artifact_kind(path, ignore=ignore) is None
+    assert path not in detect_figures([path], ignore=ignore)
+    # (b) comments and blank lines are ignored (implied by parsing succeeding)
+    assert ignore is not None
+    assert not ignore.match_file("# this is a comment")
+    # (c) a glob pattern excludes matching files
+    globbed = "data/raw.csv"
+    assert detect_artifact_kind(globbed) == "dataset"
+    assert detect_artifact_kind(globbed, ignore=ignore) is None
+    assert ignore.match_file("analysis.ipynb") is True
+    # (d) a directory pattern excludes files under it
+    in_dir = "notebooks/scratch/data/raw.parquet"
+    assert detect_artifact_kind(in_dir) == "dataset"
+    assert detect_artifact_kind(in_dir, ignore=ignore) is None

{calkit_python-0.41.19.dist-info → calkit_python-0.41.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.41.19
+Version: 0.41.21
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -26,7 +26,7 @@ Requires-Dist: arithmeval
 Requires-Dist: bibtexparser
 Requires-Dist: checksumdir
 Requires-Dist: docx2pdf
-Requires-Dist: dvc==3.67.1
+Requires-Dist: dvc[all]==3.67.1
 Requires-Dist: fastapi
 Requires-Dist: fsspec>=2026.4.0
 Requires-Dist: gitpython
@@ -78,15 +78,16 @@ Description-Content-Type: text/markdown
 
 <!-- INCLUDE: docs/index.md -->
 
-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.
+Typical research workflows are horizontally-siloed, i.e.,
+various stages--data collection, analysis, writing--are performed in
+disconnected systems,
+turning research into a slow, error-prone, and tedious
+[waterfall](https://en.wikipedia.org/wiki/Waterfall_model) process.
 
 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.
+so every output can be traced back to its source (provenance)
+and reproduced with a single command.
 
 With industry standard tools combined into a unified and simplified experience
 tailored for research,

{calkit_python-0.41.19.dist-info → calkit_python-0.41.21.dist-info}/RECORD

@@ -8,11 +8,11 @@ calkit/config.py,sha256=tkrdAQU1m3__B9efpYgK6IhtLtS3WWFcVpY2zEQpBio,7573
 calkit/core.py,sha256=ferYD6jmvbZ1h1MlNApmuHiMokrLPynWtuU62wudzsc,28534
 calkit/datasets.py,sha256=9lOlOreey2aJGMw6MiV9MDzSHp-fYkCf1k1AZbWTdQE,2235
 calkit/dependencies.py,sha256=y5N_4ctwp9rFZVg82Si9_2x8Yh64Ex-WqP0iiN5NNBE,13276
-calkit/detect.py,sha256=3uD0Jjhx_vuDVuAkwI90_TBuMhB9nS-tSujmBabEct4,81122
+calkit/detect.py,sha256=IbkeuBUSk_6bjDK3G-HD7dDAAIp_OzYN3IRREasOaj8,83519
 calkit/docker.py,sha256=EEcgbXjs-1ttixAZ-G-hmDlvnqSxYbIZmbzeAza37TI,15706
 calkit/environments.py,sha256=PoAzpD3Esuupn3AGnR8J9ffvjHcxdBH1SQTXLxB1fY0,78060
 calkit/fs.py,sha256=dKWUfi51F1ka7uikn_O__jxvPOUwY05ZmydxE1KaJUA,45459
-calkit/git.py,sha256=rHAWdI13vA35m7q-MhlHj2KHMa42s4ecisTvKbdXKMw,13321
+calkit/git.py,sha256=2o94iQkz8-kv6p-VgvKML-waWJOo79ts8eDrpcF0C8M,14602
 calkit/github.py,sha256=8_yZ0ej8TKM4qk8iPeGq47R1I4MHdSoJ_Zpr1gRwNEM,1701
 calkit/gui.py,sha256=2UCrMyosc5v4CLlDcHO7oDwW9eLn5_WbNaLaG5bjMTc,23
 calkit/install.py,sha256=n989NLyZSTndj_rEaHceSip5aXP7zZIlG9QwbFs8kTc,7913
@@ -39,23 +39,23 @@ calkit/cli/describe.py,sha256=g6WWqa4nHSDda1Jt4D1g-VUm1k4bMskBfgKwDAhUokU,1817
 calkit/cli/dev.py,sha256=cu4QsfDiA_KurGx4WJcgA2qgfghMoZutE8kl4IZbUcM,1070
 calkit/cli/import_.py,sha256=5j2ANLq6v7HOku9kJUWylwvQnJfkb_OUKCNOdv1BQXU,18264
 calkit/cli/latex.py,sha256=Zqw7EyodVohUqC1iR1i5QmPRMYg8quHwJdgS8I684ag,7739
-calkit/cli/list.py,sha256=W-ftvc6sYwt5iT7NIYr5_4jJWjDPbB-8pAropPnvaFc,10704
-calkit/cli/new.py,sha256=yFrwl4qB8iUyV2wQ1fR-lLtVH9WuVVpeQUwHXAQapTc,137621
+calkit/cli/list.py,sha256=jzkZC7dgbmYz8aCBfEWibu_ZRm6i0xwXmIgbUR4NZgA,12040
+calkit/cli/new.py,sha256=UDFUi3_MvQcI7q5VWFnRRrX7pW6KCoTcssmJtxkfXpw,137435
 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/overleaf.py,sha256=xgcONFdyItlUHUfSD_iF-bhjddKO_-ObtHz_Khiz-xE,25384
 calkit/cli/scheduler.py,sha256=OWJpW57G6Ebs5FTZ_nf2PpEG9QNd6WPe0mb3TmbVTyE,42402
 calkit/cli/update.py,sha256=5Jjo-5uRTxd5UWHvOETPYFWtJJRr81qmKmsibthkLPk,43501
 calkit/cli/main/__init__.py,sha256=qu1POZPyqs33ZKfasOxv_Wc-EzVcEgK3Dt_vwFL8Bi8,65
-calkit/cli/main/core.py,sha256=MMKEAI4bAJm1YJcS4E5MTQAR-XluwtGn3wlsNYjK-NE,123878
+calkit/cli/main/core.py,sha256=1qP6pJB7j8Xsxt51naLhCh3A_PebeZrjVeVTuwC5XLs,125197
 calkit/cli/main/xr.py,sha256=Bug5qJuiIq0tusmdu30t-ZdyaT_Sy5RwPSTiHvCtIqE,25600
 calkit/dvc/__init__.py,sha256=-B6tilCb_jw7QFmJ2srILez24wDhNKUzIBhZUMt01dE,381
 calkit/dvc/core.py,sha256=p42i_uCzgZD6ClGnLOn88zaiGTwrdSG09quL8Hb8Aas,30908
-calkit/dvc/zip.py,sha256=nsAkcTLinH5S2UyZMdoYrBESKPb7s-PARmnuY9dyWVQ,21256
+calkit/dvc/zip.py,sha256=nf4EzOyc5nI_OA3M6S7wwZpL7N4EQz9yCf8FbnPjlxM,21857
 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=0qVnOy5C8n2Bbekj7Fy_WvbVWc6LPoj-Eh6VMiVhVTg,13323
+calkit/models/core.py,sha256=zyfNnq5hPoWW7CFkT3LN4hEBOqJzMu-zCs3V6j2z0DE,13549
 calkit/models/io.py,sha256=FgItZDxrSyph91YRMOEfJo9xWmy3drMin_632vy9WhA,1087
 calkit/models/iteration.py,sha256=lodRMjj818ysec303PkuepOUr3dMPOa0cwKmTUaw9Ok,2947
 calkit/models/pipeline.py,sha256=DhAEXahgaBBI4KqHn0mii2w2t5fE5mzH95jLfdCTY_U,49130
@@ -76,7 +76,7 @@ calkit/tests/test_cloud.py,sha256=yCSuMq0o-i-kN-uWdvbSSBfz6mgKpS_hC3cFA-4DKjs,13
 calkit/tests/test_conda.py,sha256=t-Oy1mL3Vb5njj_t3LQ8HwMhsmLN64HAzSlebnN1A9s,14204
 calkit/tests/test_core.py,sha256=CMhTx89ZpaHTK4nvll2S5M0NLJoBAuH_OBPhq9oEFfM,6272
 calkit/tests/test_dependencies.py,sha256=HskXLzbvvRJz2TXnKPpPAo9lPhoZGYQFy4BmEF31nvk,11139
-calkit/tests/test_detect.py,sha256=XlETyNwNaJKPgAPh9glMcjmuDz-LB2a-Is7EG-hFDAk,43092
+calkit/tests/test_detect.py,sha256=TRrcjp5HF9FgfGZbP1KZGk-oVI08J2rSsAwJoyRxq0Y,45136
 calkit/tests/test_docker.py,sha256=27d0K1GOWiCNv_5TkZSob6EaC0EtQ9DSBIDfkEAEzGk,2077
 calkit/tests/test_environments.py,sha256=ms8avkZy70QPD4GSWAFa04O5rhd2oePaBeo0CBgnXAo,40300
 calkit/tests/test_fs.py,sha256=merhHGLypHTI4qP5qp0L9QFzKtJ7NcOQ2WzH4_CUnF0,13635
@@ -99,47 +99,46 @@ calkit/tests/cli/test_config.py,sha256=Tl4LWfi81eQo6fUgJsoZRNPj_LfkKH-s42HRg5Mxh
 calkit/tests/cli/test_delete.py,sha256=qIbgwKc8nBjmkynzyVuVAjrQB96XSmGRet_jfxs19_0,750
 calkit/tests/cli/test_import.py,sha256=e2BToVPebf4NalFQuIgyTNJHwbc9VMc6AYO-FAhYbQ0,663
 calkit/tests/cli/test_latex.py,sha256=3pG7o-56Rc9_kPbfkoCJ9DKojfNPTQY8yl5JB3SFh2Y,4608
-calkit/tests/cli/test_list.py,sha256=ejMg6q8vtjCbKxvS9zZ32rv_oeKH94JbvpEiVjnw5QA,3859
-calkit/tests/cli/test_new.py,sha256=3d_RoSLfYQVvMA-IF2sh0qXHs-RT3VCrgSF4vnrh_IY,53263
+calkit/tests/cli/test_list.py,sha256=bY74qAHlejgF04EIQgwR5RSdv0Oss3nUkLXcUiSoeFo,5491
+calkit/tests/cli/test_new.py,sha256=G1CpwlhV7a4oiGYep0DgolaAHOrdxQshxE7fE_EeD8M,53283
 calkit/tests/cli/test_notebooks.py,sha256=2t1KiGhEz9H9LcIdWy4jGM05REUxJpWiIg6fSpX12ME,10678
-calkit/tests/cli/test_overleaf.py,sha256=Y-ud4kZHh3nhyoZlXrtMfx61z-GPNytUpfDHMad3tuA,16474
+calkit/tests/cli/test_overleaf.py,sha256=tgGCuOpic0owtOPD_CtZDnffPkknC_73CSDpOT9S3io,18159
 calkit/tests/cli/test_scheduler.py,sha256=mE0KLwcb9gozOnylTLsaL_xYGAptlD9hB8ZiKpPhmcc,17934
 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=_Sjsu-WihAD4wMpL6QyA0T4W-_GtfPRm6ho6wxQqbeA,66012
+calkit/tests/cli/main/test_core.py,sha256=1OqdxnCreG-OqBMgOOYQDrBRjoE2eyECYEQW6nQcqxM,69420
 calkit/tests/cli/main/test_lock.py,sha256=1iX8iSbGtr4O9OkaAi4d3gP3_QzNl6Rr6HLtbEpS6iU,9847
 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=ywXBEyw1XpoSuu1EnMbFl-ebbdEJjpaBEPG157_3RBY,12914
-calkit/tests/dvc/test_zip.py,sha256=H6L3uJdUpsaNQcOPKnmRxMb5Imr_MaDQFoAnMrZMErU,11212
+calkit/tests/dvc/test_zip.py,sha256=UjluBZYTnw5nisHELz42VRPDk88b0TvDx4QJNVaR-iA,12369
 calkit/tests/jupyterlab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/jupyterlab/conftest.py,sha256=Xsh5Zwg0fdqEFPkHDgG7oCHhHJj6WuZLWbmsl7ATABA,207
 calkit/tests/jupyterlab/test_routes.py,sha256=TEEyoHiKnzzKOkQsJcMPKdqpKFQ25yBCvVSquqe9nsE,408
 calkit/tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-calkit/tests/models/test_core.py,sha256=EY-8CRR-Nh6PIjqRfAvyz_An3fkf6Hzk7ed4da02afg,872
+calkit/tests/models/test_core.py,sha256=PkB8WcTSCqOxoGESM395b4GXwTXSCzx6QxUK-bamNAM,1558
 calkit/tests/models/test_iteration.py,sha256=vjuDKwyYQAV4w1qF9VJWQEHksq3KRd6gtT39_a-RhnI,644
 calkit/tests/models/test_pipeline.py,sha256=9F0g6ij7vc8c2hIRIVTHpT0I-JHXC6i2NRB2O9JyrOo,16680
 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.19.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/package.json,sha256=39PQEWOzw0qtqD7Kep3OPbUR113vI7CG5TeD84v7clM,6224
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=NBG3t7gFYb6_2J-yPU29qS7Ck9pYgm8-wC5Q1LrzQeI,6082
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.ac9035764d5b2adbb542.js,sha256=rJA1dk1bKtu1QkURrp5HEC2WCxzZppPV1SCYz-35GTc,8737
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
-calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
-calkit_python-0.41.19.dist-info/METADATA,sha256=wDbS_46jDpM0rrNts42Fxlh_bfLCO-8ihA0n32v-SKU,12437
-calkit_python-0.41.19.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-calkit_python-0.41.19.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
-calkit_python-0.41.19.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
-calkit_python-0.41.19.dist-info/RECORD,,
+calkit_python-0.41.21.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/package.json,sha256=39PQEWOzw0qtqD7Kep3OPbUR113vI7CG5TeD84v7clM,6224
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=NBG3t7gFYb6_2J-yPU29qS7Ck9pYgm8-wC5Q1LrzQeI,6082
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.ac9035764d5b2adbb542.js,sha256=rJA1dk1bKtu1QkURrp5HEC2WCxzZppPV1SCYz-35GTc,8737
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
+calkit_python-0.41.21.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
+calkit_python-0.41.21.dist-info/METADATA,sha256=ajpJDiEj8nYKRBjH6gYzBithUWfetdaZTv3Myz7lXJY,12567
+calkit_python-0.41.21.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+calkit_python-0.41.21.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
+calkit_python-0.41.21.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
+calkit_python-0.41.21.dist-info/RECORD,,

{calkit_python-0.41.19.dist-info → calkit_python-0.41.21.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any

calkit_python-0.41.19.data/data/share/jupyter/labextensions/calkit/install.json

@@ -1,5 +0,0 @@
-{
-  "packageManager": "python",
-  "packageName": "calkit-python",
-  "uninstallInstructions": "Use your Python package manager (pip, conda, etc.) to uninstall the package calkit-python"
-}