calkit-python 0.48.0__py3-none-any.whl → 0.48.1__py3-none-any.whl

calkit/cli/latex.py

@@ -2121,6 +2121,15 @@ def to_docx(
         )
         maths = calkit.docx.latex_to_omml([p[2] for p in pieces], preamble)
         converted = dict(zip([(id(p[0]), p[1]) for p in pieces], maths))
+        # What each link within the document shows, e.g., an equation's
+        # number, by the bookmark it goes to
+        link_text = {
+            h.get(calkit.docx._tag(calkit.docx.W, "anchor"), ""): "".join(
+                t.text or ""
+                for t in h.iter(calkit.docx._tag(calkit.docx.W, "t"))
+            ).strip()
+            for h in doc.doc.iter(calkit.docx._tag(calkit.docx.W, "hyperlink"))
+        }
         bid = 100000
         last_number: str | None = None
         for group, gap, numbers, lead, before_para, after_para in plans:
@@ -2156,7 +2165,30 @@ def to_docx(
             ):
                 if para.element is not None and para.element in unit.iter(w_p):
                     doc.move_out(para.element, unit, after=end)
-            doc.insert_equations(gap[0], rows, bid)
+            # The conversion's own bookmarks on the equations, which
+            # references in the text link to, wholly inside what's replaced,
+            # each on the row whose number the references show
+            w_name = calkit.docx._tag(calkit.docx.W, "name")
+            w_id = calkit.docx._tag(calkit.docx.W, "id")
+            ended = {
+                e.get(w_id)
+                for el in gap
+                for e in el.iter(
+                    calkit.docx._tag(calkit.docx.W, "bookmarkEnd")
+                )
+            }
+            row_of = {num: i for i, (_, num, _) in enumerate(rows) if num}
+            keep: dict[int, list[tuple[str, str]]] = {}
+            for el in gap:
+                for b in el.iter(
+                    calkit.docx._tag(calkit.docx.W, "bookmarkStart")
+                ):
+                    name = b.get(w_name, "")
+                    if name in original or b.get(w_id) not in ended:
+                        continue
+                    row = row_of.get(link_text.get(name, ""), 0)
+                    keep.setdefault(row, []).append((name, b.get(w_id, "")))
+            doc.insert_equations(gap[0], rows, bid, keep=keep)
             bid += len(rows)
             for el in gap:
                 doc.remove(el)

calkit/cli/update.py

@@ -1718,18 +1718,33 @@ def update_hub(
     # A project that already exists on the hub, e.g., one created there
     # for this repo, is connected to rather than created again, which the
     # hub would refuse since a repo belongs to one project
-    exists = False
-    if owner is not None:
+    project = None
+    if git_repo_url is not None and git_repo_url.startswith(
+        "https://github.com/"
+    ):
+        github_repo = git_repo_url.removeprefix("https://github.com/")
+        try:
+            found = calkit.hub.get(
+                "/projects",
+                params=dict(github_repo=github_repo),
+                max_retries=1,
+            )
+            if found.get("data"):
+                project = found["data"][0]
+        except Exception:
+            pass
+    elif owner is not None:
         try:
-            calkit.hub.get(f"/projects/{owner}/{name}", max_retries=1)
-            exists = True
+            project = calkit.hub.get(
+                f"/projects/{owner}/{name}", max_retries=1
+            )
         except Exception:
             pass
     # Creating it is the step that can already be done, so a project that
     # exists is not an error: the point is to end up connected
     resp = None
     try:
-        if exists:
+        if project is not None:
             raise RuntimeError("Project already exists")
         resp = calkit.hub.post(
             "/projects",
@@ -1760,6 +1775,22 @@ def update_hub(
             typer.echo(f"Adding Git remote: {git_repo_url}")
             repo.git.remote(["add", "origin", git_repo_url])
         ck_info["git_repo_url"] = git_repo_url
+    # The hub decides who owns the project, e.g., an org's repo belongs to
+    # the org, under an account name that's lowercase even when the Git
+    # remote's isn't
+    for info in (project, resp):
+        if isinstance(info, dict) and info.get("owner_account_name"):
+            owner = info["owner_account_name"]
+            name = info.get("name") or name
+    if owner is not None and ck_info.get("owner") != owner:
+        ck_info["owner"] = owner
+    if ck_info.get("name") != name:
+        ck_info["name"] = name
+    if ck_info.get("hub") is None:
+        ck_info["hub"] = hub_url
+    # The DVC remote is named from calkit.yaml, so it has to be written first
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
     try:
         remote_name = configure_remote()
         set_remote_auth(remote_name=remote_name)
@@ -1773,14 +1804,6 @@ def update_hub(
         raise_error("Current directory is not a Git repository")
     except (ValueError, RuntimeError) as e:
         raise_error(f"Failed to set up DVC remote: {e}")
-    if owner is not None and ck_info.get("owner") != owner:
-        ck_info["owner"] = owner
-    if ck_info.get("name") != name:
-        ck_info["name"] = name
-    if ck_info.get("hub") is None:
-        ck_info["hub"] = hub_url
-    with open("calkit.yaml", "w") as f:
-        calkit.ryaml.dump(ck_info, f)
     paths = [".dvc/config", "calkit.yaml"]
     # The hub would have written one, and a repo it didn't scaffold has none
     if not os.path.isfile("README.md"):

calkit/core.py

@@ -41,6 +41,82 @@ logger = logging.getLogger(__package__)
 logger.setLevel(logging.INFO)
 
 
+class _FoldedPlainStr(str):
+    """A plain scalar read from several lines, remembering where they broke.
+
+    ``fold_pos`` holds the index of each space that was a line break, so
+    the value can be written back the way it was wrapped rather than
+    re-folded at whatever width ruamel is set to, which rewrote every
+    paragraph of a file wrapped any other way.
+    """
+
+    fold_pos: list[int]
+
+
+class _FoldPreservingConstructor(ruamel.yaml.constructor.RoundTripConstructor):
+    def construct_scalar(self, node: Any) -> Any:
+        value = super().construct_scalar(node)
+        if (
+            type(value) is not str
+            or node.style is not None
+            or node.start_mark.line == node.end_mark.line
+        ):
+            return value
+        # Only text loaded from a string has its source in the marks
+        buffer = getattr(node.start_mark, "buffer", None)
+        if buffer is None:
+            return value
+        source = buffer[node.start_mark.index : node.end_mark.index]
+        lines = [line.strip() for line in source.split("\n")]
+        # Blank lines are newlines in the value, which the emitter handles
+        if "" in lines or " ".join(lines) != value:
+            return value
+        out = _FoldedPlainStr(value)
+        out.fold_pos = []
+        pos = -1
+        for line in lines[:-1]:
+            pos += len(line) + 1
+            out.fold_pos.append(pos)
+        return out
+
+
+class _FoldPreservingRepresenter(ruamel.yaml.representer.RoundTripRepresenter):
+    pass
+
+
+_FoldPreservingRepresenter.add_representer(
+    _FoldedPlainStr, ruamel.yaml.representer.RoundTripRepresenter.represent_str
+)
+
+
+class _FoldPreservingEmitter(ruamel.yaml.emitter.Emitter):
+    def write_plain(self, text: Any, split: Any = True) -> None:
+        fold_pos = getattr(text, "fold_pos", None)
+        if not fold_pos or not split or self.root_context:
+            return super().write_plain(text, split)
+
+        def write(data: str) -> None:
+            self.column += len(data)
+            self.stream.write(
+                data.encode(self.encoding) if self.encoding else data
+            )
+
+        # The same bookkeeping as the parent's, breaking where the source
+        # did instead of where the width says to
+        if not self.whitespace:
+            write(" ")
+        self.whitespace = False
+        self.indention = False
+        start = 0
+        for pos in fold_pos:
+            write(text[start:pos])
+            self.write_indent()
+            self.whitespace = False
+            self.indention = False
+            start = pos + 1
+        write(text[start:])
+
+
 class _ThreadLocalYAML(threading.local):
     """Holds one configured ruamel ``YAML`` per thread.
 
@@ -65,6 +141,10 @@ class _ThreadLocalYAML(threading.local):
         # 79-80 columns is written back as it was; at 70, lines of 71-80
         # characters were re-folded with a stray word on the next line
         self.yaml.width = 80
+        # Prose wrapped some other way is still written back as it was
+        self.yaml.Constructor = _FoldPreservingConstructor
+        self.yaml.Representer = _FoldPreservingRepresenter
+        self.yaml.Emitter = _FoldPreservingEmitter
 
 
 _yaml_local = _ThreadLocalYAML()
@@ -83,6 +163,20 @@ class _ThreadLocalYAMLProxy:
     def __setattr__(self, name: str, value: Any) -> None:
         setattr(_yaml_local.yaml, name, value)
 
+    def load(self, stream: Any) -> Any:
+        """Load YAML, reading it to a string first.
+
+        Only a string load leaves the source in the marks, which is how
+        multi-line values remember where they were wrapped.
+        """
+        from pathlib import Path
+
+        if isinstance(stream, Path):
+            stream = stream.read_text(encoding="utf-8")
+        elif hasattr(stream, "read"):
+            stream = stream.read()
+        return _yaml_local.yaml.load(stream)
+
     def dump(self, data: Any, stream: Any = None, **kwargs: Any) -> Any:
         """Dump YAML, dropping the space ruamel leaves before a fold.
 

calkit/docx.py

@@ -633,10 +633,13 @@ class Document:
         before: ET.Element,
         rows: list[tuple[ET.Element, str | None, str]],
         first_bid: int,
+        keep: dict[int, list[tuple[str, str]]] | None = None,
     ) -> None:
         """Insert display equations before a body element as a borderless
         table of (math, number, bookmark name) rows, which Word and
         LibreOffice both lay out like LaTeX: centered, numbered at right.
+        ``keep`` is bookmarks, as (name, ID) by row, from what the
+        equations replace, so links to them still land.
         """
         width = self.column_width(before)
         side = width // 8
@@ -677,16 +680,19 @@ class Document:
                     )
                     # The bookmark spans the equation, since Word drops an
                     # empty one beside it
-                    bid = str(first_bid + i)
-                    ET.SubElement(
-                        p,
-                        _tag(W, "bookmarkStart"),
-                        {_tag(W, "id"): bid, _tag(W, "name"): name},
-                    )
+                    marks = [(name, str(first_bid + i))]
+                    marks += (keep or {}).get(i, [])
+                    for mark, bid in marks:
+                        ET.SubElement(
+                            p,
+                            _tag(W, "bookmarkStart"),
+                            {_tag(W, "id"): bid, _tag(W, "name"): mark},
+                        )
                     ET.SubElement(p, _tag(M, "oMathPara")).append(math)
-                    ET.SubElement(
-                        p, _tag(W, "bookmarkEnd"), {_tag(W, "id"): bid}
-                    )
+                    for _, bid in marks:
+                        ET.SubElement(
+                            p, _tag(W, "bookmarkEnd"), {_tag(W, "id"): bid}
+                        )
                 elif j == 2 and number:
                     ET.SubElement(
                         ppr, _tag(W, "jc"), {_tag(W, "val"): "right"}
@@ -1120,6 +1126,44 @@ def find_soffice() -> str | None:
     return next((c for c in candidates if os.path.isfile(c)), None)
 
 
+def _link_into_objects(content: str) -> str:
+    """Point links into embedded objects at the objects themselves.
+
+    TeX4ht puts each equation in an object of its own and links a
+    reference to it to an anchor inside, e.g., ``main-m7.4om#x7-3001r2``,
+    which Word can't follow, so LibreOffice writes it out as a path to a
+    file in the build directory. A bookmark of that name beside the object
+    in the main text makes it an ordinary link within the document.
+    """
+
+    def relink(m: re.Match) -> str:
+        name, anchor = m.group("name"), m.group("anchor")
+        if name not in objects:
+            return str(m.group(0))
+        anchors.setdefault(name, set()).add(anchor)
+        return f"{m.group('attr')}{m.group('q')}#{anchor}{m.group('q')}"
+
+    def mark(m: re.Match) -> str:
+        names = sorted(anchors.get(m.group("name"), ()))
+        marks = "".join(f"<text:bookmark text:name='{a}'/>" for a in names)
+        return marks + str(m.group(0))
+
+    frame_re = re.compile(
+        r"<draw:frame\b(?:(?!</draw:frame>).)*?<draw:object\b[^>]*?"
+        r"xlink:href=['\"]\./(?P<name>[^'\"/]+)['\"]",
+        flags=re.S,
+    )
+    objects = {m.group("name") for m in frame_re.finditer(content)}
+    anchors: dict[str, set[str]] = {}
+    content = re.sub(
+        r"(?P<attr><text:a\b[^>]*?xlink:href=)(?P<q>['\"])"
+        r"(?P<name>[^'\"#/]+)\.[^'\"#./]+#(?P<anchor>[^'\"]+)(?P=q)",
+        relink,
+        content,
+    )
+    return frame_re.sub(mark, content)
+
+
 def odt_to_docx(odt_path: str, docx_path: str) -> None:
     """Convert an OpenDocument text to .docx with LibreOffice."""
     import shutil
@@ -1130,6 +1174,21 @@ def odt_to_docx(odt_path: str, docx_path: str) -> None:
     if soffice is None:
         raise RuntimeError("Converting to Word requires LibreOffice")
     with tempfile.TemporaryDirectory() as tmp:
+        # A copy with its links fixed up, leaving the original as made
+        src = os.path.join(tmp, "src", Path(odt_path).name)
+        os.makedirs(os.path.dirname(src))
+        with (
+            zipfile.ZipFile(odt_path) as zin,
+            zipfile.ZipFile(src, "w") as zout,
+        ):
+            for item in zin.infolist():
+                data = zin.read(item)
+                if item.filename == "content.xml":
+                    data = _link_into_objects(data.decode("utf-8")).encode(
+                        "utf-8"
+                    )
+                zout.writestr(item, data)
+        odt_path = src
         # A profile of its own, since a LibreOffice already open would take
         # the job and exit without doing it
         res = subprocess.run(

calkit/dvc/core.py

@@ -367,6 +367,16 @@ class CalkitDVCFileSystem(ObjectFileSystem):
         fs.info = cached_info  # type: ignore[method-assign]
         return fs
 
+    def _info_many(self, paths: list[str], **kwargs: Any) -> dict:
+        # Only a .dir is read once it's found, so any other object's content
+        # would be downloaded just to say it exists
+        dirs = [p for p in paths if p.endswith(".dir")]
+        others = [p for p in paths if not p.endswith(".dir")]
+        infos = self.fs.info_many(dirs, **kwargs) if dirs else {}
+        if others:
+            infos |= self.fs.info_many(others, content=False, **kwargs)
+        return infos
+
     def _extract_owner_project(self) -> tuple[str, str] | None:
         """Extract owner and project from the path_info."""
         try:
@@ -432,7 +442,7 @@ class CalkitDVCFileSystem(ObjectFileSystem):
                     uncached_paths.append(p)
             # Only fetch info for uncached paths
             if uncached_paths:
-                infos = self.fs.info_many(uncached_paths, **kwargs)
+                infos = self._info_many(uncached_paths, **kwargs)
                 # Cache the newly fetched info
                 for p in uncached_paths:
                     exists = p in infos and isinstance(infos[p], dict)
@@ -490,7 +500,7 @@ class CalkitDVCFileSystem(ObjectFileSystem):
             # Only fetch info for uncached paths
             # Use info_many to get and cache both info and existence
             if uncached_paths:
-                infos = self.fs.info_many(uncached_paths, **kwargs)
+                infos = self._info_many(uncached_paths, **kwargs)
                 for p in uncached_paths:
                     exists = p in infos and isinstance(infos[p], dict)
                     if p not in self._cache:

calkit/fs.py

@@ -866,9 +866,13 @@ class CalkitFileSystem(AbstractFileSystem):
         return self._get_info_for_parsed_path(owner, project, file_path)
 
     def info_many(
-        self, paths: list[str], **kwargs
+        self, paths: list[str], content: bool = True, **kwargs
     ) -> dict[str, dict[str, Any]]:
-        """Get metadata for multiple paths in a batch API call."""
+        """Get metadata for multiple paths in a batch API call.
+
+        With ``content``, each small file's bytes come back too, saving
+        a request per file for callers that will read them.
+        """
         if not paths:
             return {}
         grouped: dict[tuple[str, str], list[tuple[str, str]]] = {}
@@ -888,7 +892,7 @@ class CalkitFileSystem(AbstractFileSystem):
                     project=project,
                     paths=file_paths,
                     operation="info",
-                    include=["info", "content"],
+                    include=["info", "content"] if content else ["info"],
                 )
                 batch_results = resp.get("results")
                 if isinstance(batch_results, dict):

calkit/hub.py

@@ -40,6 +40,13 @@ _REFRESH_BUFFER_SECONDS = 60
 # they don't recurse into the auth-retry paths in ``_request``.
 _device_login_lock = threading.Lock()
 
+# Reused so each request after the first skips the TLS handshake, which
+# was most of the time of a small request. The pool is sized for DVC's
+# concurrent transfers.
+_session = requests.Session()
+_session.mount("https://", requests.adapters.HTTPAdapter(pool_maxsize=64))
+_session.mount("http://", requests.adapters.HTTPAdapter(pool_maxsize=64))
+
 
 class DeviceLoginError(RuntimeError):
     """Raised when the OAuth device login flow cannot complete."""
@@ -381,7 +388,7 @@ def _request(
     # Bound how long a single attempt can hang so stalled connections become
     # retryable timeouts rather than blocking forever. Callers can override.
     kwargs.setdefault("timeout", (10, 120))
-    func = getattr(requests, kind)
+    func = getattr(_session, kind)
     if base_url is None:
         base_url = get_base_url()
     refresh_attempted = False

calkit/models/pipeline.py

@@ -228,6 +228,23 @@ def _allow_null(schema: dict[str, Any]) -> None:
     schema["anyOf"] = [inner, {"type": "null"}]
 
 
+def _unique_paths(paths: list[str]) -> list[str]:
+    """Drop repeated paths, keeping the order they were first added in.
+
+    A stage can name the same path more than once: a document's target is
+    often also one of its inputs, and one source can be copied to several
+    destinations. DVC warns about a duplicate dep on every run, so the
+    generated stage lists each path once.
+    """
+    seen: set[str] = set()
+    unique: list[str] = []
+    for path in paths:
+        if path not in seen:
+            seen.add(path)
+            unique.append(path)
+    return unique
+
+
 class Stage(BaseModel):
     """A stage in the pipeline."""
 
@@ -709,6 +726,9 @@ class Stage(BaseModel):
             path = i if isinstance(i, str) else i.path
             if path not in deps:
                 deps.append(path)
+        # Each path appears once: a stage that names the same one twice, e.g.
+        # a target that is also an input, otherwise reaches DVC as a duplicate
+        deps = _unique_paths(deps)
         outs = self.dvc_outs
         log_out = self.scheduler_log_output
         if log_out is not None:
@@ -954,7 +974,7 @@ class MapPathsStage(Stage):
         deps = []
         for path in self.paths:
             deps.append(path.src)
-        return deps + super().dvc_deps
+        return _unique_paths(deps + super().dvc_deps)
 
     @property
     def dvc_outs(self) -> list[dict]:
@@ -1288,7 +1308,7 @@ class LatexStage(Stage):
         deps = [self.target_path] + super().dvc_deps
         if self.latexmkrc_path is not None:
             deps.append(self.latexmkrc_path)
-        return deps
+        return _unique_paths(deps)
 
     @property
     def dvc_outs(self) -> list[str | dict]:

calkit/tests/cli/test_notebooks.py

@@ -179,6 +179,9 @@ def test_execute_notebook(tmp_dir):
     sys.platform == "win32",
     reason="TODO: Julia env init fails on Windows GHA runners (Pkg stdlib missing)",
 )
+# Both install and build IJulia in the shared depot, and one precompiling it
+# while the other builds it fails with "IJulia not properly installed"
+@pytest.mark.xdist_group("ijulia")
 def test_execute_notebook_julia(tmp_dir):
     subprocess.check_call(
         [
@@ -218,6 +221,9 @@ def test_execute_notebook_julia(tmp_dir):
     sys.platform == "win32",
     reason="TODO: Julia env init fails on Windows GHA runners (Pkg stdlib missing)",
 )
+# Both install and build IJulia in the shared depot, and one precompiling it
+# while the other builds it fails with "IJulia not properly installed"
+@pytest.mark.xdist_group("ijulia")
 def test_check_env_kernel_julia(tmp_dir):
     subprocess.check_call(["calkit", "init"])
     subprocess.check_call(

calkit/tests/cli/test_update.py

@@ -23,7 +23,7 @@ def test_update_project_config(tmp_dir, monkeypatch):
 
     import requests
 
-    monkeypatch.setattr(requests, "get", fail)
+    monkeypatch.setattr(requests.Session, "request", fail)
     subprocess.check_call(["calkit", "init"])
     result = runner.invoke(update_app, ["devcontainer"])
     assert result.exit_code == 0
@@ -561,24 +561,39 @@ def test_update_hub_creates_repo(tmp_dir, tmp_path_factory, monkeypatch):
     posted: list[dict] = []
     remote = {"url": ""}
 
+    posted_resp: dict = {}
+
     def post(path, json=None, **kwargs):
         posted.append(json)
-        return {"git_repo_url": remote["url"]}
+        return {"git_repo_url": remote["url"]} | posted_resp
 
     existing: set[str] = set()
-
-    def get(path, **kwargs):
+    on_hub: dict[str, dict] = {}
+
+    def get(path, params=None, **kwargs):
+        if path == "/projects":
+            found = on_hub.get(params["github_repo"].lower())
+            return {
+                "data": [found] if found else [],
+                "count": int(bool(found)),
+            }
         if path not in existing:
             raise RuntimeError("404: Not found")
         return {}
 
+    remote_names: list[str] = []
+
+    def configure_remote() -> str:
+        remote_names.append(calkit.detect_project_name())
+        return "calkit"
+
     monkeypatch.setattr(calkit.hub, "post", post)
     monkeypatch.setattr(calkit.hub, "get", get)
     monkeypatch.setattr(
         calkit.hub, "get_current_user", lambda: {"github_username": "someone"}
     )
     monkeypatch.setattr(calkit.hub, "get_hub_url", lambda: "https://hub.test")
-    monkeypatch.setattr(calkit.dvc, "configure_remote", lambda: "calkit")
+    monkeypatch.setattr(calkit.dvc, "configure_remote", configure_remote)
     monkeypatch.setattr(
         calkit.dvc, "set_remote_auth", lambda remote_name: None
     )
@@ -626,3 +641,34 @@ def test_update_hub_creates_repo(tmp_dir, tmp_path_factory, monkeypatch):
     assert "already exists" in result.output
     assert len(posted) == n_posted
     assert calkit.load_calkit_info()["hub"] == "https://hub.test"
+    # An org's repo already on the hub is found by its URL, and the remote
+    # is named for the account that owns it there, which is lowercase
+    on_hub["acme-lab/widget"] = {
+        "owner_account_name": "acme-lab",
+        "name": "widget",
+    }
+    git("remote", "set-url", "origin", "git@github.com:Acme-Lab/widget.git")
+    with open("calkit.yaml", "w") as f:
+        f.write("title: Widget\n")
+    result = runner.invoke(
+        update_app, ["hub", "https://hub.test", "--no-commit"]
+    )
+    assert result.exit_code == 0, result.output
+    assert len(posted) == n_posted
+    assert remote_names[-1] == "acme-lab/widget"
+    ck_info = calkit.load_calkit_info()
+    assert ck_info["owner"] == "acme-lab"
+    assert ck_info["name"] == "widget"
+    assert "https://hub.test/acme-lab/widget" in result.output
+    # One the client creates takes the owner the hub gave it
+    on_hub.clear()
+    with open("calkit.yaml", "w") as f:
+        f.write("name: widget\ntitle: Widget\n")
+    posted_resp["owner_account_name"] = "acme-lab"
+    result = runner.invoke(
+        update_app, ["hub", "https://hub.test", "--no-commit"]
+    )
+    assert result.exit_code == 0, result.output
+    assert posted[-1]["git_repo_url"] == "https://github.com/Acme-Lab/widget"
+    assert remote_names[-1] == "acme-lab/widget"
+    assert calkit.load_calkit_info()["owner"] == "acme-lab"

calkit/tests/dvc/test_core.py

@@ -586,3 +586,48 @@ def test_commit_path_with_missing_dep(tmp_dir):
     # The output's hash should be kept, since there's nothing new to hash
     assert lock["stages"]["my-stage"]["outs"][0]["path"] == "output.txt"
     assert "md5" in lock["stages"]["my-stage"]["outs"][0]
+
+
+def test_ck_fs_reads_content_only_for_dirs() -> None:
+    from calkit.dvc.core import CalkitDVCFileSystem
+
+    calls: list[tuple[list[str], bool]] = []
+    stored = {
+        "o/p/files/md5/aa/1.dir": b"[]",
+        "o/p/files/md5/bb/2": b"data",
+    }
+
+    class FakeFS:
+        def info_many(
+            self, paths: list[str], content: bool = True, **kwargs: object
+        ) -> dict[str, dict]:
+            calls.append((sorted(paths), content))
+            infos = {}
+            for path in paths:
+                if path in stored:
+                    infos[path] = {"name": path, "size": len(stored[path])}
+                    if content:
+                        infos[path]["content"] = stored[path]
+            return infos
+
+    fs = CalkitDVCFileSystem()
+    fs.__dict__["fs"] = FakeFS()
+    paths = [
+        "o/p/files/md5/aa/1.dir",
+        "o/p/files/md5/bb/2",
+        "o/p/files/md5/cc/3.dir",
+        "o/p/files/md5/dd/4",
+    ]
+    assert fs.exists(paths) == [True, True, False, False]
+    assert calls == [
+        (["o/p/files/md5/aa/1.dir", "o/p/files/md5/cc/3.dir"], True),
+        (["o/p/files/md5/bb/2", "o/p/files/md5/dd/4"], False),
+    ]
+    infos = fs.info(paths[:2])
+    assert infos[0]["content"] == b"[]"
+    assert "content" not in infos[1]
+    # Everything asked about is answered from what was already fetched
+    assert len(calls) == 2
+    with pytest.raises(FileNotFoundError):
+        fs.info(paths)
+    assert len(calls) == 2

calkit/tests/models/test_pipeline.py

@@ -17,6 +17,7 @@ from calkit.models.pipeline import (
     Pipeline,
     PythonScriptStage,
     QuartoStage,
+    ShellScriptStage,
     StageIteration,
     WordToPdfStage,
 )
@@ -1005,3 +1006,61 @@ def test_system_env_can_wrap_a_runtime():
             bad.set_stage_scheduler_options(
                 envs | {"sched": {"kind": "slurm", "host": "hpc.edu"}}
             )
+
+
+def test_dvc_deps_are_unique_per_stage():
+    # A generated dvc.yaml lists each dependency once. A stage that names the
+    # same path twice otherwise reaches DVC as a duplicate, which it warns
+    # about on every run
+    def assert_unique(deps: list[str]) -> None:
+        assert len(deps) == len(set(deps)), f"duplicates in {deps}"
+
+    # The target is also a common input, e.g. a bib or a figure the document
+    # reads, so it arrives as both target_path and an input
+    latex = LatexStage(
+        name="paper",
+        environment="tex",
+        target_path="main.tex",
+        inputs=["main.tex", "figures/plot.png"],
+    )
+    assert_unique(latex.dvc_deps)
+    # One source copied to two destinations is one dependency, not two
+    mapped = MapPathsStage(
+        name="copy",
+        paths=[
+            dict(kind="file-to-file", src="paper/main.tex", dest="out/a.tex"),
+            dict(kind="file-to-file", src="paper/main.tex", dest="out/b.tex"),
+        ],
+    )
+    assert_unique(mapped.dvc_deps)
+    # The compiled stage is what reaches dvc.yaml
+    for stage in [latex, mapped]:
+        assert_unique(stage.to_dvc()["deps"])
+
+
+def test_to_dvc_deps_have_no_duplicates():
+    # A script named as its own input reaches the generated stage twice:
+    # once through the script_path override and once through inputs
+    for stage in [
+        PythonScriptStage(
+            name="run",
+            environment="py",
+            script_path="run.py",
+            inputs=["run.py", "data/in.csv"],
+        ),
+        ShellScriptStage(
+            name="shell",
+            kind="shell-script",
+            environment="_system",
+            script_path="run.sh",
+            inputs=["run.sh"],
+        ),
+        WordToPdfStage(
+            name="doc",
+            environment="tex",
+            word_doc_path="document.docx",
+            inputs=["document.docx"],
+        ),
+    ]:
+        deps = stage.to_dvc()["deps"]
+        assert len(deps) == len(set(deps)), f"duplicates in {deps}"

calkit/tests/test_core.py

@@ -364,6 +364,56 @@ def test_ryaml_dump_keeps_significant_trailing_whitespace():
         assert calkit.ryaml.load(buf.getvalue()) == {"k": value}
 
 
+@pytest.mark.usefixtures("tmp_dir")
+def test_ryaml_keeps_how_prose_was_wrapped() -> None:
+    import copy
+    import io
+    from pathlib import Path
+
+    import calkit
+
+    def dumped(data: dict) -> str:
+        buf = io.StringIO()
+        calkit.ryaml.dump(data, buf)
+        return buf.getvalue()
+
+    # Wrapped narrower than ruamel's width, which used to re-fold it all
+    text = (
+        "title: A project\n"
+        "questions:\n"
+        "  - question: Does the new mesh change the drag coefficient by\n"
+        "      more than the measurement uncertainty?\n"
+        "    notes: The coarse and fine meshes agree to within two\n"
+        "      percent, so the remaining difference comes from the\n"
+        "      turbulence model rather than the resolution.\n"
+    )
+    with open("calkit.yaml", "w") as f:
+        f.write(text)
+
+    # However it's loaded, an untouched file is written back as it was
+    with open("calkit.yaml") as f:
+        from_file = calkit.ryaml.load(f)
+    for data in [
+        calkit.ryaml.load(text),
+        from_file,
+        calkit.ryaml.load(Path("calkit.yaml")),
+        copy.deepcopy(from_file),
+    ]:
+        assert dumped(data) == text
+    info = calkit.load_calkit_info()
+    info["owner"] = "someone"
+    calkit.save_calkit_info(info)
+    with open("calkit.yaml") as f:
+        assert f.read() == text + "owner: someone\n"
+    # A value that's changed is wrapped at the width like any other
+    data = calkit.ryaml.load(text)
+    data["questions"][0]["notes"] += " And one more sentence to fold."
+    out = dumped(data)
+    assert "agree to within two\n" not in out
+    assert calkit.ryaml.load(out) == data
+    assert "      more than the measurement uncertainty?\n" in out
+
+
 def test_update_readme_content():
     import calkit
 

calkit/tests/test_docx.py

@@ -15,6 +15,7 @@ import re
 import shutil
 import subprocess
 from pathlib import Path
+from xml.etree import ElementTree as ET
 
 import pytest
 
@@ -604,6 +605,13 @@ def test_docx_round_trip(
         assert lo_sent is not None and len(lo_sent.equations) == 1
         assert len(lo_sent.paragraphs) >= 15
         assert any(p.text == "(1)" for p in lo.paragraphs)
+        # A reference to an equation links to it inside the document, not
+        # to TeX4ht's build directory
+        body = lo.parts["word/document.xml"].decode("utf-8")
+        anchors = re.findall(r'w:anchor="([^"]+)"', body)
+        marks = set(re.findall(r'w:bookmarkStart [^>]*w:name="([^"]+)"', body))
+        assert anchors and set(anchors) <= marks
+        assert "HYPERLINK" not in body and ".4om" not in body
         main = Path("paper/main.tex").read_text(encoding="utf-8")
         methods = Path("paper/methods.tex").read_text(encoding="utf-8")
         res = subprocess.run(
@@ -615,3 +623,48 @@ def test_docx_round_trip(
         assert "Applied 0 edits" in res.stdout
         assert Path("paper/main.tex").read_text(encoding="utf-8") == main
         assert Path("paper/methods.tex").read_text(encoding="utf-8") == methods
+
+
+def test_equation_links() -> None:
+    content = (
+        "<text:p>See (<text:a xlink:href='main-m7.4om#x7-3001r2' "
+        "xlink:type='simple'>2</text:a>), "
+        '<text:a xlink:href="main-m7.4om#x7-3001r3">3</text:a>, '
+        "<text:a xlink:href='#Xsmith2020'>Smith</text:a>, "
+        "<text:a xlink:href='https://calkit.io/a.html#b'>web</text:a> and "
+        "<text:a xlink:href='other.4om#x9'>gone</text:a>.</text:p>"
+        "<text:p><draw:frame draw:name='obj-7'><draw:object "
+        "xlink:href='./main-m7' xlink:show='embed'/></draw:frame></text:p>"
+    )
+    out = calkit.docx._link_into_objects(content)
+    # Links into an object point at bookmarks beside it
+    assert "xlink:href='#x7-3001r2'" in out
+    assert 'xlink:href="#x7-3001r3"' in out
+    assert (
+        "<text:p><text:bookmark text:name='x7-3001r2'/>"
+        "<text:bookmark text:name='x7-3001r3'/><draw:frame" in out
+    )
+    # Links within the document or out of it, or to an object that isn't
+    # there, are left alone
+    assert "xlink:href='#Xsmith2020'" in out
+    assert "xlink:href='https://calkit.io/a.html#b'" in out
+    assert "xlink:href='other.4om#x9'" in out
+    assert calkit.docx._link_into_objects(out) == out
+    # A kept bookmark goes on the row it's for, not just the first
+    doc = calkit.docx.Document(str(FIXTURES / "export.docx"))
+    w, m = calkit.docx.W, calkit.docx.M
+    before = next(doc.doc.iter(calkit.docx._tag(w, "p")))
+    rows = [
+        (ET.Element(calkit.docx._tag(m, "oMath")), "4", "ck_a"),
+        (ET.Element(calkit.docx._tag(m, "oMath")), "5", "ck_a_r2"),
+    ]
+    doc.insert_equations(before, rows, 100, keep={1: [("x13-3004r5", "7")]})
+    tbl = next(doc.doc.iter(calkit.docx._tag(w, "tbl")))
+    names = [
+        [
+            b.get(calkit.docx._tag(w, "name"))
+            for b in tr.iter(calkit.docx._tag(w, "bookmarkStart"))
+        ]
+        for tr in tbl.iter(calkit.docx._tag(w, "tr"))
+    ]
+    assert names == [["ck_a"], ["ck_a_r2", "x13-3004r5"]]

calkit/tests/test_hub.py

@@ -294,7 +294,7 @@ def test_request_retries_on_401_with_refresh(monkeypatch):
             return Resp401()
         return Resp200()
 
-    monkeypatch.setattr(hub.requests, "get", _fake_get)
+    monkeypatch.setattr(hub._session, "get", _fake_get)
     monkeypatch.setitem(hub._tokens, base_url, fresh)
     monkeypatch.setattr(hub, "_try_refresh", lambda: fresh)
     result = hub._request("get", "/test", base_url=base_url)
@@ -333,7 +333,7 @@ def test_request_invalid_credentials_403_triggers_refresh(monkeypatch):
         call_count["n"] += 1
         return Resp403() if call_count["n"] == 1 else Resp200()
 
-    monkeypatch.setattr(hub.requests, "get", _fake_get)
+    monkeypatch.setattr(hub._session, "get", _fake_get)
     monkeypatch.setitem(hub._tokens, base_url, fresh)
     monkeypatch.setattr(hub, "_try_refresh", lambda: fresh)
     result = hub._request("get", "/test", base_url=base_url)
@@ -369,7 +369,7 @@ def test_request_permission_403_does_not_trigger_refresh(monkeypatch):
         refresh_calls["n"] += 1
         return fresh
 
-    monkeypatch.setattr(hub.requests, "post", _fake_post)
+    monkeypatch.setattr(hub._session, "post", _fake_post)
     monkeypatch.setitem(hub._tokens, base_url, fresh)
     monkeypatch.setattr(hub, "_try_refresh", _fake_refresh)
     with pytest.raises(Exception):
@@ -410,7 +410,7 @@ def test_request_retries_on_transient_5xx(monkeypatch):
             calls["n"] += 1
             return Resp(status)
 
-        monkeypatch.setattr(hub.requests, "get", _fake_get)
+        monkeypatch.setattr(hub._session, "get", _fake_get)
         result = hub._request("get", "/test", base_url=base_url)
         assert result == {"ok": True}
         assert calls["n"] == 2
@@ -421,7 +421,7 @@ def test_request_retries_on_transient_5xx(monkeypatch):
         persistent["n"] += 1
         return Resp(500)
 
-    monkeypatch.setattr(hub.requests, "get", _fake_get_500)
+    monkeypatch.setattr(hub._session, "get", _fake_get_500)
     with pytest.raises(HTTPError):
         hub._request("get", "/test", base_url=base_url)
     # Initial attempt plus max_retries follow-ups.
@@ -458,7 +458,7 @@ def test_request_retries_on_network_error(monkeypatch):
             raise errors[calls["n"] - 1]
         return Resp200()
 
-    monkeypatch.setattr(hub.requests, "get", _fake_get)
+    monkeypatch.setattr(hub._session, "get", _fake_get)
     assert hub._request("get", "/test", base_url=base_url) == {"ok": True}
     assert calls["n"] == 3
     # Case 2: a persistent network error exhausts retries and propagates.
@@ -468,7 +468,7 @@ def test_request_retries_on_network_error(monkeypatch):
         persistent["n"] += 1
         raise Timeout("read timeout")
 
-    monkeypatch.setattr(hub.requests, "get", _always_timeout)
+    monkeypatch.setattr(hub._session, "get", _always_timeout)
     with pytest.raises(Timeout):
         hub._request("get", "/test", base_url=base_url)
     assert persistent["n"] == 11
@@ -533,7 +533,7 @@ def test_request_can_skip_retries_and_login(monkeypatch):
         attempts["n"] += 1
         return _Resp()
 
-    monkeypatch.setattr(calkit.hub.requests, "post", fake_post)
+    monkeypatch.setattr(calkit.hub._session, "post", fake_post)
     monkeypatch.setattr(calkit.hub, "get_headers", lambda h, auth=True: {})
     monkeypatch.setattr(calkit.hub, "get_base_url", lambda: "http://x")
     with pytest.raises(calkit.hub.HTTPError):

{calkit_python-0.48.0.dist-info → calkit_python-0.48.1.dist-info}/METADATA

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

{calkit_python-0.48.0.dist-info → calkit_python-0.48.1.dist-info}/RECORD

@@ -3,18 +3,18 @@ calkit/__main__.py,sha256=whqS7I7q_c9004emvKptZ9B9OVn-jgr5kaLaCFKmwa0,112
 calkit/calc.py,sha256=5RQVwH3goakmeDwHtmslcAZJXEZihIBuLNw_lF6QCcc,7924
 calkit/conda.py,sha256=ddsHScMlPkpPU-d5vi-X--ANFvO2fi0fRFUFd_Ux51Y,33399
 calkit/config.py,sha256=kMGYi-S4Ojp_VRGgxapvsci3XYcIBx3jGllmdLe7wuo,21780
-calkit/core.py,sha256=eI5VcAxTJlaleBsnCCGVsP764QTwrUw53WAKXN8SNe4,54766
+calkit/core.py,sha256=HBG4gho491y5tZL_VTXo_HFB-sIZnoKhuFWQ5X0Kplc,58092
 calkit/datasets.py,sha256=3YtDmvBCzyX5AC-7Mb7ylnxM1mFLyTLj5CH7QqblDwA,2212
 calkit/dependencies.py,sha256=MI_wuvQaY9okkmui37qz2yIxxBXJ3yuJUOQRj95IEbw,15362
 calkit/detect.py,sha256=qEdYOrXMVCUYRoQ7YBQZBn_YZQT3K2GeWSOnWceGpNA,88418
 calkit/docker.py,sha256=kMMcmAsVIuvYlANiVow2DuLTkMKJBN8HabyW5UsgOYs,50668
-calkit/docx.py,sha256=RzqiTHfyKrf_tHuaVtGKGPfW6pGTYpZbXyvSNYmc36c,52670
+calkit/docx.py,sha256=wP0vwzcTdRDknUyaelr1_OVgW8C6RDnfZHKKRPXWp4k,55141
 calkit/environments.py,sha256=O10Ppy2Sy0IKzFYoAJRbdxELBDG04u6p9zMKWuRh0-8,102536
-calkit/fs.py,sha256=C6Xubi6BBdyHwJrPhFr6I07zusGQJ6E5Cnl-Xu9O7U8,45469
+calkit/fs.py,sha256=7huOJIDPni4bTJ3MZyyifgE4NqbfbT_bPW8Uff-7JMU,45658
 calkit/git.py,sha256=ikSKyvx-xuk64deSeBTDqXsNlaFVePlP8Vc_Zupd7IU,27324
 calkit/github.py,sha256=nBR3CH3mFIDk_atWtZ_EdQEP3ktDi-xNPbe6Bbusarg,1699
 calkit/gui.py,sha256=2UCrMyosc5v4CLlDcHO7oDwW9eLn5_WbNaLaG5bjMTc,23
-calkit/hub.py,sha256=mZ1rAnDOOK2J6jAXqKsjaNJnlxveZkIlwE1BjvIxmgU,19612
+calkit/hub.py,sha256=cZ8ltzambJ9MObb5Xj1B8MblmO0XVws7Y1MoOO0gWlM,19959
 calkit/install.py,sha256=y3-ZUZt1Tf3H9mP5v8dXtrNnhx7NiJPolF9ptlWRUkk,16997
 calkit/invenio.py,sha256=i3UrEkzWXw4buhVwgjpLJL4AierBYnyWJCg0ytLuaBo,6214
 calkit/julia.py,sha256=4GxUSItNXpYcRlCD9N8dLiuX44-HQaKFcuEudD8At1I,5640
@@ -47,7 +47,7 @@ calkit/cli/describe.py,sha256=LMODpla_g7hyTI7Oi7V5dAb9WSp5nZ_4-XhSYmZP1eo,3608
 calkit/cli/dev.py,sha256=_BZqDdfF1VSfXaFfdBvofwE6cpcevhbgjRYNUHRQU2M,1761
 calkit/cli/hub.py,sha256=ZBOlL7-mV57q_ynr4hPuhV7NlkKEkINSRksXD-jjiOg,2972
 calkit/cli/import_.py,sha256=QOZEfKUmqMntle47PRZhN8cs7gfWCBte_smPZqksl54,25563
-calkit/cli/latex.py,sha256=uCVeQoRHPbhRI6Zbrl2S6PqdZGqbzSjFQ9sxmSzn6EM,110414
+calkit/cli/latex.py,sha256=CXpPsu8359pUR7fJkXosRFaiag8aLa1YAk_GUCf04Y0,111959
 calkit/cli/list.py,sha256=dcpDdeG8OdjL5--DbE27URXQnuB4w1pPYltsBFC45_s,21969
 calkit/cli/new.py,sha256=aGPHpz8poGt_F04sdaKsvOLr4Kowc0qaV-n4dhO6VPM,158819
 calkit/cli/notebooks.py,sha256=aR4I0qatOtkrAxEG5PVLej20SBLKo8qr-lxDSzgljUQ,38836
@@ -56,12 +56,12 @@ calkit/cli/overleaf.py,sha256=vuV0GktH2ZlI93s-pA7RZ4zRFM9BLUC20lMrVZ92mro,38727
 calkit/cli/scheduler.py,sha256=s4q9wLcvTCmxuLmAoz7ptJZiNXPWCamn-NU1S5l28go,52719
 calkit/cli/show.py,sha256=zI9dqviFxXlcjnpEXnN7Ip2kmw9bVwP74rJDM9UqZ4s,3074
 calkit/cli/sync.py,sha256=o6EnwADaUUK1yudWTc0gllKNLYD54jJbMnYBIuG5SfY,12643
-calkit/cli/update.py,sha256=_q8XOxJWIeNn4FKez-T07AebufGksFmMUjLIwqrhptQ,63660
+calkit/cli/update.py,sha256=CfjghxEQIB8dJ7XahH64kroULFhQHLJqRAiOKNEOwZY,64595
 calkit/cli/main/__init__.py,sha256=qu1POZPyqs33ZKfasOxv_Wc-EzVcEgK3Dt_vwFL8Bi8,65
 calkit/cli/main/core.py,sha256=cHeRj62MREnc6_t7FFUs2mtu-vl6UiVtyYelmrXdF7g,179890
 calkit/cli/main/xr.py,sha256=cYQBNVlRTzp6ba3EwEwZylOxVpk9ThWhy6IAD7_ahWw,37594
 calkit/dvc/__init__.py,sha256=-B6tilCb_jw7QFmJ2srILez24wDhNKUzIBhZUMt01dE,381
-calkit/dvc/core.py,sha256=f_gvVn5TglwdwKL6uebb4qTQ9Ac-oaFvRi0ZKHKdY6Y,45377
+calkit/dvc/core.py,sha256=RadL_0va0kIaalIkDLzCa-KPbiOltlR1ADFPKtsP_ro,45866
 calkit/dvc/zip.py,sha256=8_FdpEeQ5N3mbq0nwqm69F3enOHsQkSZpx2KBYLbSCg,21888
 calkit/jupyterlab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/jupyterlab/routes.py,sha256=sARrFjWnHVV-LunrgqO4DCt_x7XLhVPAqA1eaUFf7HQ,51443
@@ -70,7 +70,7 @@ calkit/models/core.py,sha256=mL9ImXwt1iTtDKzdmt96F9ONevLSTWhIKb_xAEJFb5I,80570
 calkit/models/docx.py,sha256=pVfBSmb2pfe-AeDYhJuYCvGohE98ixDuBBbkmtDyOMU,2897
 calkit/models/io.py,sha256=0nup-gDz3FbiD8AT5pTpxji6XN_rW5AsijErsIFdpbg,2330
 calkit/models/iteration.py,sha256=_QajYhWVXV9ge9naX8ZkT1PBNzfc75cpl2BR2f8VPOo,2945
-calkit/models/pipeline.py,sha256=jVh03eoPSNUjxv0zJFoDnZX5HL9yFcJs_RlHeqFDcw4,99661
+calkit/models/pipeline.py,sha256=6JiABNJDx_MgcsswT8AgNiY2R3ff3cqt6cFZ22CCPfM,100460
 calkit/resources/README.md,sha256=sqqGXkhVLGeo50cXHx6XDm_yYB3klyDhudisZlLpNuE,1463
 calkit/resources/__init__.py,sha256=QhDLrihdVQGyW2xEGzj2fIHGheq6Pn8W8jwlrjmmRv0,5122
 calkit/resources/devcontainer/Dockerfile,sha256=U56BhC7sB9qlwpSMMb8CNHgNyuF-ZCV7X7E88rx6KQQ,3091
@@ -101,16 +101,16 @@ calkit/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/test_calc.py,sha256=h-wOUIRqfyi06LTzhY_rS-a1xChZTkmwdEfBybMUM7E,2033
 calkit/tests/test_conda.py,sha256=aJzuKHT81DfbmcRpae-x0I8s6I-ZTdbSlq5yjIYIvTM,17097
 calkit/tests/test_config.py,sha256=hPJ-PRDOXjrwwO_PcP8KG1ehlrlHUI2Qhlkja9NfMCU,14834
-calkit/tests/test_core.py,sha256=t21yli5UU66LDaK2zpcxWQdp9dcJ8WV6VktsUZk9dEE,16379
+calkit/tests/test_core.py,sha256=m-P2OSWv1MjABY2YgSJJdtkvzPNPOspdvcLXT2j0GDs,18106
 calkit/tests/test_dependencies.py,sha256=Stb_pQr8HTrkUSTjZFAJ2aFOXAzlFNXtEjf2Uh0PF2E,12672
 calkit/tests/test_detect.py,sha256=rNi_W5ck4_TZo2_tXfIfTc-U_GxOePdz_jJjaqnewlA,49981
 calkit/tests/test_docker.py,sha256=mBjj_z47fqVLfZTbuJoJwXTAo-udd22RZGR-IXTX9a4,20704
 calkit/tests/test_docs_references.py,sha256=n9XZMniIH1XvlUxdlFcLeQuNBwJsDydyVYZOeAh2XrA,5264
-calkit/tests/test_docx.py,sha256=NWiP7zR8T8jWKTTpYoa11u13W7aO8BBM3XKK4C85BU8,26019
+calkit/tests/test_docx.py,sha256=wYTVX2axWkMZC4cxzQsJjllqf__O-6WaAHMB67FHTbg,28481
 calkit/tests/test_environments.py,sha256=sJoarJMpSub1u9FvqY-KcVzdfg7svpgDEUeajC4DcDQ,62874
 calkit/tests/test_fs.py,sha256=vBbzZlikzwAQkPwn8_-wdsD-l1R4YTH7g-ghGfWrtzE,13785
 calkit/tests/test_git.py,sha256=i_m11l5MkgjzuI0hB6PwmSCQ-Vx_Bgk2moZEorpODxo,26016
-calkit/tests/test_hub.py,sha256=bxo_aRj3G_vmWlxBM6A7A9hjG_RBI9DW8fdA2wivhlc,17824
+calkit/tests/test_hub.py,sha256=H7We9KFZnW2Y5SqKVRqQCOksCjZHDoFc_IFJmiXDANQ,17824
 calkit/tests/test_install.py,sha256=ZpM0HAVLoddtyWuuOoATIkJoCpst0w6TIzXIY-ZQik4,14739
 calkit/tests/test_invenio.py,sha256=TJI8HsWkrLl0XOW-K51wdoRd-LH6RhpfvgRonjcdnZI,3693
 calkit/tests/test_julia.py,sha256=q7UYIJAvCQ8b6eMaledcV3rV3PPL6hDnpYJEzn2tmCE,6390
@@ -145,19 +145,19 @@ calkit/tests/cli/test_import.py,sha256=snQgCw6SM9V3g5NS8oBK-2B3bYFVyJcuXtJuFtDtf
 calkit/tests/cli/test_latex.py,sha256=6UTu1vMjv3a7PCXQvB6nLdyRFDyWn-VvlgiOpUIRqhQ,36998
 calkit/tests/cli/test_list.py,sha256=rnoDS2JOiy2TN_zj1LI2IgIa0WKP8UA1zlj4_-uLjpI,13510
 calkit/tests/cli/test_new.py,sha256=WqesquN9fuDs04en5TW06MhVNbwITQBcsi_D_fuTwcQ,76963
-calkit/tests/cli/test_notebooks.py,sha256=RcFnZAnyEnWpgPj1Hsnhryn0gCncgtHRxDSEROanOlE,11904
+calkit/tests/cli/test_notebooks.py,sha256=FkD2HD9kveyKuXU55MgHoYyTnOGNzS-FtFIdVtMHzkc,12270
 calkit/tests/cli/test_overleaf.py,sha256=VRBXGmU_8dvIsn3marpV5BmviCq3ofij_FtvqFkW_eQ,49790
 calkit/tests/cli/test_scheduler.py,sha256=YfJi_fcRlQt1bdFyo3b8BFelA1PcH-wn5lAVXiH7Zj4,24109
 calkit/tests/cli/test_show.py,sha256=9vXLdRvHuFvXDRbTgTrMJZS9o_EYr55GyqMfpHHBUi4,3327
 calkit/tests/cli/test_sync.py,sha256=K8FbLq0PPE_JJmYRdXxlWcMx7IAAo-VjiVsfIPj-aYI,4811
-calkit/tests/cli/test_update.py,sha256=FVm2A2umERFMkmA-irMaHR7nT6Zd5Sec8c36XPqYXbQ,21804
+calkit/tests/cli/test_update.py,sha256=5OL7VjSFxdD4i1pztFIWd_5WDx2oEgh4jTIBBEb27fo,23648
 calkit/tests/cli/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/cli/main/test_core.py,sha256=lyTQcMBmKIqPRiUaVXE5HqGNqomQU4ySSxtpVVD174U,112702
 calkit/tests/cli/main/test_lock.py,sha256=1iX8iSbGtr4O9OkaAi4d3gP3_QzNl6Rr6HLtbEpS6iU,9847
 calkit/tests/cli/main/test_subprojects.py,sha256=2IHwonTH_nI6yraFsgvOQTQ6z6JWOFOmMjZngOeMrwY,18920
 calkit/tests/cli/main/test_xr.py,sha256=0ExuYuub66wsC2tYHnj3lzlgsFsjGjkDyCV2RBIkm4U,28832
 calkit/tests/dvc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-calkit/tests/dvc/test_core.py,sha256=xAMtoTV1d893y35mQ-2tk_IjRJVK_hS-DUD6g7ciz-4,20575
+calkit/tests/dvc/test_core.py,sha256=ANDdwOO-eKwV_jGxrkOY8CVC8h8EQHt9Loq0JuLP9aE,22043
 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
@@ -165,28 +165,28 @@ calkit/tests/jupyterlab/test_routes.py,sha256=TEEyoHiKnzzKOkQsJcMPKdqpKFQ25yBCvV
 calkit/tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/models/test_core.py,sha256=iDi0mvgZDBj2n7bo-cyKd8dvRZHl5ywWbcab4BPsqcE,8421
 calkit/tests/models/test_iteration.py,sha256=vjuDKwyYQAV4w1qF9VJWQEHksq3KRd6gtT39_a-RhnI,644
-calkit/tests/models/test_pipeline.py,sha256=gfDv-n5QywtTJebOp4nNY8v-vje-QRs0EpNARjsNyjA,35667
+calkit/tests/models/test_pipeline.py,sha256=K-q4LHh35AjvcLxgJnVTMcwsXxIdynCKO16xqdDTtO8,37692
 calkit/agent_skills/add-pipeline-stage/SKILL.md,sha256=kpYYb-rJsS4B9p1Ub3gL21irCG5ZZ4DvWZpdJeEwPZk,3772
 calkit/agent_skills/build-paper-pipeline/SKILL.md,sha256=aV9t86FxQNkeXyswM03fb5LW3ns4pcsWQyYNZ33niLI,6829
 calkit/agent_skills/check-questions/SKILL.md,sha256=yn6geOQUNQnJbM_Bn9grULerzreGvZob8vNtawWgvCs,9653
 calkit/agent_skills/check-reproducibility/SKILL.md,sha256=5SGmtnbq8bSJW0Zwav_aVzfuhilHwBkkdxGuZvPHxGU,4699
 calkit/agent_skills/conventions/SKILL.md,sha256=W9ayIG76Q8BTBgIRhpZz52dCKDLsSVj8_7O3LPeffU4,10323
 calkit/agent_skills/create-pipeline/SKILL.md,sha256=2FGw1iDQVRk5FUq79GP3lPdgvgof2Wi1O9O-abGGtgs,5422
-calkit_python-0.48.0.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/package.json,sha256=0hnHqhCly59Wg7urFGahc2mSupCWwiPfwKWCYfnbB2E,6202
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=egkbkHmJYzDARH3_4qpoF75_Svpj_dfPaIwRU-PNjW4,6064
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/506.c34b070098184e33.js,sha256=0PxdmgdZvLeh6RBcfgN1pcriNO8oCeTK5WJvUIEA3MY,112384
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/57d13a7399cec3c5.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/616.528427eb54a4a0c0.js,sha256=d0rHq7cqAjj1GNAMLOpl8dyY8yyKUQcLPCOUr-wJGdQ,8129
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/740.6bf87276e9e5788a.js,sha256=4E0sK8x-ldVkL-1sM07wgJGS1vtVD9Uly7VtoFTi23c,221
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/899.f9b9f9bf705a6493.js,sha256=RNTIItG9k-A_Ip54fRR3QMCjiffkY0bo8zQ2Xh7TyOY,57096
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/935.46ecc6bf99aa593a.js,sha256=Cmp0KWM5YDZ-zcsJWWgqCMIF6adeHQH80rxz1sas45E,51183
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.109a3a8379365e59.js,sha256=4JavPLcn703qVSC2E1_MD1thrJNL4N-eITjnfNhSDSM,15066
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=LTlA3M58hwjqmhomdcrNRO9GM58zZcf0V76WX9HI6EQ,146
-calkit_python-0.48.0.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
-calkit_python-0.48.0.dist-info/METADATA,sha256=Fs8kH4nO9atEaO1S3HKquRoqtExw2OaldGbuivr-8t8,22044
-calkit_python-0.48.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-calkit_python-0.48.0.dist-info/entry_points.txt,sha256=TtpHpcv2vFVAVYxFVp0XrwCV_z7FWIOguEiypXRDoOw,131
-calkit_python-0.48.0.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
-calkit_python-0.48.0.dist-info/RECORD,,
+calkit_python-0.48.1.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/package.json,sha256=0hnHqhCly59Wg7urFGahc2mSupCWwiPfwKWCYfnbB2E,6202
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=egkbkHmJYzDARH3_4qpoF75_Svpj_dfPaIwRU-PNjW4,6064
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/506.c34b070098184e33.js,sha256=0PxdmgdZvLeh6RBcfgN1pcriNO8oCeTK5WJvUIEA3MY,112384
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/57d13a7399cec3c5.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/616.528427eb54a4a0c0.js,sha256=d0rHq7cqAjj1GNAMLOpl8dyY8yyKUQcLPCOUr-wJGdQ,8129
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/740.6bf87276e9e5788a.js,sha256=4E0sK8x-ldVkL-1sM07wgJGS1vtVD9Uly7VtoFTi23c,221
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/899.f9b9f9bf705a6493.js,sha256=RNTIItG9k-A_Ip54fRR3QMCjiffkY0bo8zQ2Xh7TyOY,57096
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/935.46ecc6bf99aa593a.js,sha256=Cmp0KWM5YDZ-zcsJWWgqCMIF6adeHQH80rxz1sas45E,51183
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.109a3a8379365e59.js,sha256=4JavPLcn703qVSC2E1_MD1thrJNL4N-eITjnfNhSDSM,15066
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=LTlA3M58hwjqmhomdcrNRO9GM58zZcf0V76WX9HI6EQ,146
+calkit_python-0.48.1.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
+calkit_python-0.48.1.dist-info/METADATA,sha256=91q0lRwvRNsd6Pri_L1zXu-N3_DvupV4gKF3RAKc_qE,22044
+calkit_python-0.48.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+calkit_python-0.48.1.dist-info/entry_points.txt,sha256=TtpHpcv2vFVAVYxFVp0XrwCV_z7FWIOguEiypXRDoOw,131
+calkit_python-0.48.1.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
+calkit_python-0.48.1.dist-info/RECORD,,