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

calkit_python-0.48.3/.calkit/env-locks/tex/amd64.json

@@ -0,0 +1,27 @@
+{
+    "RepoDigests": [
+        "sha256:a6df16eb0634a94defc9c794f6a4a94addca2cc41857f2e89c4db332591676c0"
+    ],
+    "Architecture": "amd64",
+    "Os": "linux",
+    "RootFS": {
+        "Type": "layers",
+        "Layers": [
+            "sha256:d81fb2a7c6ee3be05fdefaa7fd223be219c1ab172083ec1b994c3ecda33ac0a8",
+            "sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef",
+            "sha256:05364db6671946629d30df5e2b0e64ac1ddf9584c850821e1310798b81dae7a6",
+            "sha256:eca883d1959b8c01c3803666dd78acfab745385c182f0134f57d6b13b0eaa5a8",
+            "sha256:b3f81a4dd621eb52ef44f1fd2708b2551d657e13f6ddcd08ebb07c072bff71ed",
+            "sha256:827badad9c1d1c760a817bd906551372d602a9d4f09326f36a91db0c97a8bad1",
+            "sha256:c9e8d9eec8adf285383a9342d7d3f5eb17ff30c83678505135caffe2d2685b1d",
+            "sha256:e2dcd8f807ab6625ede0dffebdd2280a48bdeba51fe464b5e8bceb15dd33d384",
+            "sha256:a7896112a0671141d2eb2860c8bf898f671bc9bdd32444d85a6cb0b11d095ded",
+            "sha256:a7080e7b80de5013eacc71c8d75a7160ff39e0f255a86138b0bbe2e7ed74a064",
+            "sha256:b29c7c1282fc0ab03ceb8cb5b0011ee14bdef43aa8a3f34a76d806f56dbeb41f",
+            "sha256:267d6598e62980803a111eaf396233bb26c552794580d0f9e3d622a717574e09",
+            "sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef"
+        ]
+    },
+    "DockerfileMD5": null,
+    "DepsMD5s": {}
+}

calkit_python-0.48.3/.calkit/env-locks/tex/arm64.json

@@ -0,0 +1,27 @@
+{
+    "RepoDigests": [
+        "sha256:a6df16eb0634a94defc9c794f6a4a94addca2cc41857f2e89c4db332591676c0"
+    ],
+    "Architecture": "arm64",
+    "Os": "linux",
+    "RootFS": {
+        "Type": "layers",
+        "Layers": [
+            "sha256:1e9178dc90058fa454a60803300219ee8c17e515be8718817ed824b96fa1207b",
+            "sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef",
+            "sha256:1b7eb283ff126198a9f292a2511133a8ab8c82bda9c4d4819cbe6f4be53f6dc4",
+            "sha256:eb05c3b16772fda838693e3621020572ef46903a9480f57cd7347bd6e30f5cfc",
+            "sha256:608ed5df5926ca9cf8ea98ee0c4b06b8cd7fae822caeaa9153d6a88569707e74",
+            "sha256:e23d740627c00ac7d052a5ba064c71e07ebf6a97a335c259f44feb0bd3c1c4e8",
+            "sha256:921b4a27c98023d4ee54c3713d11ed094201b1448a590eebb8739296b9978799",
+            "sha256:7449d2f5a570e6301afc4b03a710a7006950d9d85372e20fde07f863a8aee3b0",
+            "sha256:e28e00624817a4447d03fbd25e6533747ce1ce6bbbc08cc157050bcc88129b30",
+            "sha256:bae81d2da5d28845b37687b158dc3c03b6fb7d1629c475432d35166a3dd0ad1b",
+            "sha256:d4c5c89019ab226aac376b4574f957689a126740a2e759a02be63157e11a292c",
+            "sha256:e9db30e578d1626eb17b4121b169932e7935bf41660e5a7be2b2627d6d4870c1",
+            "sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef"
+        ]
+    },
+    "DockerfileMD5": null,
+    "DepsMD5s": {}
+}

