refactor(gc): consistent hash-side stat names (hash_paths_*, orphaned_hash_paths)

Mirror the schema-addressed naming on the hash-addressed side of the collect()
report, so the two sections read in parallel:

  hash_referenced      -> hash_paths_referenced
  hash_stored          -> hash_paths_stored
  hash_orphaned        -> hash_paths_orphaned
  hash_orphaned_bytes  -> hash_paths_orphaned_bytes
  orphaned_hashes      -> orphaned_hash_paths
  hash_deleted         -> hash_paths_deleted

Keys and the corresponding internal variables renamed; no behavior change.
Tests and docs (datajoint-docs) updated. GC suite 39/39.

Author: dimitri-yatsenko

src/datajoint/gc.py

@@ -318,47 +318,47 @@ def collect(self, dry_run: bool = True, verbose: bool = False) -> dict[str, Any]
 
         Returns a dict with per-section stats and the deletion outcome:
 
-        - hash_referenced / hash_stored / hash_orphaned / hash_orphaned_bytes
-        - orphaned_hashes: orphaned hash items as full relative store paths
+        - hash_paths_referenced / hash_paths_stored / hash_paths_orphaned / hash_paths_orphaned_bytes
+        - orphaned_hash_paths: orphaned hash items as full relative store paths
           (NOT bare hashes — passed as-is to the deleter)
         - schema_paths_referenced / schema_paths_stored / schema_paths_orphaned
           / schema_paths_orphaned_bytes
         - orphaned_paths: orphaned schema files as full relative store paths
