calkit-python 0.41.2__tar.gz → 0.41.3__tar.gz

{calkit_python-0.41.2 → calkit_python-0.41.3}/PKG-INFO

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

{calkit_python-0.41.2 → calkit_python-0.41.3}/calkit/cli/main/core.py

@@ -579,6 +579,8 @@ def get_status(
                 if stale_stage is None:
                     continue
                 typer.echo(f"        {typer.style(stage_name, fg='yellow')}:")
+                if stale_stage.always_run:
+                    typer.echo("          always runs")
                 if stale_stage.modified_command:
                     typer.echo("          modified command")
                 # Show stale outputs for this stage
@@ -596,8 +598,16 @@ def get_status(
                     typer.echo("          modified inputs:")
                     for input_path in stale_stage.modified_inputs:
                         typer.echo(f"            {input_path}")
+            if pipeline_status.always_run_stage_names:
+                typer.echo("Always-run stages:")
+                for stage_name in pipeline_status.always_run_stage_names:
+                    typer.echo(f"        {typer.style(stage_name, fg='cyan')}")
         elif pipeline_status:
             typer.echo("Pipeline is up to date.")
+            if pipeline_status.always_run_stage_names:
+                typer.echo("Always-run stages:")
+                for stage_name in pipeline_status.always_run_stage_names:
+                    typer.echo(f"        {typer.style(stage_name, fg='cyan')}")
 
 
 @app.command(name="diff")
@@ -2421,7 +2431,10 @@ def run_in_env(
     elif env["kind"] == "pixi":
         env_cmd = []
         if "name" in env:
-            env_cmd = ["--environment", env["name"]]
+            env_cmd += ["--environment", env["name"]]
+        env_path = env.get("path")
+        if env_path and os.path.dirname(env_path):
+            env_cmd += ["--manifest-path", os.path.abspath(env_path)]
         cmd = ["pixi", "run"] + env_cmd + cmd
         if verbose:
             typer.echo(f"Running command: {cmd}")

{calkit_python-0.41.2 → calkit_python-0.41.3}/calkit/environments.py

@@ -314,6 +314,12 @@ def get_env_lock_fpath(
             lock_fpath = os.path.join(env_dir, "uv.lock")
         else:
             lock_fpath = "uv.lock"
+    elif env_kind == "pixi":
+        env_dir = os.path.dirname(env.get("path") or "")
+        if env_dir:
+            lock_fpath = os.path.join(env_dir, "pixi.lock")
+        else:
+            lock_fpath = "pixi.lock"
     elif env_kind in ["venv", "uv-venv"]:
         if legacy:
             lock_fpath += ".txt"

{calkit_python-0.41.2 → calkit_python-0.41.3}/calkit/jupyterlab/routes.py

@@ -903,11 +903,14 @@ class PipelineStatusRouteHandler(APIHandler):
             pipeline_status = {
                 k.split("dvc.yaml:")[-1]: v
                 for k, v in raw_status.items()
-                if v != ["always changed"]
-                and not k.endswith(".dvc")
+                if not k.endswith(".dvc")
                 and k.split("dvc.yaml:")[-1].split("@")[0] not in frozen_stages
             }
-            is_outdated = len(pipeline_status) > 0
+            # Always-run-only stages are surfaced in pipeline_status but do
+            # not count toward is_outdated, matching the CLI's is_stale logic.
+            is_outdated = any(
+                v != ["always changed"] for v in pipeline_status.values()
+            )
             self.finish(
                 json.dumps(
                     {

{calkit_python-0.41.2 → calkit_python-0.41.3}/calkit/pipeline.py

@@ -91,7 +91,32 @@ class PipelineStatus(BaseModel):
     @computed_field
     @property
     def stale_stage_names(self) -> list[str]:
-        return list(self.stale_stages.keys())
+        # Pure always-run stages aren't truly stale; surface them via
+        # always_run_stage_names instead.
+        return [
+            name
+            for name, stage in self.stale_stages.items()
+            if not stage.always_run
+            or stage.modified_command
+            or stage.modified_inputs
+            or stage.modified_outputs
+            or stage.stale_outputs
+        ]
+
+    @computed_field
+    @property
+    def always_run_stage_names(self) -> list[str]:
+        # Only list stages whose sole change indicator is always_run; stages
+        # that also have real changes are reported under stale_stage_names.
+        return [
+            name
+            for name, stage in self.stale_stages.items()
+            if stage.always_run
+            and not stage.modified_command
+            and not stage.modified_inputs
+            and not stage.modified_outputs
+            and not stage.stale_outputs
+        ]
 
     @computed_field
     @property
@@ -107,7 +132,20 @@ class PipelineStatus(BaseModel):
     @computed_field
     @property
     def is_stale(self) -> bool:
-        return bool(self.stale_stages)
+        # A stage whose only listed change is "always_run" is not actually
+        # stale — it just always re-executes by design. Treat the pipeline
+        # as stale only if some stage has real change indicators.
+        for stage in self.stale_stages.values():
+            if not stage.always_run:
+                return True
+            if (
+                stage.modified_command
+                or stage.modified_inputs
+                or stage.modified_outputs
+                or stage.stale_outputs
+            ):
+                return True
+        return False
 
 
 class StaleStage(BaseModel):
@@ -118,6 +156,7 @@ class StaleStage(BaseModel):
     modified_inputs: list[str] = Field(default_factory=list)
     modified_outputs: list[str] = Field(default_factory=list)
     modified_command: bool = False
+    always_run: bool = False
 
     @staticmethod
     def _as_path_list(paths: object) -> list[str]:
@@ -206,17 +245,22 @@ class StaleStage(BaseModel):
         modified_outputs = []
         status_blocks = []
         modified_command = False
+        always_run = False
         if isinstance(status_data, dict):
             status_blocks = [status_data]
         elif isinstance(status_data, list):
             status_blocks = [
                 item for item in status_data if isinstance(item, dict)
             ]
-            # DVC may return plain markers like ["changed command"].
+            # DVC may return plain markers like ["changed command"] or
+            # ["always changed"], possibly alongside other change blocks.
             if "changed command" in status_data:
                 modified_command = True
+            if "always changed" in status_data:
+                always_run = True
         elif isinstance(status_data, str):
             modified_command = status_data == "changed command"
+            always_run = status_data == "always changed"
         for block in status_blocks:
             if "changed command" in block:
                 changed_command_value = block.get("changed command")
@@ -264,7 +308,16 @@ class StaleStage(BaseModel):
         stale_outputs.extend(
             [path for path in output_paths if path not in modified_outputs]
         )
-        if not stale_outputs and not modified_outputs and configured_outputs:
+        # Fallback: if DVC flagged the stage but we couldn't attribute the
+        # change to specific paths, mark all configured outputs as stale.
+        # Skip the fallback for pure "always_run" stages — they always
+        # re-execute by design, not because outputs are out of date.
+        if (
+            not stale_outputs
+            and not modified_outputs
+            and configured_outputs
+            and not always_run
+        ):
             stale_outputs.extend(configured_outputs)
         stale_outputs = list(dict.fromkeys(stale_outputs))
         return cls(
@@ -273,6 +326,7 @@ class StaleStage(BaseModel):
             modified_inputs=modified_inputs,
             modified_outputs=modified_outputs,
             modified_command=modified_command,
+            always_run=always_run,
         )
 
 
@@ -666,7 +720,10 @@ def get_status(
         # collisions when a subproject stage shares a name with a root stage.
         raw_stale_stages: dict[str, tuple[str, str | None, list]] = {}
         for k, v in raw_status.items():
-            if v == ["always changed"] or k.endswith(".dvc"):
+            # Skip DVC-tracked files (.dvc entries) — they are not pipeline
+            # stages. Stages marked ["always changed"] are kept so the user
+            # sees them in the pipeline status output.
+            if k.endswith(".dvc"):
                 continue
             if "dvc.yaml:" in k:
                 prefix, bare_name = k.split("dvc.yaml:", 1)

{calkit_python-0.41.2 → calkit_python-0.41.3}/calkit/server.py

@@ -303,18 +303,16 @@ def get_status(
         #     ]
         # }
         dvc_pipeline_status = dvc.repo.status.status(dvc_repo)
-        # Remove any always changed entries so the pipeline doesn't look
-        # out of date
         logger.info(f"Raw DVC pipeline status: {dvc_pipeline_status}")
-        # Frozen stages are intentionally pinned and hidden from status
+        # Frozen stages are intentionally pinned and hidden from status.
+        # Always-run entries are kept so clients can surface them.
         frozen_stages = calkit.pipeline.frozen_stage_base_names(
             wdir=project.wdir
         )
         dvc_pipeline_status = {
             k.split("dvc.yaml:")[-1]: v
             for k, v in dvc_pipeline_status.items()
-            if v != ["always changed"]
-            and not k.endswith(".dvc")
+            if not k.endswith(".dvc")
             and k.split("dvc.yaml:")[-1].split("@")[0] not in frozen_stages
         }
         logger.info(

{calkit_python-0.41.2 → calkit_python-0.41.3}/calkit/tests/test_environments.py

@@ -1017,6 +1017,40 @@ def test_nix_env(tmp_dir):
     assert "devShells" in content
 
 
+def test_pixi_env_lock_fpath(tmp_dir):
+    # Manifest at the repo root: pixi.lock lives next to pixi.toml.
+    root_env = {"kind": "pixi", "path": "pixi.toml"}
+    assert (
+        calkit.environments.get_env_lock_fpath(
+            env=root_env, env_name="main", as_posix=True
+        )
+        == "pixi.lock"
+    )
+    # Manifest in a subdirectory: lock follows the manifest.
+    nested_env = {"kind": "pixi", "path": ".calkit/envs/my-env/pixi.toml"}
+    assert (
+        calkit.environments.get_env_lock_fpath(
+            env=nested_env, env_name="my-env", as_posix=True
+        )
+        == ".calkit/envs/my-env/pixi.lock"
+    )
+    # path may be omitted/None without raising.
+    assert (
+        calkit.environments.get_env_lock_fpath(
+            env={"kind": "pixi"}, env_name="main", as_posix=True
+        )
+        == "pixi.lock"
+    )
+    assert (
+        calkit.environments.get_env_lock_fpath(
+            env={"kind": "pixi", "path": None},
+            env_name="main",
+            as_posix=True,
+        )
+        == "pixi.lock"
+    )
+
+
 def test_add_packages_to_nix_flake(tmp_dir):
     # Round-trip: generate a flake, add some packages, verify they appear
     # in the packages list, that duplicates aren't re-inserted, and that

{calkit_python-0.41.2 → calkit_python-0.41.3}/calkit/tests/test_pipeline.py

@@ -1465,6 +1465,98 @@ def test_get_status_excludes_frozen_stage(tmp_dir):
     assert "get-data" not in status.stale_stage_names
 
 
+def test_get_status_includes_always_run_stage(tmp_dir):
+    subprocess.check_call(["calkit", "init"])
+    ck_info = {
+        "environments": {
+            "py": {
+                "kind": "uv-venv",
+                "path": "requirements.txt",
+                "prefix": ".venv",
+            }
+        },
+        "pipeline": {
+            "stages": {
+                "ticker": {
+                    "kind": "python-script",
+                    "environment": "py",
+                    "script_path": "something/my-cool-script.py",
+                    "outputs": ["ticker.out"],
+                    "always_run": True,
+                },
+                "normal": {
+                    "kind": "python-script",
+                    "environment": "py",
+                    "script_path": "something/normal-script.py",
+                    "outputs": ["normal.out"],
+                },
+            }
+        },
+    }
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
+    with open("requirements.txt", "w") as f:
+        f.write("requests\n")
+    os.makedirs("something", exist_ok=True)
+    with open("something/my-cool-script.py", "w") as f:
+        f.write("open('ticker.out', 'w').write('tick')\n")
+    with open("something/normal-script.py", "w") as f:
+        f.write("open('normal.out', 'w').write('hi')\n")
+    # The compiled DVC stage must carry always_changed: true so DVC's status
+    # actually emits the "always changed" marker
+    dvc_stages = calkit.pipeline.to_dvc(ck_info=ck_info)
+    assert dvc_stages["ticker"]["always_changed"] is True
+    # Initial status: outputs missing, both stages are stale for real reasons.
+    # The always-run stage carries the always_run flag too.
+    status = calkit.pipeline.get_status(ck_info=ck_info)
+    assert status.is_stale
+    assert "ticker" in status.stale_stages
+    assert status.stale_stages["ticker"].always_run
+    assert "normal" in status.stale_stage_names
+    assert "ticker" in status.stale_stage_names
+    # Run the pipeline so outputs exist and nothing is "really" stale
+    subprocess.check_call(["calkit", "run"])
+    status = calkit.pipeline.get_status(ck_info=ck_info)
+    # The always-run stage must still be visible — that was the bug
+    assert "ticker" in status.stale_stages
+    assert status.stale_stages["ticker"].always_run
+    assert status.stale_stages["ticker"].stale_outputs == []
+    assert status.stale_stages["ticker"].modified_outputs == []
+    assert status.stale_stages["ticker"].modified_inputs == []
+    assert not status.stale_stages["ticker"].modified_command
+    assert status.always_run_stage_names == ["ticker"]
+    # A pipeline whose only "stale" stage is always_run must not be marked
+    # stale — calkit update relies on is_stale to gate release publication
+    assert not status.is_stale
+    assert "ticker" not in status.stale_stage_names
+
+
+def test_stale_stage_detects_always_changed_marker():
+    stale_stage = calkit.pipeline.StaleStage.from_status_data(
+        status_data=["always changed"],
+        configured_outputs=["ticker.out"],
+    )
+    assert stale_stage.always_run
+    assert not stale_stage.modified_command
+    assert stale_stage.stale_outputs == []
+    assert stale_stage.modified_outputs == []
+    assert stale_stage.modified_inputs == []
+
+
+def test_stale_stage_always_changed_with_missing_output():
+    # Mirrors DVC's actual output for an always_changed stage whose output
+    # is missing from cache: ["always changed"] coexists with a change block.
+    stale_stage = calkit.pipeline.StaleStage.from_status_data(
+        status_data=[
+            {"changed outs": {"ticker.out": "deleted"}},
+            "always changed",
+        ],
+        configured_outputs=["ticker.out"],
+    )
+    assert stale_stage.always_run
+    assert stale_stage.stale_outputs == ["ticker.out"]
+
+
 def test_stale_stage_detects_changed_command():
     stale_stage = calkit.pipeline.StaleStage.from_status_data(
         status_data=[{"changed command": "python src/new-script.py"}],