calkit-python 0.35.4__py3-none-any.whl → 0.35.6__py3-none-any.whl

calkit/conda.py

@@ -9,6 +9,7 @@ import shutil
 import subprocess
 import warnings
 from pathlib import Path
+from typing import cast
 
 import toml
 from packaging.specifiers import SpecifierSet
@@ -123,7 +124,13 @@ def _editable_package_name_from_dir(dir_path: str) -> str:
     elif os.path.isfile(os.path.join(dir_path, "pyproject.toml")):
         # Read pyproject.toml to get the package name
         with open(os.path.join(dir_path, "pyproject.toml")) as f:
-            pyproject = toml.load(f)
+            try:
+                pyproject = toml.load(f)
+            except Exception as e:
+                raise type(e)(
+                    f"Failed to load pyproject.toml from {dir_path}; "
+                    "check that it is valid TOML"
+                ) from e
         if "project" in pyproject:
             if "name" in pyproject["project"]:
                 return pyproject["project"]["name"]
@@ -139,6 +146,7 @@ def _check_single(
     """
     # If this is an editable install it needs to be handled specially
     # It also needs to be relative to the env spec dir
+    editable = False
     if req.startswith("-e ") or req.startswith("--editable "):
         req = req.split(" ", 1)[1]
         if "#" in req:
@@ -147,6 +155,7 @@ def _check_single(
         # Create path relative to env spec dir
         req = os.path.join(env_spec_dir, req)
         req = _editable_package_name_from_dir(req)
+        editable = True
     # If this is a Git version, we can't check it
     # TODO: Clone Git repos to check?
     if "@git" in req:
@@ -182,7 +191,7 @@ def _check_single(
         # TODO: Check exact version only
         return True
     spec = SpecifierSet(req_spec)
-    return spec.contains(version)
+    return spec.contains(version, prereleases=editable)
 
 
 def _check_list(
@@ -193,6 +202,10 @@ def _check_list(
     if "::" in req:
         req = req.split("::", 1)[1]
     for installed in actual:
+        if not isinstance(installed, str):
+            raise ValueError(
+                f"Expected installed package to be a string, got {installed}"
+            )
         if _check_single(
             req, installed, env_spec_dir=env_spec_dir, conda=conda
         ):
@@ -200,6 +213,46 @@ def _check_list(
     return False
 
 
+def _split_env_dependencies(
+    dependencies: list[str | dict[str, str | list[str]]],
+) -> tuple[list[str], list[str]]:
+    """Split an environment dependency list into conda and pip deps.
+
+    Conda environment files commonly include both the plain ``"pip"`` package
+    marker and a nested ``{"pip": [...]}`` section. This helper normalizes the
+    latter so callers do not need to assume it is the final list entry or that
+    the pip section is already represented as a list.
+    """
+    conda_deps = []
+    pip_deps = []
+    for dep in dependencies:
+        if isinstance(dep, dict):
+            dep_pip = dep.get("pip", [])
+            if isinstance(dep_pip, str):
+                dep_pip = [dep_pip]
+            elif dep_pip is None:
+                dep_pip = []
+            pip_deps.extend(dep_pip)
+        else:
+            conda_deps.append(dep)
+    return conda_deps, pip_deps
+
+
+def _get_pip_dependency_list(
+    dependencies: list[str | dict[str, str | list[str]]],
+) -> list[str]:
+    """Return a mutable pip dependency list from an env dependency list."""
+    for dep in dependencies:
+        if isinstance(dep, dict) and "pip" in dep:
+            dep_pip = dep["pip"]
+            if isinstance(dep_pip, str):
+                dep["pip"] = [dep_pip]
+            elif dep_pip is None:
+                dep["pip"] = []
+            return cast(list[str], dep["pip"])
+    return []
+
+
 class EnvCheckResult(BaseModel):
     env_exists: bool | None = None
     env_needs_export: bool | None = None
@@ -393,18 +446,12 @@ def check_env(
                 ryaml.dump(env_check, f)
         # Determine if the env matches
         env_needs_rebuild = False
-        if isinstance(env_check["dependencies"][-1], dict):
-            existing_conda_deps = env_check["dependencies"][:-1]
-            existing_pip_deps = env_check["dependencies"][-1]["pip"]
-        else:
-            existing_conda_deps = env_check["dependencies"]
-            existing_pip_deps = []
-        if isinstance(env_spec["dependencies"][-1], dict):
-            required_conda_deps = env_spec["dependencies"][:-1]
-            required_pip_deps = env_spec["dependencies"][-1]["pip"]
-        else:
-            required_conda_deps = env_spec["dependencies"]
-            required_pip_deps = []
+        existing_conda_deps, existing_pip_deps = _split_env_dependencies(
+            env_check["dependencies"]
+        )
+        required_conda_deps, required_pip_deps = _split_env_dependencies(
+            env_spec["dependencies"]
+        )
         if relaxed:
             log_func("Running in relaxed mode; combining pip and conda deps")
             for dep in existing_pip_deps:
@@ -516,20 +563,23 @@ def check_env(
         # Note that this needs to be relative to the env lock directory,
         # since that's how pip will interpret it
         editable_pip_deps = {}
-        if isinstance(env_spec["dependencies"][-1], dict):
-            # Map editable install dir to package name we'd see in lock
-            required_pip_deps = env_spec["dependencies"][-1]["pip"]
-            for dep in required_pip_deps:
-                if dep.startswith("-e ") or dep.startswith("--editable "):
-                    dir_path = dep.split(" ", 1)[1]
-                    if "#" in dir_path:
-                        dir_path = dir_path.split("#", 1)[0]
-                    dir_path = dir_path.strip()
-                    dir_path = os.path.join(env_spec_dir, dir_path)
-                    pkg_name = _editable_package_name_from_dir(dir_path)
-                    editable_pip_deps[pkg_name] = dir_path
-        if isinstance(env_export["dependencies"][-1], dict):
-            export_pip_deps = env_export["dependencies"][-1]["pip"]
+        required_pip_deps = _get_pip_dependency_list(env_spec["dependencies"])
+        for dep in required_pip_deps:
+            if dep.startswith("-e ") or dep.startswith("--editable "):
+                dir_path = dep.split(" ", 1)[1]
+                if "#" in dir_path:
+                    dir_path = dir_path.split("#", 1)[0]
+                dir_path = dir_path.strip()
+                dir_path = os.path.join(env_spec_dir, dir_path)
+                pkg_name = _editable_package_name_from_dir(dir_path)
+                if verbose:
+                    log_func(
+                        f"Found editable pip dependency '{pkg_name}' "
+                        f"at '{dir_path}'"
+                    )
+                editable_pip_deps[pkg_name] = dir_path
+        export_pip_deps = _get_pip_dependency_list(env_export["dependencies"])
+        if export_pip_deps:
             for i, dep in enumerate(export_pip_deps):
                 dep_name = re.split("[=<>]+", dep, maxsplit=1)[0]
                 if dep_name in editable_pip_deps:

calkit/git.py

@@ -100,6 +100,30 @@ def _resolve_repo_and_ignore_path(
     return repo, rel_path
 
 
+def _get_matching_gitignore_details(
+    repo: git.Repo, path: str
+) -> tuple[Path | None, str | None]:
+    """Return the repo-local gitignore file and pattern matching ``path``."""
+    try:
+        check_ignore = repo.git.check_ignore("-v", "--", path)
+    except git.GitCommandError:
+        return None, None
+    line = check_ignore.splitlines()[0]
+    try:
+        source_info, _ = line.split("\t", 1)
+        source_path, _, pattern = source_info.rsplit(":", 2)
+    except ValueError:
+        return None, None
+    if not source_path.endswith(".gitignore"):
+        return None, pattern
+    gitignore_path = (Path(repo.working_dir) / source_path).resolve()
+    try:
+        gitignore_path.relative_to(Path(repo.working_dir).resolve())
+    except ValueError:
+        return None, pattern
+    return gitignore_path, pattern
+
+
 def ensure_path_is_ignored(
     repo: git.Repo, path: str | PathLike
 ) -> None | bool:
@@ -141,56 +165,132 @@ def ensure_path_is_not_ignored(
     # No-op if Git does not ignore this path.
     if not target_repo.ignored(target_path):
         return
-    gitignore_path = os.path.join(target_repo.working_dir, ".gitignore")
+    matching_gitignore_path, matched_pattern = _get_matching_gitignore_details(
+        target_repo, target_path
+    )
+    if matching_gitignore_path is not None:
+        gitignore_path = matching_gitignore_path.as_posix()
+        path_for_gitignore = (
+            (Path(target_repo.working_dir) / target_path)
+            .resolve()
+            .relative_to(matching_gitignore_path.parent.resolve())
+            .as_posix()
+        )
+    else:
+        gitignore_path = os.path.join(target_repo.working_dir, ".gitignore")
+        path_for_gitignore = target_path
     if not os.path.isfile(gitignore_path):
         with open(gitignore_path, "w") as f:
-            f.write(f"!{target_path}\n")
+            f.write(f"!{path_for_gitignore}\n")
         return True
     with open(gitignore_path) as f:
         gitignore_txt = f.read()
     lines = gitignore_txt.splitlines()
-    no_ignore_line = f"!{target_path}"
-    path_parts = Path(target_path).parts
+    direct_rule_variants = [path_for_gitignore, f"/{path_for_gitignore}"]
+    if matched_pattern is not None and matched_pattern.startswith("/"):
+        no_ignore_line = f"!/{path_for_gitignore}"
+    else:
+        no_ignore_line = f"!{path_for_gitignore}"
+    path_parts = Path(path_for_gitignore).parts
+
+    def ancestor_requires_recursive_unignore() -> bool:
+        """Return True if any ancestor-level ignore rule would block this path.
+
+        This includes explicit directory ignores (e.g. 'dir/' or '/dir/')
+        as well as ancestor-based glob patterns like 'dir/*' or '/dir/*',
+        i.e., any rule that would prevent reaching the nested path without
+        adding recursive unignore patterns.
+        """
+        for i in range(1, len(path_parts)):
+            ancestor = "/".join(path_parts[:i])
+            if (
+                ancestor in lines
+                or f"/{ancestor}" in lines
+                or f"{ancestor}/" in lines
+                or f"/{ancestor}/" in lines
+                or f"{ancestor}/*" in lines
+                or f"/{ancestor}/*" in lines
+            ):
+                return True
+        return False
+
     if len(path_parts) == 1:
         # Simple (non-nested) path: remove the direct ignore rule, or add a
-        # negation if the ignore comes from a glob or other pattern.
-        if target_path in lines:
-            lines.remove(target_path)
-        elif no_ignore_line not in lines:
+        # negation if the ignore comes from a glob or other pattern
+        direct_rule = next(
+            (rule for rule in direct_rule_variants if rule in lines), None
+        )
+        if direct_rule is not None:
+            lines.remove(direct_rule)
+        else:
+            # Remove any stale negation and re-append at the end so it takes
+            # precedence over any later re-ignore rule
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
             lines.append(no_ignore_line)
     else:
-        # Nested path: Git will not traverse into a directory excluded by a
-        # "dir/" pattern, so a bare "!dir/sub/file" negation has no effect.
-        # We need to:
-        #   1. Convert any "ancestor/" (or "ancestor") exclude to "ancestor/*"
-        #      so that git traverses the directory while still ignoring its
-        #      direct children by default.
-        #   2. Add "!ancestor/" un-ignore rules for each intermediate directory
-        #      so git recurses into them.
-        #   3. Add "ancestor/*" re-ignore rules so that only explicitly
-        #      un-ignored files within each intermediate directory are tracked.
-        #   4. Add the final "!target_path" negation for the specific file.
-        if target_path in lines:
-            lines.remove(target_path)
-        for i in range(1, len(path_parts)):
-            ancestor = "/".join(path_parts[:i])
-            reignore_glob = f"{ancestor}/*"
-            # Convert a directory-exclude pattern to a glob so git traverses it
-            if f"{ancestor}/" in lines:
-                idx = lines.index(f"{ancestor}/")
-                lines[idx] = reignore_glob
-            elif ancestor in lines:
-                idx = lines.index(ancestor)
-                lines[idx] = reignore_glob
-            # Un-ignore this intermediate directory so git recurses into it
-            no_ignore_dir = f"!{ancestor}/"
-            if no_ignore_dir not in lines:
-                lines.append(no_ignore_dir)
-            # Re-ignore everything inside this intermediate directory so that
-            # only explicitly un-ignored entries are tracked
-            if reignore_glob not in lines:
-                lines.append(reignore_glob)
-        if no_ignore_line not in lines:
+        # Nested path: only apply recursive un-ignore rules when an ancestor
+        # directory is explicitly ignored
+        # Otherwise, remove a direct ignore
+        # rule for this path or add a simple negation if needed
+        removed_direct_rule = False
+        direct_rule = next(
+            (rule for rule in direct_rule_variants if rule in lines), None
+        )
+        if direct_rule is not None:
+            lines.remove(direct_rule)
+            removed_direct_rule = True
+        if ancestor_requires_recursive_unignore():
+            # Git will not traverse into a directory excluded by a "dir/"
+            # pattern, so a bare "!dir/sub/file" negation has no effect.
+            # We need to:
+            #   1. Convert any "ancestor/" (or "ancestor") exclude to
+            #      "ancestor/*" so git traverses the directory while still
+            #      ignoring direct children by default.
+            #   2. Add "!ancestor/" rules for intermediate directories.
+            #   3. Add "ancestor/*" re-ignore rules for each intermediate dir.
+            #   4. Add "!target_path" for the specific file.
+            for i in range(1, len(path_parts)):
+                ancestor = "/".join(path_parts[:i])
+                reignore_glob = f"{ancestor}/*"
+                if f"{ancestor}/" in lines:
+                    idx = lines.index(f"{ancestor}/")
+                    lines[idx] = reignore_glob
+                elif f"/{ancestor}/" in lines:
+                    idx = lines.index(f"/{ancestor}/")
+                    lines[idx] = f"/{ancestor}/*"
+                elif ancestor in lines:
+                    idx = lines.index(ancestor)
+                    lines[idx] = reignore_glob
+                elif f"/{ancestor}" in lines:
+                    idx = lines.index(f"/{ancestor}")
+                    lines[idx] = f"/{ancestor}/*"
+                no_ignore_dir = f"!{ancestor}/"
+                anchored_no_ignore_dir = f"!/{ancestor}/"
+                # The first ancestor does not need an explicit un-ignore once
+                # converted to "ancestor/*". Deeper ancestors do.
+                if i > 1:
+                    # Remove stale entry and re-append so it takes precedence
+                    if no_ignore_dir in lines:
+                        lines.remove(no_ignore_dir)
+                    elif anchored_no_ignore_dir in lines:
+                        lines.remove(anchored_no_ignore_dir)
+                    lines.append(no_ignore_dir)
+                if (
+                    reignore_glob not in lines
+                    and f"/{ancestor}/*" not in lines
+                ):
+                    lines.append(reignore_glob)
+            # Remove stale negation and re-append at the end so it takes
+            # precedence over any later re-ignore rule
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
+            lines.append(no_ignore_line)
+        elif not removed_direct_rule:
+            # The path may be ignored by a non-directory pattern (e.g., glob);
+            # remove stale negation and append at end so it takes precedence
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
             lines.append(no_ignore_line)
     with open(gitignore_path, "w") as f:
         f.write(os.linesep.join(lines))

calkit/overleaf.py

@@ -317,6 +317,32 @@ class OverleafSyncPaths:
             - self.files_in_overleaf_last_sync
         )
 
+    @cached_property
+    def dvc_files(self) -> set[str]:
+        """Files tracked by DVC within the Overleaf project folder.
+
+        These paths are relative to the project directory (i.e., relative to
+        the Overleaf repo root). Files tracked by DVC may not exist on disk if
+        they haven't been pulled, but should still be kept on Overleaf rather
+        than deleted.
+        """
+        try:
+            import calkit.dvc
+
+            dvc_paths = calkit.dvc.list_paths(
+                wdir=str(self.main_repo.working_dir), recursive=True
+            )
+        except Exception as e:
+            warnings.warn(f"Could not list DVC files: {e}")
+            return set()
+        prefix = Path(self.path_in_project).as_posix().rstrip("/") + "/"
+        result = set()
+        for p in dvc_paths:
+            p_posix = Path(p).as_posix()
+            if p_posix.startswith(prefix):
+                result.add(p_posix[len(prefix) :])
+        return result
+
     @cached_property
     def files_to_keep_on_overleaf(self) -> set[str]:
         """Files that should be preserved on Overleaf.
@@ -324,9 +350,14 @@ class OverleafSyncPaths:
         This includes:
         1. All files being copied from local
         2. Any files newly added on Overleaf since last sync
+        3. Any files tracked by DVC within the project path (these may not
+           exist on disk if not pulled, but should not be deleted from
+           Overleaf)
         """
         return (
-            set(self.files_to_copy_to_overleaf) | self.newly_added_on_overleaf
+            set(self.files_to_copy_to_overleaf)
+            | self.newly_added_on_overleaf
+            | self.dvc_files
         )
 
     @cached_property

calkit/pipeline.py

@@ -117,6 +117,20 @@ def to_dvc(
     except Exception as e:
         raise ValueError(f"Pipeline is not defined properly: {e}")
     dvc_stages = {}
+    # Read existing dvc.yaml now so we can clean up stale .gitignore entries
+    # when stage outputs are renamed or removed
+    if write:
+        dvc_yaml_path = os.path.join(wdir, "dvc.yaml") if wdir else "dvc.yaml"
+        if os.path.isfile(dvc_yaml_path):
+            with open(dvc_yaml_path) as f:
+                existing_dvc_yaml = calkit.ryaml.load(f)
+        else:
+            existing_dvc_yaml = {}
+        if existing_dvc_yaml is None:
+            existing_dvc_yaml = {}
+        existing_dvc_stages = existing_dvc_yaml.get("stages", {})
+    else:
+        existing_dvc_stages = {}
     # First, gather up any env lock paths we might need for DVC deps
     used_envs = set(
         [stage.inner_environment for stage in pipeline.stages.values()]
@@ -227,6 +241,17 @@ def to_dvc(
                 outputs += stage.notebook_outputs
             elif stage.kind == "sbatch":
                 outputs.append(stage.log_output)
+            # Build the set of current DVC output paths so we can detect stale
+            # .gitignore entries from the previous version of the stage,
+            # including synthesized outputs like LaTeX PDFs
+            current_out_paths = set(calkit.dvc.out_paths_from_stage(dvc_stage))
+            # If this stage already existed, un-ignore any outputs that have
+            # been renamed or removed so .gitignore does not accumulate stale
+            # entries (e.g., after a capitalization change in the path)
+            old_stage = existing_dvc_stages.get(stage_name, {})
+            for old_path in calkit.dvc.out_paths_from_stage(old_stage):
+                if old_path not in current_out_paths:
+                    calkit.git.ensure_path_is_not_ignored(repo, path=old_path)
             # Deal with any gitignore changes necessary
             for out in outputs:
                 if isinstance(out, PathOutput) and out.storage is None:
@@ -268,14 +293,8 @@ def to_dvc(
                         else:
                             dvc_stages[stage_name]["deps"].append(out)
     if write:
-        if os.path.isfile("dvc.yaml"):
-            with open("dvc.yaml") as f:
-                dvc_yaml = calkit.ryaml.load(f)
-        else:
-            dvc_yaml = {}
-        if dvc_yaml is None:
-            dvc_yaml = {}
-        existing_stages = dvc_yaml.get("stages", {})
+        dvc_yaml = existing_dvc_yaml
+        existing_stages = existing_dvc_stages
         for stage_name, stage in existing_stages.items():
             # Skip private stages (ones whose names start with an underscore)
             # and stages that are automatically generated

calkit/tests/cli/test_overleaf.py

@@ -181,6 +181,44 @@ def test_overleaf(tmp_dir):
     subprocess.run(["calkit", "overleaf", "sync", "--verbose"], check=True)
     print("Overleaf Git show after adding fig2 back:", ol_repo.git.show())
     assert "ol-project/figs/fig2.txt" in ls_files(repo)
+    # Test that if a file is deleted from Git but added to DVC, it is not
+    # deleted from Overleaf (the file still logically exists in the DVC repo)
+    with open(
+        os.path.join(repo.working_dir, "ol-project", "figs", "fig3.txt"), "w"
+    ) as f:
+        f.write("Fig3 created in main repo")
+    repo.git.add("ol-project/figs/fig3.txt")
+    repo.git.commit(["-m", "Add figure 3"])
+    assert "ol-project/figs/fig3.txt" in ls_files(repo)
+    subprocess.run(["calkit", "overleaf", "sync", "--verbose"], check=True)
+    ol_repo_git_show = ol_repo.git.show()
+    assert "diff --git a/figs/fig3.txt b/figs/fig3.txt" in ol_repo_git_show
+    # Now move from Git to DVC: first remove from Git index (keeping file on
+    # disk), then add to DVC so it gets moved to DVC cache
+    repo.git.rm(["--cached", "ol-project/figs/fig3.txt"])
+    subprocess.run(
+        ["dvc", "add", "ol-project/figs/fig3.txt"],
+        check=True,
+        cwd=repo.working_dir,
+    )
+    # Commit the DVC pointer file (fig3.txt is now tracked by DVC, not Git)
+    repo.git.add("ol-project/figs/fig3.txt.dvc", "ol-project/figs/.gitignore")
+    repo.git.commit(["-m", "Move figure 3 from git to DVC"])
+    assert "ol-project/figs/fig3.txt" not in ls_files(repo)
+    # Also remove the local file to simulate the file not being pulled from
+    # DVC (i.e., only the DVC pointer exists locally, not the actual file)
+    fig3_path = os.path.join(
+        repo.working_dir, "ol-project", "figs", "fig3.txt"
+    )
+    if os.path.exists(fig3_path):
+        os.remove(fig3_path)
+    assert not os.path.exists(fig3_path)
+    subprocess.run(["calkit", "overleaf", "sync", "--verbose"], check=True)
+    ol_repo_git_show = ol_repo.git.show()
+    print("Git show in OL repo after moving fig3 to DVC:\n", ol_repo_git_show)
+    # The file should not have been deleted from Overleaf
+    assert "deleted file mode" not in ol_repo_git_show
+    assert "--- a/figs/fig3.txt" not in ol_repo_git_show
 
 
 def test_extract_title_from_tex(tmp_dir):

calkit/tests/test_conda.py

@@ -1,12 +1,19 @@
 """Tests for the ``conda`` module."""
 
 import os
+import shutil
 import subprocess
 
 import pytest
 
 import calkit
-from calkit.conda import _check_list, _check_single, check_env
+from calkit.conda import (
+    _check_list,
+    _check_single,
+    _get_pip_dependency_list,
+    _split_env_dependencies,
+    check_env,
+)
 
 ENV_NAME = "main"
 
@@ -37,6 +44,25 @@ def test_check_list():
     assert not _check_list("pandas", installed, env_spec_dir=".", conda=False)
 
 
+def test_split_env_dependencies():
+    dependencies = [
+        "python=3.12",
+        "pip",
+        "numpy=2",
+        {"pip": ["sqlalchemy==2.0.39"]},
+    ]
+    conda_deps, pip_deps = _split_env_dependencies(dependencies)
+    assert conda_deps == ["python=3.12", "pip", "numpy=2"]
+    assert pip_deps == ["sqlalchemy==2.0.39"]
+
+
+def test_get_pip_dependency_list():
+    dependencies = ["python=3.12", "pip", {"pip": "sqlalchemy==2.0.39"}]
+    pip_deps = _get_pip_dependency_list(dependencies)
+    assert pip_deps == ["sqlalchemy==2.0.39"]
+    assert dependencies[-1]["pip"] == ["sqlalchemy==2.0.39"]
+
+
 def delete_env(name: str):
     subprocess.check_call(["conda", "env", "remove", "-y", "-n", name])
 
@@ -262,7 +288,7 @@ def test_check_prefix_env(tmp_dir, conda_env_prefix):
     )
 
 
-def test_check_editable(tmp_dir, conda_env_name):
+def test_check_env_editable(tmp_dir, conda_env_name):
     subprocess.check_call(["calkit", "init"])
     # Create a dummy package named 'src' to install in editable mode
     os.makedirs("src", exist_ok=True)
@@ -306,6 +332,98 @@ setup(
         lock = calkit.ryaml.load(f)
     pip_deps = lock["dependencies"][-1]["pip"]
     assert "-e ." in pip_deps
+    # Now let's make sure we get proper output if the editable package is
+    # has an invalid pyproject.toml
+    os.remove("setup.py")
+    shutil.rmtree("src.egg-info")
+    toml_txt = """[build-system]
+requires = ["setuptools>=61.0.0", "wheel", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "src-thing"
+dynamic = ["version"]
+authors = [
+  {name = "Someone"}
+]
+description = "Test"
+
+dependencies = [
+    "numpy>=1.21",
+    "scipy>=1.7",
+    "pandas>=1.5",
+    "matplotlib>=3.5",
+    "h5netcdf>=0.12",
+    "h5py>=3.0",
+    "xarray>=2023.0",
+    "streamlit>=1.0"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["src-thing"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"src-thing" = [] # Explicitly state no package data
+
+[tool.setuptools_scm]
+local_scheme = "no-local-version"
+fallback_version = "0+unknown"
+"""
+    with open("pyproject.toml", "w") as f:
+        f.write(toml_txt)
+    with pytest.raises(Exception, match="Failed to load pyproject.toml"):
+        res = check_env()
+    # Fix it and make sure it runs with relaxed mode
+    toml_txt = """[build-system]
+requires = ["setuptools>=61.0.0", "wheel", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "src-thing"
+dynamic = ["version"]
+authors = [
+  {name = "Someone"}
+]
+description = "Test"
+
+dependencies = []
+
+[tool.setuptools]
+packages = ["src"]
+
+[tool.setuptools_scm]
+local_scheme = "no-local-version"
+fallback_version = "0+unknown"
+"""
+    with open("pyproject.toml", "w") as f:
+        f.write(toml_txt)
+    res = check_env(relaxed=True)
+    assert res.env_exists
+    assert res.env_needs_rebuild
+    assert res.env_needs_export
+    # Make sure we can import the editable package
+    os.makedirs("subdir")
+    subprocess.check_call(
+        [
+            "conda",
+            "run",
+            "-n",
+            conda_env_name,
+            "python",
+            "-c",
+            "import src; print('src file:', src.__file__);",
+        ],
+        cwd="subdir",
+    )
+    # Check again and make sure we don't need a rebuild since the editable
+    # package is still valid
+    res = check_env(relaxed=True)
+    assert res.env_exists
+    assert not res.env_needs_rebuild
 
 
 def test_find_conda_exe():

calkit/tests/test_git.py

@@ -105,7 +105,7 @@ def test_ensure_path_is_not_ignored_nested(tmp_dir):
 
     When a parent directory is excluded with a trailing slash (e.g.,
     ``results/``), git will not traverse into it, so a simple negation like
-    ``!results/StageName/end.json`` has no effect.  The fix converts the
+    ``!results/StageName/end.json`` has no effect. The fix converts the
     directory exclude to a glob pattern and adds intermediate un-ignore rules.
     """
     repo = git.Repo.init()
@@ -124,15 +124,13 @@ def test_ensure_path_is_not_ignored_nested(tmp_dir):
     assert result is True
     with open(".gitignore") as f:
         lines = f.read().splitlines()
-    # The plain directory exclude should be replaced with a glob
-    assert "results/" not in lines
-    assert "results/*" in lines
-    # Intermediate directory must be un-ignored so git traverses into it
-    assert "!results/StageName/" in lines
-    # The intermediate directory's other contents must be re-ignored
-    assert "results/StageName/*" in lines
-    # The specific file must be explicitly un-ignored
-    assert "!results/StageName/end.json" in lines
+    # Keep the rules minimal while preserving the required behavior
+    assert lines == [
+        "results/*",
+        "!results/StageName/",
+        "results/StageName/*",
+        "!results/StageName/end.json",
+    ]
     # Verify git no longer considers the target file as ignored
     assert not repo.ignored("results/StageName/end.json")
     # Other files in results/ must still be ignored
@@ -148,3 +146,54 @@ def test_ensure_path_is_not_ignored_nested(tmp_dir):
         repo, path="results/StageName/end.json"
     )
     assert result2 is None
+
+
+def test_ensure_path_is_not_ignored_nested_direct_path_rule(tmp_dir):
+    """Unignoring a directly ignored nested path should only remove that
+    rule.
+    """
+    repo = git.Repo.init()
+    target = "pubs/applied-ocean-research-model/references.bib"
+    sibling = "pubs/applied-ocean-research-model/paper.pdf"
+    with open(".gitignore", "w") as f:
+        f.write(f"{target}\n")
+    os.makedirs("pubs/applied-ocean-research-model", exist_ok=True)
+    with open(target, "w") as f:
+        f.write("@article{test}\n")
+    with open(sibling, "w") as f:
+        f.write("pdf\n")
+    # Only the direct target path should be ignored initially
+    assert repo.ignored(target)
+    assert not repo.ignored(sibling)
+    result = calkit.git.ensure_path_is_not_ignored(repo, path=target)
+    assert result is True
+    with open(".gitignore") as f:
+        lines = f.read().splitlines()
+    # Remove only the direct rule, with no recursive ancestor entries
+    assert target not in lines
+    assert f"!{target}" not in lines
+    assert "!pubs/" not in lines
+    assert "pubs/*" not in lines
+    assert "!pubs/applied-ocean-research-model/" not in lines
+    assert "pubs/applied-ocean-research-model/*" not in lines
+    assert not repo.ignored(target)
+    assert not repo.ignored(sibling)
+
+
+def test_ensure_path_is_not_ignored_nested_gitignore_direct_path_rule(tmp_dir):
+    repo = git.Repo.init()
+    os.makedirs("paper", exist_ok=True)
+    target = "paper/main.pdf"
+    with open("paper/.gitignore", "w") as f:
+        f.write("/main.pdf\n")
+    with open(target, "w") as f:
+        f.write("pdf\n")
+    assert repo.ignored(target)
+    result = calkit.git.ensure_path_is_not_ignored(repo, path=target)
+    assert result is True
+    with open("paper/.gitignore") as f:
+        lines = f.read().splitlines()
+    assert "/main.pdf" not in lines
+    assert "!/main.pdf" not in lines
+    assert not os.path.exists(".gitignore")
+    assert not repo.ignored(target)

calkit/tests/test_pipeline.py

@@ -1,9 +1,12 @@
 """Tests for ``calkit.pipeline``."""
 
+import os
 import subprocess
 
+import git
 import pytest
 
+import calkit
 import calkit.pipeline
 from calkit.environments import get_env_lock_fpath
 from calkit.pipeline import stages_are_similar
@@ -648,3 +651,100 @@ def test_shell_script_stage_allows_non_composite_slurm_env():
         "calkit slurm batch --name run --environment mycluster "
         "-- scripts/run.sh a b"
     )
+
+
+def test_gitignore_updated_when_stage_output_renamed(tmp_dir):
+    """When a stage output path is renamed, stale .gitignore entries are
+    replaced.
+
+    Use the .gitignore contents for verification because case-only renames can
+    still appear ignored on case-insensitive filesystems like the default macOS
+    setup.
+    """
+    subprocess.check_call(["calkit", "init"])
+    # Stage 1: initial calkit.yaml with output 'b_sparsity_plot.pdf' stored in DVC
+    ck_info = {
+        "pipeline": {
+            "stages": {
+                "plot": {
+                    "kind": "command",
+                    "environment": "_system",
+                    "command": "touch b_sparsity_plot.pdf",
+                    "outputs": [
+                        {
+                            "path": "b_sparsity_plot.pdf",
+                            "storage": "dvc",
+                        }
+                    ],
+                }
+            }
+        }
+    }
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
+    subprocess.check_call(["calkit", "run"])
+    # Verify DVC has added the old output path to .gitignore
+    repo = git.Repo(".")
+    assert repo.ignored("b_sparsity_plot.pdf")
+    with open(".gitignore") as f:
+        lines = f.read().splitlines()
+    assert "/b_sparsity_plot.pdf" in lines
+    # Stage 2: rename output (capitalization change) to 'B_sparsity_plot.pdf'
+    ck_info["pipeline"]["stages"]["plot"]["command"] = (
+        "touch B_sparsity_plot.pdf"
+    )
+    ck_info["pipeline"]["stages"]["plot"]["outputs"] = [
+        {"path": "B_sparsity_plot.pdf", "storage": "dvc"}
+    ]
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
+    subprocess.check_call(["calkit", "run"])
+    with open(".gitignore") as f:
+        lines = f.read().splitlines()
+    assert "/b_sparsity_plot.pdf" not in lines
+    assert "/B_sparsity_plot.pdf" in lines
+    assert repo.ignored("B_sparsity_plot.pdf")
+
+
+def test_gitignore_not_unignored_latex_pdf_output(tmp_dir):
+    repo = git.Repo.init()
+    subprocess.check_call(["calkit", "init"])
+    os.makedirs("paper", exist_ok=True)
+    with open("paper/.gitignore", "w") as f:
+        f.write("/main.pdf\n")
+    ck_info = {
+        "environments": {
+            "tex": {
+                "kind": "conda",
+                "path": "environment.yaml",
+            }
+        },
+        "pipeline": {
+            "stages": {
+                "build-paper": {
+                    "kind": "latex",
+                    "environment": "tex",
+                    "target_path": "paper/main.tex",
+                    "force": True,
+                    "inputs": [
+                        "paper/references.bib",
+                        "paper/aasjournal.bst",
+                        "paper/aastex631.cls",
+                        "paper/results.tex",
+                        "paper/diagrams",
+                        "paper/figures",
+                    ],
+                }
+            }
+        },
+    }
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
+    calkit.pipeline.to_dvc(ck_info=ck_info, write=True)
+    assert not os.path.exists(".gitignore")
+    assert repo.ignored("paper/main.pdf")
+    calkit.pipeline.to_dvc(ck_info=ck_info, write=True)
+    assert not os.path.exists(".gitignore")
+    with open("paper/.gitignore") as f:
+        assert f.read().splitlines() == ["/main.pdf"]
+    assert repo.ignored("paper/main.pdf")

{calkit_python-0.35.4.dist-info → calkit_python-0.35.6.dist-info}/METADATA

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

{calkit_python-0.35.4.dist-info → calkit_python-0.35.6.dist-info}/RECORD

@@ -3,7 +3,7 @@ calkit/__main__.py,sha256=whqS7I7q_c9004emvKptZ9B9OVn-jgr5kaLaCFKmwa0,112
 calkit/calc.py,sha256=ucTWBssZhDDc585q2R6l5Zb-924vxwGID4KX7K-eUPA,7563
 calkit/check.py,sha256=wL7xMoyX8yT8lGuy0KBMObq_fjaiCdqC5dhJcX6JjL4,9075
 calkit/cloud.py,sha256=Gc9l8GlW3g6DKKUuvFtFxrkbVq3QPukYXXwWziiw2sU,3277
-calkit/conda.py,sha256=kwmeLAKUyhhJHHZSZlQUCvLf98f0dA4jYZ9Nu0OTjkQ,20959
+calkit/conda.py,sha256=ZSF9bDiC73WMeZr5uQot4uFIUXlF79vYmyDIkZpqWkk,22498
 calkit/config.py,sha256=_LebIjIRHlWbmFBa5vibS2VZtqzf0bmDA0jPbG3Aqm8,7546
 calkit/core.py,sha256=a9bG3fDSiGH2GX4y97WAUagvDSIKCNIOLQYm9hwnPSc,21320
 calkit/datasets.py,sha256=9lOlOreey2aJGMw6MiV9MDzSHp-fYkCf1k1AZbWTdQE,2235
@@ -12,7 +12,7 @@ calkit/docker.py,sha256=EEcgbXjs-1ttixAZ-G-hmDlvnqSxYbIZmbzeAza37TI,15706
 calkit/dvc.py,sha256=aLQKB14Fg0L-Lxr1Rz0WE8hQ72MF8pALNlBP6-4wg3E,16999
 calkit/environments.py,sha256=Y5GufgcPsEAz_NfZ-DAC5mxRUiJ1G6h48vG956Gd7Q0,63270
 calkit/fs.py,sha256=T7AwoNGfZpGnUsksUXU31_98BDfqwboFvF2ho7N3ATI,39741
-calkit/git.py,sha256=0QxC-ihDF6h8Prx4tmnu-9uOzS7dKT1OvybgMwzD6Bk,7167
+calkit/git.py,sha256=MDm0ARxg8eqVzGcYzEHv7l0pvBnhgTgJj9c3cGEX-tM,11327
 calkit/github.py,sha256=8_yZ0ej8TKM4qk8iPeGq47R1I4MHdSoJ_Zpr1gRwNEM,1701
 calkit/gui.py,sha256=2UCrMyosc5v4CLlDcHO7oDwW9eLn5_WbNaLaG5bjMTc,23
 calkit/invenio.py,sha256=dU1Mw6G9R0LSNp4vKnJU3P7RcPXrteYV7J5ThBMvJ20,3468
@@ -24,8 +24,8 @@ calkit/matlab.py,sha256=dthWLDhtpE10qHkJy80h0QzKlbUR1FxFwPTth4-Vs0s,26060
 calkit/notebooks.py,sha256=7OISqRi1sOtPO5xFoi41zKxOu0kNIvp8U5WDI2PZcYw,8800
 calkit/office.py,sha256=mZqCxkIsmWthBAeJZ5SiGe21fn5zD2zXsy1E6nQIpWE,1291
 calkit/ops.py,sha256=lLlZAFeplU8uLeMavr99d__Iof-YYwKijus74WfLipk,854
-calkit/overleaf.py,sha256=Qul7ge0BYp9TuspcR6M4JMAKZQtHI11f6-sVyPyf8x0,22365
-calkit/pipeline.py,sha256=H_YHNFpdj7JJjpMYurvX3d1CIqG7nyqRGcHH06O7Odg,11813
+calkit/overleaf.py,sha256=0LcVvMmYu8sfwEGG1GTPedNuk7hOIQTr6Hwv4u9S5Xs,23540
+calkit/pipeline.py,sha256=HxfdVM4j9rwpYtnU4X5sVR_ZrD6V1rAVvz6l-teHjMI,13000
 calkit/releases.py,sha256=gIjSVhrFpNdNXUAGqDt4C-85cc06wAESJUbCGdau0uo,5598
 calkit/server.py,sha256=sKJpSzfBnSqipQ9MJW70AUZe5Hosnv7E9UwWDUTs2Vc,21700
 calkit/cli/__init__.py,sha256=WE2C1rXrwby5mEs8NGbGLwt4K-4uO7PHUoYS4GkxBKo,92
@@ -66,21 +66,21 @@ calkit/templates/latex/jfm/upmath.sty,sha256=9nzNixqQd18zVrv0vLBjGjfnc8L19tP_m0b
 calkit/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/test_calc.py,sha256=h-wOUIRqfyi06LTzhY_rS-a1xChZTkmwdEfBybMUM7E,2033
 calkit/tests/test_check.py,sha256=ngRZq1_dSRQoa0oSjcx_QpR94omG9Bpas_h0wqjwrK0,1475
-calkit/tests/test_conda.py,sha256=spb6mVulmZCVhhjgNSCbibNkbFWEaBB7ZgrkVZNl3Wk,8499
+calkit/tests/test_conda.py,sha256=z-v3GGrFkog7dpvpKwic7MBUHyVoXz1YChKtJ3LeGCE,11440
 calkit/tests/test_core.py,sha256=kcwbDibBR9b-aBKG_ALvqnpZGuJXF9_T7cj9IQ39Xsw,3873
 calkit/tests/test_detect.py,sha256=GT08cpfFIeI133iiSz-i4qAQy4VA9GKNXjegDuCvQu8,32899
 calkit/tests/test_docker.py,sha256=27d0K1GOWiCNv_5TkZSob6EaC0EtQ9DSBIDfkEAEzGk,2077
 calkit/tests/test_dvc.py,sha256=so6db2K_amSmA1n3fVOsr0gzxEBoExC2HedJgLPvfi4,2570
 calkit/tests/test_environments.py,sha256=MWoWu9zCusXvhQdVdlsBcRMeSqBEcq5-Hy_H49ygtLA,25029
 calkit/tests/test_fs.py,sha256=i6VfBime4ay6e9jpbbF2CekfDdPufdlZUZWIb4DdP4w,4928
-calkit/tests/test_git.py,sha256=ced9NNBxKNMwGhir-G1d_MAK1-UVptAFzPFMtVzGb6w,5346
+calkit/tests/test_git.py,sha256=oUg02LpMZF6sTr864iGXH8AVes2NCCrV_H9m7RtQJaQ,7053
 calkit/tests/test_invenio.py,sha256=RpiwgcYu0yIpl2gOMTkAQNsSStYPZGa2ReFnA4KCt94,296
 calkit/tests/test_julia.py,sha256=V_q-6wVuIJ-Qj1xkstdZliTqKh0qTeIFjYx4sYETeqA,1234
 calkit/tests/test_jupyter.py,sha256=YTL6zI740UM2KUjskSipzvSKxsyQ8rVPFQIX5cb2tMQ,114
 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=vPNIydIIhuHPf9d_jbJT6EK3vYyHTuoT44tOJGyVHhM,22057
+calkit/tests/test_pipeline.py,sha256=P_q0cJoaUnZZK2pfamuHqsMVEeEGufk-GS4tjcYGSDE,25540
 calkit/tests/test_releases.py,sha256=zsy3JMg69uZP5aNPO_TtaP-iPmFu0mDQ7bdruDd1jKU,1478
 calkit/tests/test_templates.py,sha256=RN4RIgmuFlmFYQFgfJUYS-KaLmie8fnWzmfg5Ay1egk,430
 calkit/tests/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -91,7 +91,7 @@ calkit/tests/cli/test_latex.py,sha256=FOiLlG7PMzQk8gGc9BeqdSJ7F0HoPbqZZ0F5sqvSI7
 calkit/tests/cli/test_list.py,sha256=h7p5jt8B-7x-GYWjggB6YyrOHXXlywnnebgvEcLKmvs,1024
 calkit/tests/cli/test_new.py,sha256=OqeSuayDNrUkNJ7TJYrE3-O47TCrPesU-j0aSmGIOM4,18044
 calkit/tests/cli/test_notebooks.py,sha256=fVE4J6qTxJvALQeyaBTRxX_aEmMdszp2YUczrAdan3M,6776
-calkit/tests/cli/test_overleaf.py,sha256=Qn5fGt3xY1cMgtpU5XY5nhKtjqFESCM3i1sz7yjJJqI,8606
+calkit/tests/cli/test_overleaf.py,sha256=FPzz4nlEJpMt0NEwr-3cTYr3uhOzWT0IIwjwyrqROt8,10562
 calkit/tests/cli/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/cli/main/test_core.py,sha256=JzwfYZAY3LhpE_b6x04zrd3eGoys9bCrcL4GZQDHtSQ,25102
 calkit/tests/cli/main/test_xr.py,sha256=UhtzJEjRiHgE_p_tdjGyYS7I9yy_Ubs2W2lSmLPpBLU,22386
@@ -100,23 +100,23 @@ calkit/tests/jupyterlab/test_routes.py,sha256=TEEyoHiKnzzKOkQsJcMPKdqpKFQ25yBCvV
 calkit/tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/models/test_iteration.py,sha256=vjuDKwyYQAV4w1qF9VJWQEHksq3KRd6gtT39_a-RhnI,644
 calkit/tests/models/test_pipeline.py,sha256=yefZIG0oHO3xBSwEc3BLx6JOuqKr8GwZvlx1eMcr6SI,9429
-calkit_python-0.35.4.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/package.json,sha256=XuEPczy1Q_u1I6pu8lF8k01SydcO3-qc8p9W-XcXtiI,6343
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=v3acRho7E8H-L_0D7qH1KwaXdYLhqsDBSOlZ0NtBkNY,6201
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/909.651be47ca47390b78a92.js,sha256=ZRvkfKRzkLeKkhSUg3qX-df9A80XTd0F0CPcXMfmb-Q,114572
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.c091821b3d7f2d287a67.js,sha256=wJGCGz1_LSh6Z9lt5VFlfXs92iKQNlLUJshrAQl4ziw,8737
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
-calkit_python-0.35.4.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
-calkit_python-0.35.4.dist-info/METADATA,sha256=5J23dVB_lDNIdhzAj4p9rVv_Z8tn_wCHItAiLRTZBiE,8777
-calkit_python-0.35.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-calkit_python-0.35.4.dist-info/entry_points.txt,sha256=59JWYjwz2N3yBOk_9vYUzsMsSs-It1LW8gYE8NsTUJ4,113
-calkit_python-0.35.4.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
-calkit_python-0.35.4.dist-info/RECORD,,
+calkit_python-0.35.6.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/package.json,sha256=XuEPczy1Q_u1I6pu8lF8k01SydcO3-qc8p9W-XcXtiI,6343
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=v3acRho7E8H-L_0D7qH1KwaXdYLhqsDBSOlZ0NtBkNY,6201
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/909.651be47ca47390b78a92.js,sha256=ZRvkfKRzkLeKkhSUg3qX-df9A80XTd0F0CPcXMfmb-Q,114572
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.c091821b3d7f2d287a67.js,sha256=wJGCGz1_LSh6Z9lt5VFlfXs92iKQNlLUJshrAQl4ziw,8737
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
+calkit_python-0.35.6.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
+calkit_python-0.35.6.dist-info/METADATA,sha256=JZp7hloviRQ4KKKqaP5gmU8KYx9MXdD-bwLbnmXX_zM,8777
+calkit_python-0.35.6.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+calkit_python-0.35.6.dist-info/entry_points.txt,sha256=59JWYjwz2N3yBOk_9vYUzsMsSs-It1LW8gYE8NsTUJ4,113
+calkit_python-0.35.6.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
+calkit_python-0.35.6.dist-info/RECORD,,