-        - hash_deleted / schema_paths_deleted / deleted / bytes_freed (0 when
+        - hash_paths_deleted / schema_paths_deleted / deleted / bytes_freed (0 when
           dry_run) / errors / dry_run
         """
         # References can be gathered across all schemas at once: because paths
         # embed the schema, a file under schema X is only ever covered by an X
         # reference, so combined coverage equals per-schema coverage.
-        hash_referenced = self.hash_references(verbose=verbose)
+        hash_paths_referenced = self.hash_references(verbose=verbose)
         schema_paths_referenced = self.schema_references(verbose=verbose)
 
-        hash_stored: dict[str, int] = {}
+        hash_paths_stored: dict[str, int] = {}
         schema_paths_stored: dict[str, int] = {}
         for schema in self.schemas:
-            hash_stored.update(self.list_hash_paths(schema.database))
+            hash_paths_stored.update(self.list_hash_paths(schema.database))
             schema_paths_stored.update(self.list_schema_paths(schema.database))
 
-        orphaned_hashes = sorted(set(hash_stored.keys()) - hash_referenced)
+        orphaned_hash_paths = sorted(set(hash_paths_stored.keys()) - hash_paths_referenced)
         # Coverage, not exact set difference: a referenced path may be a
         # directory-valued object (many files + a manifest sidecar).
         orphaned_paths = sorted(p for p in schema_paths_stored if not _is_covered(p, schema_paths_referenced))
 
-        hash_deleted = 0
+        hash_paths_deleted = 0
         schema_paths_deleted = 0
         bytes_freed = 0
         errors = 0
 
         if not dry_run:
             # The size maps from the scan above are reused for the byte tally —
             # no second listing pass.
-            for path in orphaned_hashes:
+            for path in orphaned_hash_paths:
                 try:
                     if delete_path(path, self.store, config=self.config):
-                        hash_deleted += 1
-                        bytes_freed += hash_stored.get(path, 0)
+                        hash_paths_deleted += 1
+                        bytes_freed += hash_paths_stored.get(path, 0)
                         if verbose:
-                            logger.info(f"Deleted: {path} ({hash_stored.get(path, 0)} bytes)")
+                            logger.info(f"Deleted: {path} ({hash_paths_stored.get(path, 0)} bytes)")
                 except Exception as e:
                     errors += 1
                     logger.warning(f"Failed to delete {path}: {e}")
@@ -376,21 +376,21 @@ def collect(self, dry_run: bool = True, verbose: bool = False) -> dict[str, Any]
 
         return {
             # Hash-addressed storage stats
-            "hash_referenced": len(hash_referenced),
-            "hash_stored": len(hash_stored),
-            "hash_orphaned": len(orphaned_hashes),
-            "hash_orphaned_bytes": sum(hash_stored.get(h, 0) for h in orphaned_hashes),
-            "orphaned_hashes": orphaned_hashes,
+            "hash_paths_referenced": len(hash_paths_referenced),
+            "hash_paths_stored": len(hash_paths_stored),
+            "hash_paths_orphaned": len(orphaned_hash_paths),
+            "hash_paths_orphaned_bytes": sum(hash_paths_stored.get(h, 0) for h in orphaned_hash_paths),
+            "orphaned_hash_paths": orphaned_hash_paths,
             # Schema-addressed storage stats
             "schema_paths_referenced": len(schema_paths_referenced),
             "schema_paths_stored": len(schema_paths_stored),
             "schema_paths_orphaned": len(orphaned_paths),
             "schema_paths_orphaned_bytes": sum(schema_paths_stored.get(p, 0) for p in orphaned_paths),
             "orphaned_paths": orphaned_paths,
             # Deletion outcome (all zero when dry_run)
-            "hash_deleted": hash_deleted,
+            "hash_paths_deleted": hash_paths_deleted,
             "schema_paths_deleted": schema_paths_deleted,
-            "deleted": hash_deleted + schema_paths_deleted,
+            "deleted": hash_paths_deleted + schema_paths_deleted,
             "bytes_freed": bytes_freed,
             "errors": errors,
             "dry_run": dry_run,

tests/integration/test_gc.py

@@ -228,8 +228,8 @@ def test_dry_run_reports_stats_and_deletes_nothing(self):
         assert stats["deleted"] == 0 and stats["bytes_freed"] == 0
         mock_delete.assert_not_called()
         # full report is present
-        assert stats["hash_orphaned"] == 1 and stats["orphaned_hashes"] == ["_hash/s/path3"]
-        assert stats["hash_orphaned_bytes"] == 200
+        assert stats["hash_paths_orphaned"] == 1 and stats["orphaned_hash_paths"] == ["_hash/s/path3"]
+        assert stats["hash_paths_orphaned_bytes"] == 200
         assert stats["schema_paths_orphaned"] == 1 and stats["orphaned_paths"] == ["s/t/pk2/f"]
         assert stats["schema_paths_orphaned_bytes"] == 300
         # no combined totals
@@ -246,7 +246,7 @@ def test_delete_removes_orphans_via_bound_store(self):
             collector = _mock_collector()
             stats = collector.collect(dry_run=False)
 
-        assert stats["hash_deleted"] == 1 and stats["schema_paths_deleted"] == 1
+        assert stats["hash_paths_deleted"] == 1 and stats["schema_paths_deleted"] == 1
         assert stats["deleted"] == 2
         assert stats["bytes_freed"] == 500  # 200 (hash path3) + 300 (schema pk2)
         assert stats["dry_run"] is False
@@ -303,7 +303,7 @@ def schema_object(self, connection_test, prefix, mock_stores):
         schema.drop()
 
     def test_scan_finds_active_blob_reference(self, schema_blob):
-        """scan() must report hash_referenced >= 1 for a populated <blob@> column.
+        """scan() must report hash_paths_referenced >= 1 for a populated <blob@> column.
 
         Decoded value type returned by BlobCodec.decode is numpy.ndarray, which
         does not satisfy the raw-metadata dict/JSON-string check in referenced_paths — this
@@ -314,7 +314,7 @@ def test_scan_finds_active_blob_reference(self, schema_blob):
         collector = _gc(schema_blob)
         stats = collector.collect()
 
-        assert stats["hash_referenced"] >= 1, f"scan should find the active <blob@> reference; got {stats}"
+        assert stats["hash_paths_referenced"] >= 1, f"scan should find the active <blob@> reference; got {stats}"
 
     def test_scan_finds_active_npy_reference(self, schema_npy):
         """scan() must report schema_paths_referenced >= 1 for a populated <npy@> column.
@@ -607,8 +607,8 @@ def test_custom_sections_written_scanned_and_collected(self, schema_prefixed):
 
         # GC scans the same sections: everything referenced, nothing falsely orphaned
         stats = collector.collect()
-        assert stats["hash_referenced"] >= 1
-        assert not (hash_refs & set(stats["orphaned_hashes"]))
+        assert stats["hash_paths_referenced"] >= 1
+        assert not (hash_refs & set(stats["orphaned_hash_paths"]))
         assert not (obj_refs & set(stats["orphaned_paths"]))
 
         # And reclamation works within the configured sections
@@ -663,7 +663,7 @@ def test_live_hash_object_survives_prefix_change(self, schema_pfx):
             assert hash_ref not in set(
                 stats["orphaned_paths"]
             ), "live hash object outside the current hash section must not be a schema orphan"
-            assert hash_ref not in set(stats["orphaned_hashes"])
+            assert hash_ref not in set(stats["orphaned_hash_paths"])
 
             # End-to-end: collect must not destroy the live hash object.
             collector.collect(dry_run=False)
@@ -735,8 +735,8 @@ def test_scan_one_schema_ignores_the_other(self, two_schemas):
 
         stats = collector.collect()
         # b's live objects are outside a's subtree → not counted, not orphaned
-        assert stats["hash_orphaned"] == 0 and stats["schema_paths_orphaned"] == 0
-        assert not any(b.database in p for p in stats["orphaned_paths"] + stats["orphaned_hashes"])
+        assert stats["hash_paths_orphaned"] == 0 and stats["schema_paths_orphaned"] == 0
+        assert not any(b.database in p for p in stats["orphaned_paths"] + stats["orphaned_hash_paths"])
 
     def test_collect_one_schema_never_touches_the_other(self, two_schemas):
         a, b, b_blob, b_obj = two_schemas