calkit-python 0.48.2__py3-none-any.whl → 0.48.3__py3-none-any.whl

calkit/calc.py

@@ -4,14 +4,20 @@ from __future__ import annotations
 
 from typing import Annotated, Literal
 
-from pydantic import BaseModel, Discriminator, model_validator
+from pydantic import BaseModel, ConfigDict, Discriminator, model_validator
 
 DTYPES = {"int": int, "float": float, "str": str}
 DEFAULT_IN_TYPE = "float"
 DEFAULT_OUT_TYPE = "float"
 
 
-class Input(BaseModel):
+class _Model(BaseModel):
+    # As calkit.models.base.Model, which importing here would import
+    # calkit.models, which imports this
+    model_config = ConfigDict(defer_build=True)
+
+
+class Input(_Model):
     name: str
     description: str | None = None
     dtype: Literal["int", "float", "str"] = DEFAULT_IN_TYPE
@@ -19,14 +25,14 @@ class Input(BaseModel):
     max: int | float | None = None
 
 
-class Output(BaseModel):
+class Output(_Model):
     name: str
     description: str | None = None
     dtype: Literal["int", "float", "str"] = DEFAULT_OUT_TYPE
     template: str | None = None
 
 
-class Calculation(BaseModel):
+class Calculation(_Model):
     kind: str
     params: dict = {}
     name: str | None = None
@@ -124,7 +130,7 @@ class Calculation(BaseModel):
         return template.format(**(inputs | {out_name: res}))
 
 
-class FormulaParams(BaseModel):
+class FormulaParams(_Model):
     formula: str
 
 
@@ -139,7 +145,7 @@ class Formula(Calculation):
         return arithmetic_eval.evaluate(self.params.formula, inputs)
 
 
-class LinearParams(BaseModel):
+class LinearParams(_Model):
     coeffs: dict[str, float]
     offset: float = 0.0
 
@@ -163,7 +169,7 @@ class Linear(Calculation):
         return val
 
 
-class LookupTableParams(BaseModel):
+class LookupTableParams(_Model):
     x_values: list[float]
     y_values: list[float]
     method: Literal["floor", "ceil", "round", "interpolate"] = "interpolate"
@@ -176,7 +182,7 @@ class LookupTable(Calculation):
     params: LookupTableParams
 
 
-class HttpRequestParams(BaseModel):
+class HttpRequestParams(_Model):
     url: str
     inputs_as_params: bool = True  # Otherwise, use body
     method: Literal["get", "post", "put"] = "get"
@@ -210,7 +216,7 @@ class HttpRequest(Calculation):
             return resp.text
 
 
-class XGBoostModelParams(BaseModel):
+class XGBoostModelParams(_Model):
     path: str
     type: Literal["classifier", "regressor"]
 

calkit/cli/check.py

@@ -2026,6 +2026,95 @@ def check_pipeline(
             )
 
 
