calkit-python 0.47.0__tar.gz → 0.47.1__tar.gz

{calkit_python-0.47.0 → calkit_python-0.47.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: calkit-python
-Version: 0.47.0
+Version: 0.47.1
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -26,6 +26,7 @@ Requires-Dist: arithmeval
 Requires-Dist: bibtexparser
 Requires-Dist: checksumdir
 Requires-Dist: docx2pdf
+Requires-Dist: dulwich>=1.2.5
 Requires-Dist: dvc[all]==3.67.1
 Requires-Dist: fastapi
 Requires-Dist: fsspec>=2026.4.0

{calkit_python-0.47.0 → calkit_python-0.47.1}/calkit/cli/check.py

@@ -2060,20 +2060,32 @@ def check_questions(
     json_output: Annotated[
         bool, typer.Option("--json", help="Output the report as JSON.")
     ] = False,
+    no_pipeline: Annotated[
+        bool,
+        typer.Option(
+            "--no-pipeline",
+            help="Skip asking DVC which stages are out of date, which is "
+            "the slowest part of the check.",
+        ),
+    ] = False,
 ) -> None:
-    """Check that answered questions are consistent with their evidence.
-
-    A question is stale if any of its evidence changed after the commit
-    that last edited the question, in Git history for Git-tracked outputs
-    or in dvc.lock for DVC-tracked ones. Evidence paths must exist, value
-    keys must resolve, every placeholder in the text must render, and a
-    publication label must still be present in the LaTeX source. Exits
-    with an error if any answered question is stale or broken.
+    """Check that answered questions are backed by current evidence.
+
+    Reports, worst first: evidence that isn't there (never run, never
+    pushed, or pinned to a Git ref that doesn't exist); broken references
+    (a key that doesn't resolve, a placeholder that names no evidence, a
+    label missing from the LaTeX); evidence the pipeline would rebuild;
+    and evidence from a frozen stage, or downstream of one, which nothing
+    will ever report out of date unless the citation pins a git_ref.
+
+    Evidence pinned with a git_ref is checked at that ref rather than in
+    the working tree. Exits with an error if any answered question is
+    missing evidence, broken, or out of date with the pipeline.
     """
     from calkit.questions import check_questions as _check_questions
     from calkit.questions import format_status
 
-    status = _check_questions(wdir=wdir)
+    status = _check_questions(wdir=wdir, check_pipeline=not no_pipeline)
     if json_output:
         calkit.echo(json.dumps(status.model_dump(mode="json"), indent=2))
     else:

{calkit_python-0.47.0 → calkit_python-0.47.1}/calkit/detect.py

@@ -1773,40 +1773,119 @@ def detect_r_dependencies(
 def detect_julia_dependencies(
     script_path: str | None = None,
     code: str | None = None,
+    script_dir: str | None = None,
+    project_dir: str = ".",
 ) -> list[str]:
     """Detect package dependencies from a Julia script or code string.
 
+    Julia's ``include`` splices a file in as source text, so any package used
+    by an included file must be declared by the project that includes it.
+    Includes with a literal path that resolve inside the project are therefore
+    followed. Ones pointing outside it are not, since that code declares its
+    dependencies in its own project file, e.g., a package's own source in the
+    depot reached via ``pkgdir``.
+
     Parameters
     ----------
     script_path : str | None
         Path to Julia script. Either this or code must be provided.
     code : str | None
         Julia code string. Either this or script_path must be provided.
+    script_dir : str | None
+        Directory the code came from, against which its includes resolve.
+        Only used with ``code``; defaults to ``project_dir``.
+    project_dir : str
+        Project root, outside of which includes are not followed.
 
     Returns
     -------
     list[str]
         List of Julia package names.
     """
+
+    def parse_dependencies(code: str) -> set[str]:
+        deps = set()
+        # Both `using` and `import` load a package, either can start a line or
+        # follow a semicolon, and either can be prefixed by macros, e.g.,
+        # `@everywhere using Foo`
+        clauses = re.findall(
+            r"(?:^|;)[ \t]*(?:@[A-Za-z_][A-Za-z0-9_!]*[ \t]+)*"
+            r"(?:using|import)[ \t]+([^\n;]+)",
+            code,
+            flags=re.MULTILINE,
+        )
+        for clause in clauses:
+            # In `using Foo: bar, baz` only what precedes the colon is a
+            # package
+            clause = clause.split(":")[0]
+            for part in clause.split(","):
+                # Drop an `as` alias, e.g., `import Foo as F`
+                name = re.split(r"\s+as\s+", part.strip())[0].strip()
+                # A leading dot means a module local to this file, not a
+                # package
+                if not name or name.startswith("."):
+                    continue
+                # Submodules like `Foo.Bar` come from the `Foo` package
+                name = name.split(".")[0]
+                if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_!]*", name):
+                    continue
+                if name in ("Base", "Core", "Main"):
+                    continue
+                deps.add(name)
+        return deps
+
+    def find_includes(code: str, from_dir: str) -> list[str]:
+        paths = []
+        for match in re.findall(
+            r'include\s*\(\s*["\']([^"\']+\.jl)["\']\s*\)', code
+        ):
+            if os.path.isabs(match):
+                continue
+            path = os.path.realpath(os.path.join(from_dir, match))
+            if not path.startswith(root + os.sep) or not os.path.isfile(path):
+                continue
+            paths.append(path)
+        return paths
+
+    def read(path: str) -> str | None:
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return f.read()
+        except (UnicodeDecodeError, IOError):
+            return None
+
     if script_path is None and code is None:
         raise ValueError("Either script_path or code must be provided")
+    root = os.path.realpath(project_dir)
     if code is None:
         assert script_path is not None  # Type guard
         if not os.path.exists(script_path):
             return []
-        try:
-            with open(script_path, "r", encoding="utf-8") as f:
-                code = f.read()
-        except (UnicodeDecodeError, IOError):
+        code = read(script_path)
+        if code is None:
             return []
-    assert code is not None  # Type guard
-    dependencies = set()
+        from_dir = os.path.dirname(script_path) or "."
+        seen = {os.path.realpath(script_path)}
+    else:
+        from_dir = script_dir if script_dir is not None else project_dir
+        seen = set()
     # Remove comments
     code = re.sub(r"#.*$", "", code, flags=re.MULTILINE)
-    # Pattern for using statements
-    pattern = r"using\s+([a-zA-Z0-9._]+)"
-    matches = re.findall(pattern, code)
-    dependencies.update(matches)
+    dependencies = parse_dependencies(code)
+    # Walk the include tree, resolving each file's includes against its own
+    # directory the way Julia does
+    queue = find_includes(code, from_dir)
+    while queue:
+        path = queue.pop(0)
+        if path in seen:
+            continue
+        seen.add(path)
+        included = read(path)
+        if included is None:
+            continue
+        included = re.sub(r"#.*$", "", included, flags=re.MULTILINE)
+        dependencies |= parse_dependencies(included)
+        queue += find_includes(included, os.path.dirname(path))
     return sorted(list(dependencies))
 
 
@@ -1855,7 +1934,10 @@ def detect_dependencies_from_notebook(
     if language == "python":
         return detect_python_dependencies(code=combined_code)
     elif language == "julia":
-        return detect_julia_dependencies(code=combined_code)
+        return detect_julia_dependencies(
+            code=combined_code,
+            script_dir=os.path.dirname(notebook_path) or ".",
+        )
     elif language == "r":
         return detect_r_dependencies(code=combined_code)
     return []

{calkit_python-0.47.0 → calkit_python-0.47.1}/calkit/docker.py

@@ -14,7 +14,7 @@ from pydantic import BaseModel
 MINIFORGE_LAYER_TXT = r"""
 # Install Miniforge
 ARG MINIFORGE_NAME=Miniforge3
-ARG MINIFORGE_VERSION=24.9.2-0
+ARG MINIFORGE_VERSION=26.7.2-0
 ARG TARGETPLATFORM
 
 ENV CONDA_DIR=/opt/conda
@@ -51,24 +51,26 @@ RUN apt-get update > /dev/null && \
     echo ". ${CONDA_DIR}/etc/profile.d/conda.sh && conda activate base" >> ~/.bashrc
 """.strip()
 
+# foamPy ships only an sdist whose setup.py imports numpy, so it needs the
+# surrounding environment rather than an isolated build one
 FOAMPY_LAYER_TEXT = r"""
 RUN pip install --no-cache-dir numpy pandas matplotlib h5py \
     && pip install --no-cache-dir scipy \
-    && pip install --no-cache-dir foampy
+    && pip install --no-cache-dir --no-build-isolation foampy
 """.strip()
 
 UV_LAYER_TEXT = """
-COPY --from=ghcr.io/astral-sh/uv:0.8.5 /uv /uvx /bin/
+COPY --from=ghcr.io/astral-sh/uv:0.12.11 /uv /uvx /bin/
 """
 
 JULIA_LAYER_TEXT = """
 # Install Julia
-# Ensure base image is a bullseye distribution
-COPY --from=julia:1.11.6-bullseye /usr/local/julia /usr/local/julia
+# Ensure base image is a bookworm distribution
+COPY --from=julia:1.11.9-bookworm /usr/local/julia /usr/local/julia
 ENV JULIA_PATH=/usr/local/julia \
     PATH=$PATH:/usr/local/julia/bin \
     JULIA_GPG=3673DF529D9049477F76B37566E3C7DC03D6E495 \
-    JULIA_VERSION=1.11.6
+    JULIA_VERSION=1.11.9
 """
 
 LAYERS = {

{calkit_python-0.47.0 → calkit_python-0.47.1}/calkit/models/core.py

@@ -1689,6 +1689,13 @@ class FigureEvidence(BaseModel):
     kind: Literal["figure"] = "figure"
     path: str
     explanation: str | None = None
+    git_ref: str | None = Field(
+        default=None,
+        description=(
+            "Git reference (branch, tag, or commit hash) pointing to the "
+            "version of the repository where the figure can be found."
+        ),
+    )
 
 
 class ResultsEvidence(BaseModel):
@@ -1707,6 +1714,13 @@ class ResultsEvidence(BaseModel):
         ),
     )
     explanation: str | None = None
+    git_ref: str | None = Field(
+        default=None,
+        description=(
+            "Git reference (branch, tag, or commit hash) pointing to the "
+            "version of the repository where the result can be found."
+        ),
+    )
 
 
 _KEY_DESCRIPTION = (
@@ -1738,6 +1752,13 @@ class ValueEvidence(BaseModel):
         ),
     )
     explanation: str | None = None
+    git_ref: str | None = Field(
+        default=None,
+        description=(
+            "Git reference (branch, tag, or commit hash) pointing to the "
+            "version of the repository where the value can be found."
+        ),
+    )
 
 
 class TableEvidence(BaseModel):
@@ -1746,6 +1767,13 @@ class TableEvidence(BaseModel):
     kind: Literal["table"] = "table"
     path: str
     explanation: str | None = None
+    git_ref: str | None = Field(
+        default=None,
+        description=(
+            "Git reference (branch, tag, or commit hash) pointing to the "
+            "version of the repository where the table can be found."
+        ),
+    )
 
 
 class PublicationEvidence(BaseModel):
@@ -1777,6 +1805,13 @@ class PublicationEvidence(BaseModel):
         ),
     )
     explanation: str | None = None
+    git_ref: str | None = Field(
+        default=None,
+        description=(
+            "Git reference (branch, tag, or commit hash) pointing to the "
+            "version of the repository where the publication can be found."
+        ),
+    )
 
 
 class Question(BaseModel):

{calkit_python-0.47.0 → calkit_python-0.47.1}/calkit/pipeline.py

@@ -59,6 +59,79 @@ def frozen_stage_base_names(
     return names
 
 
+def frozen_tainted_stage_names(
+    ck_info: dict | None = None, wdir: str | None = None
+) -> set[str]:
+    """Base names of frozen stages, plus every stage downstream of one.
+
+    A frozen stage doesn't re-run when its inputs change, so DVC never calls
+    it out of date -- and never calls anything built from its outputs out of
+    date either. Nothing in a status report will say so, which is the point
+    of naming them here: an answer resting on one of those outputs is
+    resting on whatever the stage last happened to produce.
+
+    Read from ``dvc.lock`` where there is one, since its deps and outs are
+    concrete, falling back to ``dvc.yaml``. Names come back without their
+    ``@`` expansion, matching :func:`frozen_stage_base_names`.
+    """
+    if ck_info is None:
+        ck_info = calkit.load_calkit_info(wdir=wdir)
+    tainted = frozen_stage_base_names(ck_info=ck_info, wdir=wdir)
+    if not tainted:
+        return set()
+    stages: dict = {}
+    for fname in ("dvc.lock", "dvc.yaml"):
+        fpath = os.path.join(wdir or ".", fname)
+        if os.path.isfile(fpath):
+            try:
+                with open(fpath, encoding="utf-8") as f:
+                    stages = (calkit.ryaml.load(f) or {}).get("stages") or {}
+            except Exception:
+                stages = {}
+            if stages:
+                break
+    if not stages:
+        return tainted
+
+    def _paths(stage: object, key: str) -> list[str]:
+        if not isinstance(stage, dict):
+            return []
+        out = []
+        for item in stage.get(key) or []:
+            path = item.get("path") if isinstance(item, dict) else item
+            if isinstance(path, str):
+                out.append(path.rstrip("/"))
+        return out
+
+    producers: dict[str, set[str]] = {}
+    for name, stage in stages.items():
+        for path in _paths(stage, "outs"):
+            producers.setdefault(path, set()).add(name.split("@")[0])
+    # A dep matches an out either way around the directory: a stage writing
+    # ``figures`` feeds one reading ``figures/x.png``, and one writing
+    # ``figures/x.png`` feeds one reading the whole ``figures`` directory.
+    consumers: dict[str, set[str]] = {}
+    for name, stage in stages.items():
+        base = name.split("@")[0]
+        for dep in _paths(stage, "deps"):
+            for out, names in producers.items():
+                if (
+                    out == dep
+                    or dep.startswith(out + "/")
+                    or out.startswith(dep + "/")
+                ):
+                    for producer in names:
+                        if producer != base:
+                            consumers.setdefault(producer, set()).add(base)
+    queue = list(tainted)
+    while queue:
+        for consumer in consumers.get(queue.pop(), set()):
+            if consumer not in tainted:
+                tainted.add(consumer)
+                queue.append(consumer)
+    return tainted
+
+
 class PipelineStatus(BaseModel):
     """Current status of the project pipeline."""