datavault-cli 1.0.0__py3-none-any.whl

row_tracker.py

@@ -0,0 +1,201 @@
+import csv
+import hashlib
+import json
+import os
+
+ROWLOG_DIR   = ".datavault/rowlogs"
+HISTORY_FILE = ".datavault/history.json"
+
+
+def hash_row(row_dict):
+    row_str = json.dumps(row_dict, sort_keys=True, ensure_ascii=False)
+    return hashlib.sha256(row_str.encode()).hexdigest()[:16]
+
+
+def parse_csv_rows(filepath):
+    try:
+        with open(filepath, "r", encoding="utf-8", newline="") as f:
+            reader  = csv.DictReader(f)
+            headers = reader.fieldnames or []
+            rows    = [dict(row) for row in reader]
+        return headers, rows
+    except Exception:
+        return [], []
+
+
+def build_row_snapshot(filepath):
+    headers, rows = parse_csv_rows(filepath)
+    if not rows:
+        return {}, headers
+    snapshot = {}
+    for i, row in enumerate(rows):
+        row_hash = hash_row(row)
+        snapshot[row_hash] = {"position": i, "data": row, "hash": row_hash}
+    return snapshot, headers
+
+
+def save_row_snapshot(filename, version_id, snapshot, headers):
+    os.makedirs(ROWLOG_DIR, exist_ok=True)
+    safe_name = filename.replace("/", "_").replace("\\", "_")
+    path      = os.path.join(ROWLOG_DIR, f"{safe_name}__{version_id}.json")
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump({"headers": headers, "rows": snapshot}, f, indent=2)
+
+
+def load_row_snapshot(filename, version_id):
+    safe_name = filename.replace("/", "_").replace("\\", "_")
+    path      = os.path.join(ROWLOG_DIR, f"{safe_name}__{version_id}.json")
+    if not os.path.exists(path):
+        return None, None
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data.get("rows", {}), data.get("headers", [])
+
+
+def snapshot_on_commit(filepath, version_id):
+    if not filepath.lower().endswith(".csv"):
+        return False
+    filename          = os.path.basename(filepath)
+    snapshot, headers = build_row_snapshot(filepath)
+    if snapshot:
+        save_row_snapshot(filename, version_id, snapshot, headers)
+        return True
+    return False
+
+
+def row_diff(filepath, version_a, version_b):
+    filename        = os.path.basename(filepath)
+    snap_a, headers = load_row_snapshot(filename, version_a)
+    snap_b, _       = load_row_snapshot(filename, version_b)
+
+    if snap_a is None:
+        return False, f"No row snapshot for {version_a}. Re-commit to generate one."
+    if snap_b is None:
+        return False, f"No row snapshot for {version_b}. Re-commit to generate one."
+
+    hashes_a = set(snap_a.keys())
+    hashes_b = set(snap_b.keys())
+    added    = hashes_b - hashes_a
+    deleted  = hashes_a - hashes_b
+    moved    = [(h, snap_a[h]["position"], snap_b[h]["position"])
+                for h in hashes_a & hashes_b
+                if snap_a[h]["position"] != snap_b[h]["position"]]
+
+    lines = [
+        f"\nRow-level diff: '{filename}'  {version_a} → {version_b}",
+        "─" * 55,
+        f"  Rows added:   {len(added)}",
+        f"  Rows deleted: {len(deleted)}",
+        f"  Rows moved:   {len(moved)}",
+        f"  Unchanged:    {len(hashes_a & hashes_b) - len(moved)}",
+        ""
+    ]
+    if added:
+        lines.append("  ADDED rows:")
+        for h in list(added)[:10]:
+            lines.append(f"    + {dict(list(snap_b[h]['data'].items())[:4])}")
+        if len(added) > 10:
+            lines.append(f"    ... and {len(added)-10} more")
+    if deleted:
+        lines.append("\n  DELETED rows:")
+        for h in list(deleted)[:10]:
+            lines.append(f"    - {dict(list(snap_a[h]['data'].items())[:4])}")
+        if len(deleted) > 10:
+            lines.append(f"    ... and {len(deleted)-10} more")
+    if moved:
+        lines.append("\n  MOVED rows:")
+        for h, pos_a, pos_b in moved[:5]:
+            lines.append(f"    ~ row {pos_a+1} → row {pos_b+1}: {dict(list(snap_a[h]['data'].items())[:2])}")
+
+    return True, "\n".join(lines)
+
+
+def row_history(filepath, row_identifier_col, row_identifier_val):
+    filename = os.path.basename(filepath)
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+
+    with open(HISTORY_FILE, "r") as f:
+        history = json.load(f)
+
+    if filename not in history.get("files", {}):
+        return False, f"'{filename}' is not tracked."
+
+    versions = history["files"][filename]["versions"]
+    timeline = []
+
+    for v in versions:
+        snapshot, _ = load_row_snapshot(filename, v["version_id"])
+        if snapshot is None:
+            continue
+        found = next(
+            (row_data for row_data in snapshot.values()
+             if row_data["data"].get(row_identifier_col) == str(row_identifier_val)),
+            None
+        )
+        timeline.append({"version_id": v["version_id"], "timestamp": v["timestamp"], "message": v["message"], "row": found})
+
+    if not any(t["row"] for t in timeline):
+        return False, f"No row found where {row_identifier_col}={row_identifier_val}\nCheck your CSV headers."
+
+    lines    = [f"\nRow history: {filename} where {row_identifier_col}={row_identifier_val}", "─" * 55]
+    prev_row = None
+
+    for entry in timeline:
+        ts  = entry["timestamp"][:19].replace("T", " ")
+        row = entry["row"]
+        lines.append(f"\n  {entry['version_id']}  |  {ts}")
+        if row is None:
+            lines.append(f"  ✗ Row not present in this version")
+        else:
+            lines.append(f"  Message: {entry['message']}")
+            if prev_row and prev_row != row["data"]:
+                changed = {k: f"{prev_row.get(k,'—')} → v" for k, v in row["data"].items() if row["data"].get(k) != prev_row.get(k)}
+                lines.append(f"  Changes: {changed}" if changed else f"  Position moved: row {row['position']+1}")
+            elif prev_row is None:
+                lines.append(f"  First appearance: {row['data']}")
+            prev_row = row["data"]
+
+    return True, "\n".join(lines)
+
+
+def row_stats(filepath):
+    filename = os.path.basename(filepath)
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+
+    with open(HISTORY_FILE, "r") as f:
+        history = json.load(f)
+
+    if filename not in history.get("files", {}):
+        return False, f"'{filename}' is not tracked."
+
+    versions      = history["files"][filename]["versions"]
+    lines         = [f"\nRow statistics: '{filename}'\n" + "─"*50]
+    prev_snapshot = None
+    total_added   = 0
+    total_deleted = 0
+
+    for v in versions:
+        snapshot, _ = load_row_snapshot(filename, v["version_id"])
+        if snapshot is None:
+            lines.append(f"\n  {v['version_id']}: no row snapshot available")
+            continue
+        ts = v["timestamp"][:19].replace("T", " ")
+        if prev_snapshot is not None:
+            added         = len(set(snapshot.keys()) - set(prev_snapshot.keys()))
+            deleted       = len(set(prev_snapshot.keys()) - set(snapshot.keys()))
+            total_added   += added
+            total_deleted += deleted
+            change_str    = f"+{added} added, -{deleted} deleted"
+        else:
+            change_str = "initial snapshot"
+        lines.append(f"\n  {v['version_id']}  |  {ts}")
+        lines.append(f"  {len(snapshot)} rows total  |  {change_str}")
+        lines.append(f"  \"{v['message']}\"")
+        prev_snapshot = snapshot
+
+    lines.append(f"\n{'─'*50}")
+    lines.append(f"  Total rows added across all versions:   {total_added}")
+    lines.append(f"  Total rows deleted across all versions: {total_deleted}")
+    return True, "\n".join(lines)