+@check_app.command(name="storage")
+def check_storage(
+    fix: Annotated[
+        bool,
+        typer.Option(
+            "--fix", help="Move each path to where it's declared to be stored."
+        ),
+    ] = False,
+    as_json: Annotated[
+        bool, typer.Option("--json", help="Output the problems as JSON.")
+    ] = False,
+) -> None:
+    """Check that paths are tracked where they're declared to be stored.
+
+    That is, nothing is tracked by both Git and DVC, no pipeline output
+    stored in Git is ignored by it, and nothing in Git is too large for it.
+    With --fix, the pipeline's declarations, or a file's .dvc file, decide
+    where each path belongs, and the changes are staged.
+    """
+    import calkit.dvc
+    import calkit.git
+    import calkit.pipeline
+
+    if fix and as_json:
+        raise_error("--json can't be used with --fix")
+    problems = calkit.dvc.get_storage_problems()
+    if as_json:
+        typer.echo(json.dumps(problems, indent=2))
+    if not fix:
+        if not as_json:
+            for problem in problems:
+                warn(problem["message"])
+        if any(p["kind"] != "large" for p in problems):
+            if not as_json:
+                typer.echo("Run 'calkit check storage --fix' to fix these")
+            raise typer.Exit(1)
+        if not problems and not as_json:
+            calkit.echo("✅ Every path is stored where it's declared to be")
+        return
+    repo = calkit.git.get_repo()
+    gitignores = calkit.git.get_dirty_gitignores(repo)
+    fixed = []
+    unfixed = []
+    # Pipeline outputs are recorded in DVC, which records their stages'
+    # inputs too, so only for stages that are up to date
+    to_record = []
+    for problem in problems:
+        path = os.path.abspath(problem["path"])
+        if problem["store_in"] == "dvc":
+            repo.git.rm("-r", "-q", "--cached", "--", path)
+            calkit.git.ensure_path_is_ignored(repo, path)
+            if problem["kind"] == "both":
+                to_record.append(problem)
+        elif problem["store_in"] == "git":
+            calkit.git.ensure_path_is_not_ignored(repo, path)
+            repo.git.add("--", path)
+        else:
+            unfixed.append(problem)
+            continue
+        fixed.append(problem)
+        typer.echo(f"Fixed: {problem['message']}")
+    # None when it can't be told which are stale, so none are recorded
+    stale: set[str] | None = set()
+    if any(p["stage"] for p in to_record):
+        status = calkit.pipeline.get_status(
+            check_environments=False, clean_notebooks=False
+        )
+        if not status.errors:
+            stale = {n.split("@")[0] for n in status.stale_stage_names}
+        else:
+            stale = None
+    for problem in to_record:
+        stage = problem["stage"]
+        if stage and (stale is None or stage.split("@")[0] in stale):
+            typer.echo(f"Run '{stage}' to record {problem['path']} in DVC")
+            continue
+        target = problem["dvc_file"] or stage
+        if calkit.dvc.run_dvc_command(["commit", "-f", "-q", target]) != 0:
+            warn(f"Couldn't record {problem['path']} in DVC")
+    for message in calkit.git.stage_gitignores(repo, gitignores):
+        warn(message)
+    for problem in unfixed:
+        warn(problem["message"])
+    if fixed:
+        typer.echo("Commit the staged changes")
+    if any(p["kind"] != "large" for p in unfixed):
+        raise typer.Exit(1)
+
+
 @check_app.command(name="call")
 def check_call(
     cmd: Annotated[str, typer.Argument(help="Command to check.")],
@@ -2082,8 +2171,9 @@ def check_questions(
     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.
+    and evidence from a frozen stage, or downstream of one, that no longer
+    matches dvc.lock, which won't be rerun, unless the citation pins a
+    git_ref. Subprojects' questions are checked too.
 
     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

calkit/cli/describe.py

@@ -9,7 +9,6 @@ import typer
 
 import calkit
 from calkit.cli import AliasGroup, echo_json, raise_error
-from calkit.environments import get_env_lock_fpath
 
 describe_app = typer.Typer(cls=AliasGroup, no_args_is_help=True)
 
@@ -20,6 +19,10 @@ def _describe_env(env: dict, env_name: str) -> dict:
     The keys here are a stable contract for tools consuming ``--json``, so
     they are always present, even if their value is null.
     """
+    # Here rather than at the top, since every command imports this module;
+    # what that saves is a question in decisions/calkit.yaml
+    from calkit.environments import get_env_lock_fpath
+
     return {
         "kind": env.get("kind"),
         "spec_path": env.get("path"),

calkit/cli/latex.py

@@ -328,8 +328,10 @@ def from_markdown(
         if "://" not in hub:
             hub = "https://" + hub
         project_url = f"{hub}/{ck_info['owner']}/{ck_info['name']}"
-    # A local version's commit is the project's own, which isn't Calkit's
-    version = calkit.__version__.split("+")[0]
+    # A local version's commit is the project's own, which isn't Calkit's,
+    # and a development build's count of commits since the last release
+    # changes with every commit, which would change the PDF on every rebuild
+    version = re.sub(r"\.dev\d+$", ".dev", calkit.__version__.split("+")[0])
     with open(md_path, encoding="utf-8") as f:
         text = f.read()
     try:
@@ -2008,6 +2010,11 @@ def to_docx(
             return out
 
         existing = listing() - {job + ".bbl"}
+        # Dated like the PDF, so \today matches it and a rebuild of an
+        # unchanged source doesn't change
+        tex_env_vars = _tex_env_vars(
+            calkit.latex.get_source_date_epoch(source)
+        )
         # TeX can loop forever, e.g., older TeX4ht on a cases environment,
         # so a run gets a time limit, and loses its LaTeX child with it
         import time
@@ -2021,6 +2028,7 @@ def to_docx(
                 proc = subprocess.Popen(
                     m4h,
                     cwd=src_dir,
+                    env=os.environ | tex_env_vars,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.STDOUT,
                     start_new_session=sys.platform != "win32",
@@ -2053,6 +2061,7 @@ def to_docx(
                         no_check=True,
                         verbose=False,
                         dep="make4ht",
+                        env_vars=tex_env_vars,
                     ),
                     stdout=subprocess.PIPE,
                     stderr=subprocess.STDOUT,
@@ -2571,7 +2580,20 @@ def to_docx(
         dirty = any(repo.is_dirty(path=p) for p in {ln.path for ln in lines})
     except Exception:
         pass
-    export_id = str(uuid.uuid4())
+    # At random, so each export can be told apart, unless the build is asked
+    # to be reproducible, in which case it comes from what was exported
+    if os.environ.get("SOURCE_DATE_EPOCH"):
+        doc.save()
+        export_id = str(
+            uuid.uuid5(
+                uuid.NAMESPACE_URL,
+                json.dumps(
+                    [calkit.get_md5(output), rev, source, original, equations]
+                ),
+            )
+        )
+    else:
+        export_id = str(uuid.uuid4())
     doc.write_original(
         calkit.docx.Original(
             export_id,

calkit/cli/main/core.py

@@ -589,6 +589,7 @@ def get_status(
             clean_notebooks=True,
             compile_to_dvc=True,
             with_data_status="dvc" in categories,
+            with_storage_problems="dvc" in categories,
         )
         if pipeline_status.failed_environment_checks:
             warn(
@@ -629,6 +630,17 @@ def get_status(
             frozen_stages=frozen_stages,
             check_history=False,
         )
+    # Paths tracked where they shouldn't be, found with the pipeline's status,
+    # which builds the DVC index this needs anyway, unless it stopped short
+    storage_problems = None
+    if "dvc" in categories and running_status is None:
+        if pipeline_status is not None:
+            storage_problems = pipeline_status.storage_problems
+        if storage_problems is None:
+            try:
+                storage_problems = calkit.dvc.get_storage_problems()
+            except Exception:
+                pass
     if as_json:
         status_dict: dict[str, Any] = {}
         if "project" in categories:
@@ -694,6 +706,7 @@ def get_status(
                 )
             except Exception as e:
                 status_dict["dvc"] = {"error": f"{e.__class__.__name__}: {e}"}
+            status_dict["storage"] = storage_problems
         if "pipeline" in categories or "dvc" in categories:
             if running_status is not None:
                 status_dict["pipeline"] = running_status
@@ -760,6 +773,10 @@ def get_status(
             raw.pop("git", None)
             raw = calkit.dvc.data_status_as_posix(raw)
             typer.echo(_format_dvc_data_status(raw, zip_path_map))
+            for problem in storage_problems or []:
+                warn(problem["message"])
+            if storage_problems:
+                typer.echo("Run 'calkit check storage' for detail.\n")
     if "pipeline" in categories or "dvc" in categories:
         print_sep("Pipeline")
         if running_status is not None:
@@ -1011,6 +1028,22 @@ def add(
         )
         repo.git.add(".dvc/config")
     dvc_paths = [] if dvc_repo is None else calkit.dvc.list_paths()
+    pipeline_output_storage = calkit.pipeline.get_output_storage_map()
+    # An ignore rule left on an output stored in Git, e.g., by an older
+    # Calkit, would hide its new files from everything below
+    for out in calkit.git.get_ignored_by_rule(
+        repo,
+        *[
+            out
+            for out, storage in pipeline_output_storage.items()
+            if storage == "git" and os.path.exists(out)
+        ],
+    ):
+        if dry_run:
+            typer.echo(f"Would un-ignore {out} since it's stored in Git")
+        else:
+            typer.echo(f"Un-ignoring {out} since it's stored in Git")
+            calkit.git.ensure_path_is_not_ignored(repo, out)
     untracked_git_files = repo.untracked_files
     if auto_commit_message:
         # See if this path is in the repo already
@@ -1118,12 +1151,31 @@ def add(
             ]:
                 paths.append(changed_file)
         zip_path_map = calkit.dvc.zip.get_zip_path_map()
-        pipeline_output_storage = calkit.pipeline.get_output_storage_map()
         lock_out_paths = calkit.dvc.get_lock_out_paths()
+        cached_out_paths: set[str] | None = None
         dvc_scm = None
         for path in paths:
             # Check if this path is already registered as a zip
             posix_path = Path(path).as_posix()
+            # A file inside an output stored in Git, e.g., one written to a
+            # persistent output directory, goes to Git like the output does
+            output_storage = pipeline_output_storage.get(posix_path)
+            if output_storage is None and any(
+                posix_path.startswith(out + "/")
+                for out, storage in pipeline_output_storage.items()
+                if storage == "git"
+            ):
+                output_storage = "git"
+            locked_out = next(
+                (
+                    out
+                    for out in lock_out_paths
+                    if posix_path == out or posix_path.startswith(out + "/")
+                ),
+                None,
+            )
+            if locked_out is not None and cached_out_paths is None:
+                cached_out_paths = calkit.dvc.get_cached_out_paths()
             if posix_path in zip_path_map:
                 if dry_run:
                     typer.echo(f"Would add {path} via DVC zip")
@@ -1155,10 +1207,9 @@ def add(
                     )
                     calkit.git.ensure_dvc_pointer_is_not_ignored(repo, path)
                     calkit.dvc.run_dvc_command(["add", path])
-            elif posix_path in pipeline_output_storage:
+            elif output_storage is not None:
                 # Respect storage explicitly set in the pipeline definition
-                pipeline_storage = pipeline_output_storage[posix_path]
-                if pipeline_storage == "git":
+                if output_storage == "git":
                     if dry_run:
                         typer.echo(
                             f"Would add {path} to Git "
@@ -1169,7 +1220,7 @@ def add(
                             f"Adding {path} to Git per pipeline output storage"
                         )
                         git_add(path)
-                elif pipeline_storage == "dvc-zip":
+                elif output_storage == "dvc-zip":
                     if dry_run:
                         typer.echo(
                             f"Would add {path} as a DVC zip "
@@ -1193,22 +1244,13 @@ def add(
                             f"({path} is a DVC pipeline output)"
                         )
                         git_add("dvc.lock")
-            elif (
-                locked_out := next(
-                    (
-                        out
-                        for out in lock_out_paths
-                        if posix_path == out
-                        or posix_path.startswith(out + "/")
-                    ),
-                    None,
-                )
-            ) is not None:
+            elif locked_out in (cached_out_paths or set()):
                 # DVC already caches this, and it's only showing up at all
                 # because its ignore entry went missing, e.g., DVC removes
                 # every entry a failed repro added, including those for the
                 # stages that succeeded. Sized up like a new file, a small
-                # one would go to Git alongside DVC's copy.
+                # one would go to Git alongside DVC's copy. Outputs DVC
+                # doesn't cache were never ignored, so they don't count.
                 if dry_run:
                     typer.echo(
                         f"Would ignore {path} ({path} is a DVC pipeline output)"

calkit/cli/update.py

@@ -1356,6 +1356,239 @@ def update_figure(
     calkit.save_calkit_info(ck_info)
 
 
+@update_app.command(name="path-storage")
+def update_path_storage(
+    paths: Annotated[
+        list[str],
+        typer.Argument(help="Files or directories to move, from the project."),
+    ],
+    to: Annotated[
+        str,
+        typer.Option("--to", "-t", help="Where to store them: git or dvc."),
+    ],
+) -> None:
+    """Move paths between Git and DVC storage without rerunning anything.
+
+    A pipeline output's storage is changed where the pipeline declares it,
+    e.g., an output's 'storage' or a LaTeX stage's 'pdf_storage', and a file
+    added on its own is added again with the other system. Either way it's
+    untracked from where it was, so it isn't left in both. The tracking
+    changes are staged, and calkit.yaml and dvc.yaml are left to commit.
+    """
+    from pathlib import Path
+
+    from ruamel.yaml.comments import CommentedMap
+
+    import calkit.dvc
+    import calkit.dvc.zip
+    import calkit.git
+    import calkit.pipeline
+    from calkit.models.pipeline import Pipeline
+
+    def storage_key(stage_name: str, stage: dict, path: str) -> str | None:
+        # The key in a stage's definition that sets this path's storage, if
+        # the stage produces it, whether declared or implied by its kind
+        def here(stage_path: str) -> str:
+            # A stage's paths are relative to its working directory
+            joined = os.path.join(stage.get("wdir") or "", stage_path)
+            return Path(os.path.normpath(joined)).as_posix()
+
+        for n, out in enumerate(stage.get("outputs") or []):
+            out_path = out if isinstance(out, str) else out.get("path")
+            if out_path is None or here(out_path) != path:
+                continue
+            if isinstance(out, dict) and out.get("storage") == "dvc-zip":
+                raise_error(f"{path} is stored zipped, which can't move yet")
+            return f"outputs.{n}"
+        try:
+            model = Pipeline.model_validate(
+                {"stages": {stage_name: stage}}
+            ).stages[stage_name]
+        except Exception:
+            return None
+        log = model.scheduler_log_output
+        if log is not None and here(log.path) == path:
+            raise_error(
+                f"{path} is the scheduler log of '{stage_name}', which can't "
+                "move yet; set its log_storage in calkit.yaml"
+            )
+        implied = {
+            "pdf_path": "pdf_storage",
+            "cleaned_notebook_path": "cleaned_ipynb_storage",
+            "executed_notebook_path": "executed_ipynb_storage",
+            "html_path": "html_storage",
+            "output_dir": "output_storage",
+        }
+        for attr, key in implied.items():
+            value = getattr(model, attr, None)
+            if (
+                key in type(model).model_fields
+                and isinstance(value, str)
+                and here(value) == path
+            ):
+                return key
+        return None
+
+    def set_storage(stage_name: str, stage: dict, key: str) -> None:
+        # Back to the default rather than spelled out where it can be
+        if key.startswith("outputs."):
+            n = int(key.split(".")[1])
+            out = stage["outputs"][n]
+            if isinstance(out, str):
+                out = CommentedMap(path=out)
+            out["storage"] = to
+            if to == "dvc" and set(out) <= {"path", "storage"}:
+                out = out["path"]
+            stage["outputs"][n] = out
+            return
+        model = Pipeline.model_validate({"stages": {stage_name: stage}})
+        field = type(model.stages[stage_name]).model_fields[key]
+        if field.default == to:
+            stage.pop(key, None)
+        else:
+            stage[key] = to
+
+    # Git runs from the repo root, which may be above the project, so it's
+    # given absolute paths
+    def in_git(path: str) -> bool:
+        return bool(repo.git.ls_files("--", os.path.abspath(path)).strip())
+
+    def dvc(*args: str) -> None:
+        if calkit.dvc.run_dvc_command(list(args)) != 0:
+            raise_error(f"'dvc {' '.join(args)}' failed")
+
+    if to not in ["git", "dvc"]:
+        raise_error(f"Storage must be git or dvc, not '{to}'")
+    repo = calkit.git.get_repo()
+    ck_info = calkit.load_calkit_info()
+    stages = (ck_info.get("pipeline") or {}).get("stages") or {}
+    # Each path with the stage and key that declare its storage, if any
+    outputs: dict[str, tuple[str, str]] = {}
+    others: list[str] = []
+    zipped = calkit.dvc.zip.get_zip_path_map()
+    # What DVC tracks, and the stage producing each, if any, to catch a path
+    # inside one, or from a stage whose storage calkit.yaml doesn't declare
+    dvc_repo = calkit.dvc.get_dvc_repo()
+    dvc_outs = [
+        (
+            Path(out.fs_path).resolve(),
+            None if out.stage.is_data_source else out.stage.addressing,
+        )
+        for out in dvc_repo.index.outs
+    ]
+    dvc_repo.close()
+    for raw in paths:
+        path = Path(os.path.normpath(raw)).as_posix()
+        if not os.path.exists(path):
+            raise_error(f"{path} isn't here; run 'calkit pull' first")
+        for stage_name, stage in stages.items():
+            key = (
+                storage_key(stage_name, stage, path)
+                if isinstance(stage, dict)
+                else None
+            )
+            if key is not None:
+                if stage.get("iterate_over"):
+                    raise_error(
+                        f"{path} comes from '{stage_name}', which iterates; "
+                        "set its storage in calkit.yaml instead"
+                    )
+                outputs[path] = (stage_name, key)
+                break
+        else:
+            if path in zipped:
+                raise_error(f"{path} is stored zipped, which can't move yet")
+            abs_path = Path(path).resolve()
+            for out_path, producer in dvc_outs:
+                out_rel = Path(os.path.relpath(out_path)).as_posix()
+                if abs_path == out_path and producer is not None:
+                    raise_error(
+                        f"{path} comes from DVC stage '{producer}', whose "
+                        "storage can't be set here"
+                    )
+                if abs_path != out_path and (
+                    abs_path.is_relative_to(out_path)
+                    or out_path.is_relative_to(abs_path)
+                ):
+                    raise_error(
+                        f"{path} overlaps {out_rel}, which DVC tracks as a "
+                        "whole; move that instead"
+                    )
+            others.append(path)
+    gitignores = calkit.git.get_dirty_gitignores(repo)
+    # Recording an output in DVC records its stage's inputs too, which would
+    # pass off a stage that's out of date as current, so the pipeline as
+    # calkit.yaml has it now must be known to be up to date
+    if outputs and to == "dvc":
+        status = calkit.pipeline.get_status(
+            ck_info=ck_info, check_environments=False, clean_notebooks=False
+        )
+        if status.errors:
+            raise_error(
+                "Couldn't tell whether the stages producing these are up "
+                "to date: " + "; ".join(status.errors)
+            )
+        stale = {name.split("@")[0] for name in status.stale_stage_names}
+        for path, (stage_name, _) in outputs.items():
+            if stage_name in stale:
+                raise_error(
+                    f"Stage '{stage_name}', which produces {path}, is out "
+                    "of date; run it first"
+                )
+    if outputs:
+        for path, (stage_name, key) in outputs.items():
+            set_storage(stage_name, stages[stage_name], key)
+        calkit.save_calkit_info(ck_info)
+        calkit.pipeline.to_dvc(ck_info=ck_info, write=True)
+    for path, (stage_name, _) in outputs.items():
+        if to == "dvc":
+            if in_git(path):
+                repo.git.rm(
+                    "-r", "-q", "--cached", "--", os.path.abspath(path)
+                )
+        else:
+            calkit.git.ensure_path_is_not_ignored(repo, os.path.abspath(path))
+            repo.git.add("--", os.path.abspath(path))
+    if to == "dvc":
+        # Into the cache, and ignored by Git, without running anything
+        for stage_name in dict.fromkeys(s for s, _ in outputs.values()):
+            dvc("commit", "-f", "-q", stage_name)
+    for path in others:
+        pointer = f"{path}.dvc"
+        if to == "dvc":
+            # Which also repairs a file DVC tracks that Git does too
+            if in_git(path):
+                repo.git.rm(
+                    "-r", "-q", "--cached", "--", os.path.abspath(path)
+                )
+            if os.path.isfile(pointer):
+                calkit.git.ensure_path_is_ignored(repo, os.path.abspath(path))
+            else:
+                dvc("add", "-q", path)
+            repo.git.add("--", os.path.abspath(pointer))
+        else:
+            if os.path.isfile(pointer):
+                tracked = in_git(pointer)
+                dvc("remove", "-q", pointer)
+                if tracked:
+                    repo.git.add("-A", "--", os.path.abspath(pointer))
+            calkit.git.ensure_path_is_not_ignored(repo, os.path.abspath(path))
+            repo.git.add("--", os.path.abspath(path))
+    for message in calkit.git.stage_gitignores(repo, gitignores):
+        warn(message)
+    system = "Git" if to == "git" else "DVC"
+    for path in [*outputs, *others]:
+        typer.echo(f"{path} is now stored in {system}")
+    if outputs:
+        typer.echo(
+            "Commit calkit.yaml and dvc.yaml along with the staged changes"
+        )
+    if to == "dvc":
+        typer.echo(
+            "Then 'calkit push' to send them to the project's DVC remote"
+        )
+
+
 @update_app.command(name="dataset")
 def update_dataset(
     path: Annotated[str, typer.Argument(help="Path to the dataset file.")],

calkit/docx.py

@@ -191,7 +191,13 @@ class Document:
             path or self.path, "w", zipfile.ZIP_DEFLATED
         ) as z:
             for name, data in self.parts.items():
-                z.writestr(name, data)
+                # Undated, as Word writes them, so the same content makes
+                # the same file
+                info = zipfile.ZipInfo(name)
+                # As written on Unix, which Windows would otherwise mark
+                info.create_system = 3
+                info.external_attr = 0o600 << 16
+                z.writestr(info, data, zipfile.ZIP_DEFLATED)
 
     @property
     def paragraphs(self) -> list[Paragraph]: