calkit-python 0.48.0__tar.gz → 0.48.1__tar.gz

{calkit_python-0.48.0 → calkit_python-0.48.1}/PKG-INFO

@@ -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 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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_python-0.48.0 → calkit_python-0.48.1}/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