signing.py

@@ -0,0 +1,166 @@
+import hashlib
+import json
+import os
+from datetime import datetime
+
+HISTORY_FILE = ".datavault/history.json"
+SIGNING_FILE = ".datavault/signatures.json"
+ROLES        = ["reviewer", "approver", "owner", "witness"]
+
+
+def sign_version(filepath, version_id, signer_name, role="reviewer"):
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+    if role not in ROLES:
+        return False, f"Invalid role '{role}'. Choose from: {', '.join(ROLES)}"
+
+    with open(HISTORY_FILE, "r") as f:
+        history = json.load(f)
+
+    filename = os.path.basename(filepath)
+    if filename not in history.get("files", {}):
+        return False, f"'{filename}' is not tracked."
+
+    versions = history["files"][filename]["versions"]
+    target   = next((v for v in versions if v["version_id"] == version_id), None)
+    if not target:
+        available = ", ".join(v["version_id"] for v in versions)
+        return False, f"Version '{version_id}' not found. Available: {available}"
+
+    signed_at       = datetime.now().isoformat()
+    signature_input = f"{signer_name}|{role}|{target['hash']}|{version_id}|{signed_at}"
+    signature_hash  = hashlib.sha256(signature_input.encode()).hexdigest()[:32]
+
+    sigs = _load_signatures()
+    if filename not in sigs:
+        sigs[filename] = {}
+    if version_id not in sigs[filename]:
+        sigs[filename][version_id] = []
+
+    if any(s["signer"] == signer_name and s["role"] == role for s in sigs[filename][version_id]):
+        return False, f"'{signer_name}' has already signed {version_id} as {role}."
+
+    sigs[filename][version_id].append({
+        "signer":         signer_name,
+        "role":           role,
+        "signed_at":      signed_at,
+        "file_hash":      target["hash"],
+        "signature_hash": signature_hash,
+        "version_id":     version_id
+    })
+    _save_signatures(sigs)
+
+    return True, (
+        f"Signed '{filename}' {version_id}\n"
+        f"  Signer:    {signer_name} ({role})\n"
+        f"  File hash: {target['hash'][:24]}…\n"
+        f"  Sig hash:  {signature_hash[:24]}…\n"
+        f"  At:        {signed_at[:19].replace('T',' ')}\n"
+        f"\n  Signature is cryptographically tied to {version_id}.\n"
+        f"  If the file changes, this signature becomes invalid."
+    )
+
+
+def verify_signatures(filepath, version_id):
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+
+    with open(HISTORY_FILE, "r") as f:
+        history = json.load(f)
+
+    filename = os.path.basename(filepath)
+    if filename not in history.get("files", {}):
+        return False, f"'{filename}' is not tracked."
+
+    versions = history["files"][filename]["versions"]
+    target   = next((v for v in versions if v["version_id"] == version_id), None)
+    if not target:
+        return False, f"Version '{version_id}' not found."
+
+    sigs         = _load_signatures()
+    version_sigs = sigs.get(filename, {}).get(version_id, [])
+    if not version_sigs:
+        return True, f"No signatures for {version_id} yet."
+
+    lines     = [f"\nSignatures for '{filename}' {version_id}:\n" + "─"*55]
+    all_valid = True
+
+    for sig in version_sigs:
+        expected_input = f"{sig['signer']}|{sig['role']}|{sig['file_hash']}|{sig['version_id']}|{sig['signed_at']}"
+        expected_hash  = hashlib.sha256(expected_input.encode()).hexdigest()[:32]
+        sig_valid      = (expected_hash == sig["signature_hash"])
+        hash_valid     = (sig["file_hash"] == target["hash"])
+
+        if sig_valid and hash_valid:
+            ts = sig["signed_at"][:19].replace("T", " ")
+            lines.append(f"\n  ✓ {sig['signer']} ({sig['role']})\n    Signed: {ts}\n    Sig:    {sig['signature_hash'][:24]}…")
+        elif not hash_valid:
+            all_valid = False
+            lines.append(f"\n  ✗ {sig['signer']} ({sig['role']}) — INVALID\n    File was modified after signing.\n    Signed hash:  {sig['file_hash'][:24]}…\n    Current hash: {target['hash'][:24]}…")
+        else:
+            all_valid = False
+            lines.append(f"\n  ✗ {sig['signer']} ({sig['role']}) — SIGNATURE TAMPERED\n    The signature record itself was modified.")
+
+    lines.append(f"\n{'─'*55}")
+    lines.append(f"  {'✓' if all_valid else '✗'} {'All' if all_valid else 'Some'} {len(version_sigs)} signature(s) {'valid' if all_valid else 'invalid — see above'}")
+    return all_valid, "\n".join(lines)
+
+
+def approval_status(filepath, version_id, require_approver=True, require_reviewer=True):
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+
+    filename     = os.path.basename(filepath)
+    sigs         = _load_signatures()
+    version_sigs = sigs.get(filename, {}).get(version_id, [])
+
+    has_reviewer = any(s["role"] == "reviewer" for s in version_sigs)
+    has_approver = any(s["role"] == "approver" for s in version_sigs)
+    has_owner    = any(s["role"] == "owner"    for s in version_sigs)
+
+    missing  = []
+    if require_reviewer and not has_reviewer: missing.append("reviewer")
+    if require_approver and not has_approver: missing.append("approver")
+    approved = len(missing) == 0 and len(version_sigs) > 0
+
+    lines = [f"\nApproval status: '{filename}' {version_id}\n" + "─"*55]
+    lines.append(f"\n  Reviewer:  {'✓' if has_reviewer else '✗ missing'}")
+    lines.append(f"  Approver:  {'✓' if has_approver else '✗ missing'}")
+    lines.append(f"  Owner:     {'✓' if has_owner else '— (optional)'}")
+    lines.append(f"\n  Total signatures: {len(version_sigs)}")
+    if approved:
+        lines.append(f"\n  ✓ APPROVED — ready for use in AI training")
+    else:
+        lines.append(f"\n  ✗ NOT APPROVED — missing: {', '.join(missing)}")
+        lines.append(f"  Run: python datavault.py sign {filepath} {version_id} <name> <role>")
+
+    return approved, "\n".join(lines)
+
+
+def list_all_signatures(filepath):
+    filename  = os.path.basename(filepath)
+    sigs      = _load_signatures()
+    file_sigs = sigs.get(filename, {})
+    if not file_sigs:
+        return True, f"No signatures found for '{filename}'."
+
+    lines = [f"\nAll signatures for '{filename}':\n" + "─"*55]
+    for version_id, version_sigs in file_sigs.items():
+        lines.append(f"\n  {version_id} ({len(version_sigs)} signature(s)):")
+        for sig in version_sigs:
+            ts = sig["signed_at"][:19].replace("T", " ")
+            lines.append(f"    • {sig['signer']} ({sig['role']}) — {ts}")
+    return True, "\n".join(lines)
+
+
+def _load_signatures():
+    if os.path.exists(SIGNING_FILE):
+        with open(SIGNING_FILE, "r") as f:
+            return json.load(f)
+    return {}
+
+
+def _save_signatures(data):
+    os.makedirs(os.path.dirname(SIGNING_FILE), exist_ok=True)
+    with open(SIGNING_FILE, "w") as f:
+        json.dump(data, f, indent=2)