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

calkit_python-0.41.4/.gitattributes

@@ -0,0 +1 @@
+test/dvc-md5-dir/** text eol=lf

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.41.2
+Version: 0.41.4
 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.4}/calkit/cli/check.py

@@ -381,7 +381,7 @@ def check_environment(
             quiet=not verbose,
         )
     elif env["kind"] == "pixi":
-        cmd = ["pixi", "lock"]
+        cmd = ["pixi", "install"]
         env_dir = os.path.dirname(env["path"])
         if env_dir:
             cmd += ["--manifest-path", env["path"]]

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

@@ -502,10 +502,11 @@ def get_status(
         if "dvc" in categories:
             try:
                 dvc_repo = calkit.dvc.get_dvc_repo()
-                data_status = dvc_repo.data_status()
-                if isinstance(data_status, dict):
-                    data_status.pop("git", None)
-                status_dict["dvc"] = data_status
+                data_status = dict(dvc_repo.data_status())
+                data_status.pop("git", None)
+                status_dict["dvc"] = calkit.dvc.data_status_as_posix(
+                    data_status
+                )
             except Exception as e:
                 status_dict["dvc"] = {"error": f"{e.__class__.__name__}: {e}"}
         if "pipeline" in categories or "dvc" in categories:
@@ -557,6 +558,7 @@ def get_status(
             dvc_repo = calkit.dvc.get_dvc_repo()
             raw = dict(dvc_repo.data_status())
             raw.pop("git", None)
+            raw = calkit.dvc.data_status_as_posix(raw)
             typer.echo(_format_dvc_data_status(raw, zip_path_map))
     if "pipeline" in categories or "dvc" in categories:
         print_sep("Pipeline")
@@ -579,6 +581,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 +600,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 +2433,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.4}/calkit/cli/new.py

@@ -1152,10 +1152,10 @@ def new_publication(
             deps += stage.get("outs", [])
     # Create publication object
     if template_type == "latex":
-        pub_fpath = os.path.join(
+        pub_fpath = pathlib.Path(
             path,
             template_obj.target.removesuffix(".tex") + ".pdf",  # type: ignore
-        )
+        ).as_posix()
     else:
         pub_fpath = path
     if not overwrite and pub_fpath in pub_paths:
@@ -1190,7 +1190,7 @@ def new_publication(
         stage = LatexStage(
             kind="latex",
             environment=env_name,
-            target_path=os.path.join(path, template_obj.target),  # type: ignore
+            target_path=pathlib.Path(path, template_obj.target).as_posix(),  # type: ignore
             outputs=[pub_fpath],
         ).model_dump()
         if "pipeline" not in ck_info:

{calkit_python-0.41.2 → calkit_python-0.41.4}/calkit/cli/scheduler.py

@@ -92,9 +92,9 @@ def _mock_enabled() -> bool:
 
 
 def _require_posix_mock() -> None:
-    # The mock backend uses bash, new sessions, and process-group signals.
-    if os.name != "posix":
-        raise_error("CALKIT_MOCK_SCHEDULER is only supported on POSIX systems")
+    # The mock backend uses bash; if that is missing, the mock cannot run.
+    if shutil.which("bash") is None:
+        raise_error("CALKIT_MOCK_SCHEDULER requires bash on PATH")
 
 
 def _ensure_mock_dir() -> None:
@@ -177,13 +177,19 @@ def _mock_submit(job_id: str, job_command: str, log_path: str) -> int:
     env = dict(os.environ)
     env.setdefault("PBS_O_WORKDIR", os.getcwd())
     with open(log_path, "w") as log_file:
-        proc = subprocess.Popen(
-            ["bash", "-c", wrapped],
+        popen_kwargs = dict(
             stdout=log_file,
             stderr=subprocess.STDOUT,
-            start_new_session=True,
             env=env,
         )
+        if os.name == "posix":
+            popen_kwargs["start_new_session"] = True
+        elif hasattr(subprocess, "CREATE_NEW_PROCESS_GROUP"):
+            popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+        proc = subprocess.Popen(
+            ["bash", "-c", wrapped],
+            **popen_kwargs,
+        )
     return proc.pid
 
 
@@ -192,7 +198,10 @@ def _mock_cancel(job_id: str) -> tuple[bool, str]:
     pid = _mock_pid(job_id)
     if pid is not None:
         try:
-            os.killpg(os.getpgid(pid), signal.SIGTERM)
+            if os.name == "posix":
+                os.killpg(os.getpgid(pid), signal.SIGTERM)
+            else:
+                os.kill(pid, signal.SIGTERM)
         except (ProcessLookupError, PermissionError):
             pass
     # Drop a sentinel so later liveness checks report the job as finished.

{calkit_python-0.41.2 → calkit_python-0.41.4}/calkit/detect.py

@@ -10,6 +10,7 @@ import os
 import re
 import shlex
 import sys
+from pathlib import Path
 from typing import Literal
 
 NotebookLanguage = Literal["python", "julia", "r"]
@@ -114,7 +115,7 @@ def detect_julia_script_io(
         if not os.path.isabs(match):
             full_path = os.path.join(script_dir, match)
             if os.path.exists(full_path):
-                inputs.append(os.path.relpath(full_path))
+                inputs.append(Path(os.path.relpath(full_path)).as_posix())
             elif _is_valid_project_path(match):
                 inputs.append(match)
     read_patterns = [
@@ -421,26 +422,29 @@ def detect_latex_io(tex_path: str) -> dict[str, list[str]]:
     for pattern, pattern_type in patterns:
         matches = re.findall(pattern, content)
         for match in matches:
+
+            def _resolve(name: str) -> str:
+                return Path(
+                    os.path.normpath(os.path.join(tex_dir, name))
+                ).as_posix()
+
             if pattern_type == "bib":
                 files = [f.strip() for f in match.split(",")]
                 for f in files:
                     if not f.endswith(".bib"):
                         f += ".bib"
                     # Resolve relative to the document directory
-                    resolved = os.path.normpath(os.path.join(tex_dir, f))
-                    inputs.append(resolved)
+                    inputs.append(_resolve(f))
             elif pattern_type == "tex":
                 filename = match
                 if not filename.endswith(".tex"):
                     filename += ".tex"
                 # Resolve relative to the document directory
-                resolved = os.path.normpath(os.path.join(tex_dir, filename))
-                inputs.append(resolved)
+                inputs.append(_resolve(filename))
             else:
                 # Include graphics or other files
                 # Resolve relative to the document directory
-                resolved = os.path.normpath(os.path.join(tex_dir, match))
-                inputs.append(resolved)
+                inputs.append(_resolve(match))
     # Filter and deduplicate inputs
     inputs = [p for p in inputs if _is_valid_project_path(p)]
     inputs = list(dict.fromkeys(inputs))
@@ -774,6 +778,9 @@ def _detect_python_code_io(
         except ValueError:
             # If paths are on different drives (Windows), use normalized path
             rel_path = full_path
+        # Always emit posix separators so downstream comparisons are stable
+        # across platforms.
+        rel_path = Path(rel_path).as_posix()
         # Strip leading ../ for paths outside project root
         while rel_path.startswith("../"):
             rel_path = rel_path[3:]
@@ -938,7 +945,7 @@ def _detect_julia_code_io(
         if not os.path.isabs(match):
             full_path = os.path.join(script_dir, match)
             if os.path.exists(full_path):
-                inputs.append(os.path.relpath(full_path))
+                inputs.append(Path(os.path.relpath(full_path)).as_posix())
             elif _is_valid_project_path(match):
                 inputs.append(match)
     read_patterns = [
@@ -978,12 +985,12 @@ def _resolve_python_import(
     if os.path.exists(file_path) and _is_valid_project_path(
         os.path.relpath(file_path)
     ):
-        return os.path.relpath(file_path)
+        return Path(os.path.relpath(file_path)).as_posix()
     init_path = os.path.join(search_dir, module_path, "__init__.py")
     if os.path.exists(init_path) and _is_valid_project_path(
         os.path.relpath(init_path)
     ):
-        return os.path.relpath(init_path)
+        return Path(os.path.relpath(init_path)).as_posix()
     return None
 
 
@@ -1018,7 +1025,7 @@ def _detect_r_code_io(
         if not os.path.isabs(match):
             full_path = os.path.join(script_dir, match)
             if os.path.exists(full_path):
-                inputs.append(os.path.relpath(full_path))
+                inputs.append(Path(os.path.relpath(full_path)).as_posix())
             elif _is_valid_project_path(match):
                 inputs.append(match)
     # Read patterns that capture variables, file.path() expressions, or literals

{calkit_python-0.41.2 → calkit_python-0.41.4}/calkit/dvc/core.py

@@ -26,6 +26,24 @@ logger.setLevel(logging.INFO)
 USE_CK_REMOTE_BY_DEFAULT = True
 
 
+class _FrozenStageWarningFilter(logging.Filter):
+    """Drop DVC's "stage is frozen" warnings.
+
+    DVC emits these for every frozen stage on every ``status``/``repro`` call
+    ("... not going to be shown in the status output." and "... not going to
+    be reproduced."). Frozen stages are pinned by design, so the warnings are
+    noise — the substring shared by both variants is matched here.
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return "is frozen. Its dependencies are" not in record.getMessage()
+
+
+_frozen_stage_warning_filter = _FrozenStageWarningFilter()
+for _name in ("dvc.repo.reproduce", "dvc.repo.status"):
+    logging.getLogger(_name).addFilter(_frozen_stage_warning_filter)
+
+
 class CalkitDVCFileSystem(ObjectFileSystem):
     """DVC-facing filesystem wrapper for the ``ck://`` scheme."""
 
@@ -614,3 +632,55 @@ def hash_path(path: str) -> dict:
         return hash_file(path)
     else:
         raise ValueError(f"Path does not exist: {path}")
+
+
+def _path_item_as_posix(item):
+    # Renamed entries are dicts like {"old": ..., "new": ...}.
+    if isinstance(item, dict):
+        return {k: Path(v).as_posix() for k, v in item.items()}
+    return Path(item).as_posix()
+
+
+def data_status_as_posix(data_status: dict) -> dict:
+    """Convert all paths in DVC data status to posix format.
+
+    We skip the ``git`` entry since Git already formats as posix.
+    """
+    data_status_fmt = {}
+    for cat, obj in data_status.items():
+        if cat == "git":
+            data_status_fmt[cat] = obj
+        elif isinstance(obj, list):
+            data_status_fmt[cat] = [_path_item_as_posix(p) for p in obj]
+        elif isinstance(obj, dict):
+            obj_fmt = {}
+            for cat2, obj_i in obj.items():
+                obj_fmt[cat2] = [_path_item_as_posix(p) for p in obj_i]
+            data_status_fmt[cat] = obj_fmt
+        else:
+            data_status_fmt[cat] = obj
+    return data_status_fmt
+
+
+def status_as_posix(status: dict) -> dict:
+    """Convert all paths in repo status to posix format."""
+    status_fmt = {}
+    for stage_name, st_list in status.items():
+        st_list_fmt = []
+        for st_dict in st_list:
+            if isinstance(st_dict, str):
+                st_list_fmt.append(st_dict)
+                continue
+            st_dict_fmt = {}
+            for st_cat, path_st_dict in st_dict.items():
+                if not isinstance(path_st_dict, dict):
+                    # e.g. {"changed command": "python src/new-script.py"}
+                    st_dict_fmt[st_cat] = path_st_dict
+                    continue
+                path_st_dict_fmt = {}
+                for p, st in path_st_dict.items():
+                    path_st_dict_fmt[Path(p).as_posix()] = st
+                st_dict_fmt[st_cat] = path_st_dict_fmt
+            st_list_fmt.append(st_dict_fmt)
+        status_fmt[stage_name] = st_list_fmt
+    return status_fmt

{calkit_python-0.41.2 → calkit_python-0.41.4}/calkit/dvc/zip.py

@@ -113,7 +113,7 @@ class SyncRecord(BaseModel):
 
 def make_zip_path(workspace_path: str) -> str:
     """Make a zip path for a given workspace path."""
-    return os.path.join(ZIPS_DIR, "files", workspace_path + ".zip")
+    return Path(ZIPS_DIR, "files", f"{workspace_path}.zip").as_posix()
 
 
 def _path_map_path(wdir: str | None = None) -> str:
@@ -272,6 +272,7 @@ def get_sync_record(
 ) -> SyncRecord | None:
     """Get a sync record for a given workspace path."""
     _check_local_dir(wdir)
+    workspace_path = Path(workspace_path).as_posix()
     with SqliteDict(_sync_records_path(wdir)) as db:
         raw = db.get(workspace_path)
     if raw is not None:
@@ -283,13 +284,14 @@ def write_sync_record(record: SyncRecord, wdir: str | None = None):
     """Write a sync record."""
     _check_local_dir(wdir)
     with SqliteDict(_sync_records_path(wdir)) as db:
-        db[record.workspace_path] = record.model_dump()
+        db[Path(record.workspace_path).as_posix()] = record.model_dump()
         db.commit()
 
 
 def delete_sync_record(workspace_path: str, wdir: str | None = None):
     """Delete a sync record."""
     _check_local_dir(wdir)
+    workspace_path = Path(workspace_path).as_posix()
     with SqliteDict(_sync_records_path(wdir)) as db:
         if workspace_path in db:
             del db[workspace_path]
@@ -466,6 +468,9 @@ def sync_one(
         workspace_path = os.path.join(wdir, workspace_path)
         if zip_path is not None:
             zip_path = os.path.join(wdir, zip_path)
+    workspace_path = Path(workspace_path).as_posix()
+    if zip_path is not None:
+        zip_path = Path(zip_path).as_posix()
     return _sync_one(workspace_path, zip_path, direction, wdir=wdir)
 
 

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

@@ -38,6 +38,12 @@ CONDA_VENV_ARCHS = [
 ]
 ENV_CHECK_CACHE_TTL_SECONDS = 3600
 KINDS_NO_CHECK = ["_system", "ssh"]
+
+
+def _as_posix_path(path: str) -> str:
+    return Path(path).as_posix()
+
+
 COMPOSITE_ENV_SEP = ":"
 VALID_OUTER_ENV_KINDS = ["slurm", "pbs"]
 
@@ -314,6 +320,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"
@@ -711,7 +723,7 @@ def make_env_name(path: str, all_env_names: list[str], kind: str) -> str:
     str
         A unique environment name.
     """
-    dirname = os.path.basename(os.path.dirname(path))
+    dirname = Path(path).parent.name
     # If this is the first env in the project, call it main
     if not all_env_names:
         return dirname or "main"
@@ -835,7 +847,7 @@ def env_from_name_or_path(
             exists=True,
         )
     # Check if name_or_path is a file and detect environment type
-    env_path = name_or_path
+    env_path = _as_posix_path(name_or_path)
     if os.path.isfile(env_path):
         if env_path.endswith("requirements.txt"):
             # TODO: Detect if uv is installed, and use a plain venv if not
@@ -845,9 +857,9 @@ def env_from_name_or_path(
                     "kind": "uv-venv",
                     "path": env_path,
                     "python": DEFAULT_PYTHON_VERSION,
-                    "prefix": os.path.join(
-                        os.path.split(env_path)[0], ".venv"
-                    ),
+                    "prefix": Path(env_path)
+                    .parent.joinpath(".venv")
+                    .as_posix(),
                 },
                 exists=False,
             )
@@ -936,9 +948,10 @@ def env_from_name_and_or_path(
     if ck_info is None:
         ck_info = calkit.load_calkit_info()
     envs = ck_info.get("environments", {})
+    path = _as_posix_path(path) if path else None
     if name and name in envs:
         env = envs[name]
-        if path and env.get("path") != path:
+        if path and _as_posix_path(env.get("path", "")) != path:
             raise ValueError(
                 f"Environment '{name}' exists but has a different path "
                 f"('{env.get('path')}') than provided ('{path}')"
@@ -952,7 +965,7 @@ def env_from_name_and_or_path(
             # Look for a sub-environment with the given name and path
             for sub_name, sub_env in envs.items():
                 if (sub_name == sub_env_name) or (
-                    path and sub_env.get("path") == path
+                    path and _as_posix_path(sub_env.get("path", "")) == path
                 ):
                     return EnvDetectResult(
                         name=sub_name,
@@ -989,12 +1002,13 @@ def env_from_notebook_path(
     """
     if ck_info is None:
         ck_info = calkit.load_calkit_info()
+    notebook_path = _as_posix_path(notebook_path)
     stages = ck_info.get("pipeline", {}).get("stages", {})
     envs = ck_info.get("environments", {})
     for stage in stages.values():
         if (
             stage.get("kind") == "jupyter-notebook"
-            and stage.get("notebook_path") == notebook_path
+            and _as_posix_path(stage.get("notebook_path", "")) == notebook_path
         ):
             env_name = stage.get("environment")
             if env_name:
@@ -1002,7 +1016,7 @@ def env_from_notebook_path(
                 if env:
                     return EnvDetectResult(name=env_name, env=env, exists=True)
     for nb in ck_info.get("notebooks", []):
-        if nb.get("path") == notebook_path:
+        if _as_posix_path(nb.get("path", "")) == notebook_path:
             env_name = nb.get("environment")
             if env_name:
                 env = envs.get(env_name)

{calkit_python-0.41.2 → calkit_python-0.41.4}/calkit/git.py

@@ -157,7 +157,7 @@ def ensure_path_is_ignored(
     if os.path.isfile(gitignore_path):
         with open(gitignore_path) as f:
             gitignore_txt = f.read()
-        lines = gitignore_txt.splitlines()
+        lines = [line for line in gitignore_txt.splitlines() if line]
         if target_path in lines:
             # The direct rule exists; also remove any stale negation that
             # follows it, otherwise the negation wins and the path stays
@@ -169,7 +169,7 @@ def ensure_path_is_ignored(
             for n in stale:
                 lines.remove(n)
             with open(gitignore_path, "w") as f:
-                f.write(os.linesep.join(lines))
+                f.write("\n".join(lines))
             return True
         # Remove any stale negations for this path so the ignore rule takes
         # effect cleanly without accumulating contradictory entries.
@@ -180,7 +180,7 @@ def ensure_path_is_ignored(
                 lines.remove(n)
             lines.append(target_path)
             with open(gitignore_path, "w") as f:
-                f.write(os.linesep.join(lines))
+                f.write("\n".join(lines))
             return True
     with open(gitignore_path, "a") as f:
         if (
@@ -329,7 +329,7 @@ def ensure_path_is_not_ignored(
                 lines.remove(no_ignore_line)
             lines.append(no_ignore_line)
     with open(gitignore_path, "w") as f:
-        f.write(os.linesep.join(lines))
+        f.write("\n".join(lines))
     # If the path is still ignored after updating this gitignore file (e.g.,
     # because a subdirectory .gitignore also contains a matching rule), fix
     # that file as well. Depth-limit guards against pathological gitignore

{calkit_python-0.41.2 → calkit_python-0.41.4}/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.4}/calkit/overleaf.py

@@ -4,6 +4,7 @@ import json
 import os
 import shutil
 import subprocess
+import tempfile
 import warnings
 from copy import deepcopy
 from functools import cached_property
@@ -23,7 +24,9 @@ def get_git_remote_url(project_id: str, token: str) -> str:
     If running against a test environment, this will use a local directory.
     """
     if calkit.config.get_env() == "test":
-        return os.path.join("/tmp", "overleaf", project_id)
+        return (
+            Path(tempfile.gettempdir()) / "overleaf" / project_id
+        ).as_posix()
     return f"https://git:{token}@git.overleaf.com/{project_id}"