{calkit_python-0.48.1 → calkit_python-0.48.3}/.pre-commit-config.yaml

@@ -85,9 +85,10 @@ repos:
         # the pipeline changes. Prettier and ruamel disagree about where a
         # long 'desc:' value goes, so formatting it here just means the two
         # take turns reformatting the same file.
-        # Likewise the example projects' results files, which are stage
-        # outputs and have to match what the stage wrote byte for byte.
-        exclude: calkit|^hub/|(^|/)dvc\.yaml$|^examples/.*/results/
+        # Likewise results files, here, in the example projects, and in
+        # decisions, which are stage outputs and have to match what the stage
+        # wrote byte for byte.
+        exclude: calkit|^hub/|(^|/)dvc\.yaml$|^((examples/.*|decisions)/)?results/
 
   - repo: local
     hooks:

{calkit_python-0.48.1 → calkit_python-0.48.3}/AGENTS.md

@@ -25,6 +25,9 @@ To run tests, use `uv run pytest`.
 
 To sync the docs and format all the code, run `make format`.
 
+Before pushing a pull request, run `make pr`, which also runs the project's
+pipeline and pushes its outputs, so the pipeline check passes.
+
 Before finishing a change, type-check it. The CLI gate is mypy
 (`uv run mypy <changed files>`, or `make check` for the full suite), and the
 VS Code editor uses Pylance (Pyright). Keep new code clean under both, and do

{calkit_python-0.48.1 → calkit_python-0.48.3}/Makefile

@@ -28,6 +28,23 @@ format: ## Automatically format files and regenerate what's generated.
 	@echo "🚀 Linting code with pre-commit"
 	@uv run pre-commit run -a
 
+.PHONY: pr
+pr: ## Get a pull request ready to pass: format, and run the pipeline.
+	@echo "🚀 Formatting, then checking it's done"
+	@uv run pre-commit run -a > /dev/null || uv run pre-commit run -a
+	@echo "🚀 Pulling the pipeline's outputs, so only what changed reruns"
+	@uv run calkit dvc pull || true
+	@echo "🚀 Running the pipeline"
+	@uv run calkit run
+	@echo "🚀 Pushing the pipeline's outputs"
+	@uv run calkit dvc push
+	@echo "🚀 Checking the run left nothing to format or rerun"
+	@files="$$(git diff --name-only)"; \
+		[ -z "$$files" ] || uv run pre-commit run --files $$files
+	@uv run calkit status --json | uv run python -c \
+		"import json, sys; sys.exit(json.load(sys.stdin)['pipeline']['is_stale'])" \
+		|| (echo "The pipeline is stale; see 'calkit status'" && exit 1)
+
 .PHONY: check
 check: format ## Run code quality tools.
 	@echo "🚀 Checking lock file consistency with 'pyproject.toml'"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: calkit-python
-Version: 0.48.1
+Version: 0.48.3
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -47,6 +47,8 @@ Requires-Dist: python-dotenv>=1
 Requires-Dist: pywin32; platform_system == 'Windows'
 Requires-Dist: requests
 Requires-Dist: rich
+Requires-Dist: ruamel-yaml-clib>=0.2.15; platform_python_implementation == 'CPython' and python_version < '3.15' and (sys_platform == 'darwin' or (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64' or platform_machine == 'i686')) or (sys_platform == 'win32' and (platform_machine == 'AMD64' or platform_machine == 'x86')))
+Requires-Dist: ruamel-yaml<0.20,>=0.19.1
 Requires-Dist: sqlitedict>=2.1.0
 Requires-Dist: texsoup>=0.3.3
 Requires-Dist: toml>=0.10.2

{calkit_python-0.48.1 → calkit_python-0.48.3}/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_python-0.48.1 → calkit_python-0.48.3}/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_python-0.48.1 → calkit_python-0.48.3}/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"),