pivot 0.3.2__tar.gz → 0.3.4__tar.gz

{pivot-0.3.2 → pivot-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pivot
-Version: 0.3.2
+Version: 0.3.4
 Summary: High-performance Python pipeline tool with automatic code change detection
 Author: Sami Jawhar
 Author-email: Sami Jawhar <sami@metr.org>

{pivot-0.3.2 → pivot-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pivot"
-version = "0.3.2"
+version = "0.3.4"
 description = "High-performance Python pipeline tool with automatic code change detection"
 requires-python = ">=3.13,<3.14"
 readme = "README.md"

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/cli/checkout.py

@@ -8,9 +8,10 @@ from typing import TYPE_CHECKING, Literal
 
 import click
 
-from pivot import config, project, registry, types
+from pivot import config, exceptions, project, registry, types
 from pivot.cli import completion
 from pivot.cli import decorators as cli_decorators
+from pivot.cli import errors as cli_errors
 from pivot.cli import helpers as cli_helpers
 from pivot.cli import targets as cli_targets
 from pivot.storage import cache, lock, state, track
@@ -73,11 +74,15 @@ def _on_disk_matches_expected(
     if is_dir_hash(expected_hash):
         if not path.is_dir():
             return False
-        actual_hash, _ = cache.hash_directory(path, cache_dir=cache_dir)
-    else:
-        if not path.is_file():
-            return False
-        actual_hash, _ = cache.hash_file(path)
+        actual = cache.hash_directory(path, cache_dir=cache_dir)
+        # A hash pivot 0.3.3 recorded lists no empty directories, and repro still honors it.
+        # When only empty directories differ, checkout would change no file, so it matches.
+        return actual["hash"] == expected_hash["hash"] or (
+            "empty_dirs" not in expected_hash and actual["manifest"] == expected_hash["manifest"]
+        )
+    if not path.is_file():
+        return False
+    actual_hash, _ = cache.hash_file(path)
     return actual_hash == expected_hash["hash"]
 
 
@@ -229,9 +234,13 @@ async def _checkout_files_async(
             for abs_path_str, output_hash in files.items():
                 _ = tg.create_task(restore_one(abs_path_str, output_hash))
     except* Exception as eg:
-        # Convert unexpected exceptions to friendly error message
-        errors = [str(e) for e in eg.exceptions]
-        raise click.ClickException("\n".join(errors)) from None
+        # Convert unexpected exceptions to a friendly error message, rendering a PivotError's
+        # actionable suggestion the same way the top-level CLI error handler does (cli/errors.py).
+        messages = [
+            cli_errors.format_pivot_error(e) if isinstance(e, exceptions.PivotError) else str(e)
+            for e in eg.exceptions
+        ]
+        raise click.ClickException("\n".join(messages)) from None
 
     # Re-raise immediate failures (all of them, aggregated)
     if immediate_errors:

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/cli/track.py

@@ -154,32 +154,36 @@ def _track_single_path(
 
     # Hash and cache
     if path.is_dir():
-        tree_hash, manifest = cache.hash_directory(
+        dir_hash = cache.hash_directory(
             path, cache_dir=cache_dir, warn_left_out_symlinks=warn_left_out_symlinks
         )
+        manifest = dir_hash["manifest"]
         total_size = sum(e["size"] for e in manifest)
         num_files = len(manifest)
 
-        # Save each file to cache
+        # copy_to_cache is idempotent and already checks existence itself; letting it see
+        # every entry (not just ones missing from the cache) is what lets it republish an
+        # object `pivot track --force` finds cached non-executable by an older pivot or a
+        # cold `pivot pull`, when this entry's bytes should be executable.
         for entry in manifest:
             file_path = path / entry["relpath"]
             file_cache_path = cache.get_cache_path(cache_dir, entry["hash"])
-            if not file_cache_path.exists():
-                cache.copy_to_cache(file_path, file_cache_path)
+            cache.copy_to_cache(file_path, file_cache_path, executable=entry["isexec"])
 
         pvt_data: track_mod.PvtData = {
             "path": path.name,
-            "hash": tree_hash,
+            "hash": dir_hash["hash"],
             "size": total_size,
             "num_files": num_files,
             "manifest": manifest,
         }
+        if "empty_dirs" in dir_hash:
+            pvt_data["empty_dirs"] = dir_hash["empty_dirs"]
     else:
         file_hash, _ = cache.hash_file(path)
         file_size = path.stat().st_size
         file_cache_path = cache.get_cache_path(cache_dir, file_hash)
-        if not file_cache_path.exists():
-            cache.copy_to_cache(path, file_cache_path)
+        cache.copy_to_cache(path, file_cache_path)
 
         pvt_data = {
             "path": path.name,

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/exceptions.py

@@ -214,6 +214,27 @@ class UncachedIncrementalOutputError(CacheError):
     """Raised when an incremental output exists without a cache entry."""
 
 
+class CacheModeCollisionError(CacheError):
+    """A HARDLINK/SYMLINK checkout shares the cache object's own permissions and found it
+    already recorded with the wrong executable bit, with no COPY fallback available.
+
+    This happens when two files with identical content disagree on their executable bit (the
+    cache key is content-only) or when a cache object was populated by a path that does not
+    know a file's intended executable bit (e.g. `pivot pull`, which downloads by hash alone).
+    """
+
+    @override
+    def get_suggestion(self) -> str:
+        return (
+            "Add CheckoutMode.COPY to checkout_modes (cache: checkout_mode: [..., copy] in "
+            ".pivot/config.yaml) so checkout can fall back to a private, correctly-permissioned "
+            "copy instead of sharing the cache object's own permissions; or, if you have the "
+            "source bytes in hand, re-running what produced them (`pivot repro --force "
+            "<stage>`, `pivot track --force <path>`) republishes the cache object with the "
+            "right bit"
+        )
+
+
 class ParamsError(PivotError):
     """Raised when parameter validation or loading fails."""
 

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/executor/core.py

@@ -409,7 +409,7 @@ def verify_tracked_files(project_root: pathlib.Path, checkout_missing: bool = Fa
                 if path.is_file():
                     current_hash, _ = cache.hash_file(path, state_db)
                 elif path.is_dir():
-                    current_hash, _ = cache.hash_directory(path, state_db, cache_dir=cache_dir)
+                    current_hash = cache.hash_directory(path, state_db, cache_dir=cache_dir)["hash"]
                 else:
                     # Path doesn't exist
                     raise FileNotFoundError(data_path)

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/executor/worker.py

@@ -39,7 +39,6 @@ from pivot.storage import artifact_lock, cache, lock, state
 from pivot.storage import store as store_mod
 from pivot.types import (
     DeferredWrites,
-    DirHash,
     FileHash,
     HashInfo,
     LockData,
@@ -631,8 +630,7 @@ def hash_output(
     ``cache_dir`` is the cache object root whose symlinks count as directory content.
     """
     if path.is_dir():
-        tree_hash, manifest = cache.hash_directory(path, state_db, cache_dir=cache_dir)
-        return DirHash(hash=tree_hash, manifest=manifest)
+        return cache.hash_directory(path, state_db, cache_dir=cache_dir)
     file_hash, _ = cache.hash_file(path, state_db)
     return FileHash(hash=file_hash)
 
@@ -1063,12 +1061,9 @@ def _hash_output_paths(
         if not path.exists():
             raise exceptions.OutputMissingError(f"Stage did not produce output: {path}")
         if path.is_dir():
-            tree_hash, manifest = cache.hash_directory(
+            output_hashes[types.identity_key(ref.identity)] = cache.hash_directory(
                 path, state_db, cache_dir=cache_dir, warn_left_out_symlinks=True
             )
-            output_hashes[types.identity_key(ref.identity)] = DirHash(
-                hash=tree_hash, manifest=manifest
-            )
         else:
             file_hash, _ = cache.hash_file(path, state_db)
             output_hashes[types.identity_key(ref.identity)] = FileHash(hash=file_hash)
@@ -1290,8 +1285,7 @@ def hash_dependencies(
             path = pathlib.Path(normalized_path)
             try:
                 if path.is_dir():
-                    tree_hash, manifest = cache.hash_directory(path, state_db)
-                    hashes[dep] = DirHash(hash=tree_hash, manifest=manifest)
+                    hashes[dep] = cache.hash_directory(path, state_db)
                 else:
                     file_hash, fs_stat = cache.hash_file(path, state_db)
                     hashes[dep] = FileHash(hash=file_hash)

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/explain.py

@@ -14,7 +14,7 @@ import pydantic
 
 from pivot import parameters, project, registry, skip, types
 from pivot.executor import worker
-from pivot.storage import lock, state
+from pivot.storage import lock, state, track
 from pivot.storage import store as store_mod
 from pivot.types import (
     ArtifactIdentity,
@@ -30,8 +30,6 @@ if TYPE_CHECKING:
 
     import pygtrie
 
-    from pivot.storage.track import PvtData
-
 OUTPUTS_MISSING_REASON = "Outputs missing from cache"
 """Reason for a stage whose lock is current but whose cacheable outputs are absent locally.
 
@@ -105,7 +103,7 @@ def _find_tracked_ancestor(dep: Path, tracked_trie: pygtrie.Trie[str]) -> Path |
 
 def _find_tracked_hash(
     dep: Path,
-    tracked_files: dict[str, PvtData],
+    tracked_files: dict[str, track.PvtData],
     tracked_trie: pygtrie.Trie[str],
 ) -> HashInfo | None:
     """Find hash for dep from tracked files data.
@@ -121,9 +119,7 @@ def _find_tracked_hash(
 
     # Exact match - use top-level hash
     if dep == tracked_path:
-        if "manifest" in pvt_data:
-            return {"hash": pvt_data["hash"], "manifest": pvt_data["manifest"]}
-        return {"hash": pvt_data["hash"]}
+        return track.pvt_to_hash_info(pvt_data)
 
     # Nested path - find in manifest
     if "manifest" not in pvt_data:
@@ -155,7 +151,7 @@ def get_stage_explanation(
     lock_data: LockData | None,
     force: bool = False,
     allow_missing: bool = False,
-    tracked_files: dict[str, PvtData] | None = None,
+    tracked_files: dict[str, track.PvtData] | None = None,
     tracked_trie: pygtrie.Trie[str] | None = None,
     producer_hashes: dict[ArtifactIdentity, HashInfo] | None = None,
 ) -> StageExplanation:

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/remote/sync.py

@@ -11,7 +11,7 @@ from pivot.remote import config as remote_config
 from pivot.remote import storage as remote_mod
 from pivot.storage import cache, lock, track
 from pivot.storage import store as store_mod
-from pivot.types import DirHash, FileHash, HashInfo, RemoteStatus, TransferSummary, is_dir_hash
+from pivot.types import HashInfo, RemoteStatus, TransferSummary, is_dir_hash
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -175,9 +175,7 @@ def _get_file_hash_from_pvt(rel_path: str, proj_root: pathlib.Path) -> HashInfo
     if track_data is None:
         return None
 
-    if "manifest" in track_data:
-        return DirHash(hash=track_data["hash"], manifest=track_data["manifest"])
-    return FileHash(hash=track_data["hash"])
+    return track.pvt_to_hash_info(track_data)
 
 
 def _get_tracked_hashes(proj_root: pathlib.Path) -> set[str]:

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/run_history.py

@@ -64,6 +64,7 @@ class OutputHashEntry(TypedDict):
     path: str
     hash: str
     manifest: NotRequired[list[DirManifestEntry]]
+    empty_dirs: NotRequired[list[str]]
 
 
 def output_hash_to_entry(path: str, oh: HashInfo) -> OutputHashEntry:
@@ -71,6 +72,8 @@ def output_hash_to_entry(path: str, oh: HashInfo) -> OutputHashEntry:
     entry = OutputHashEntry(path=path, hash=oh["hash"])
     if is_dir_hash(oh):
         entry["manifest"] = oh["manifest"]
+        if "empty_dirs" in oh:
+            entry["empty_dirs"] = oh["empty_dirs"]
     return entry
 
 
@@ -78,7 +81,10 @@ def entry_to_output_hash(entry: OutputHashEntry) -> FileHash | DirHash:
     """Convert serialized OutputHashEntry back to internal HashInfo."""
     # Null check guards against corrupted JSON where manifest could be null
     if "manifest" in entry and entry["manifest"] is not None:  # pyright: ignore[reportUnnecessaryComparison]
-        return DirHash(hash=entry["hash"], manifest=entry["manifest"])
+        dir_hash = DirHash(hash=entry["hash"], manifest=entry["manifest"])
+        if "empty_dirs" in entry and entry["empty_dirs"]:
+            dir_hash["empty_dirs"] = entry["empty_dirs"]
+        return dir_hash
     return FileHash(hash=entry["hash"])
 
 

{pivot-0.3.2 → pivot-0.3.4}/src/pivot/status.py

@@ -356,7 +356,7 @@ def get_tracked_files_status(
 
             try:
                 if path.is_dir():
-                    current_hash, _ = cache.hash_directory(path, state_db, cache_dir=cache_dir)
+                    current_hash = cache.hash_directory(path, state_db, cache_dir=cache_dir)["hash"]
                 else:
                     current_hash, _ = cache.hash_file(path, state_db)
             except FileNotFoundError: