computefence 0.2.11__tar.gz → 0.2.13__tar.gz

{computefence-0.2.11 → computefence-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: computefence
-Version: 0.2.11
+Version: 0.2.13
 Summary: Don't lose another RunPod checkpoint to ephemeral disk before your job bills.
 License-Expression: MIT
 Keywords: runpod,vast.ai,gpu training,hf_home,cuda,preflight,machine learning,mlops,checkpoint

computefence-0.2.13/computefence/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.13"

{computefence-0.2.11 → computefence-0.2.13}/computefence/cli.py

@@ -5,6 +5,7 @@ from computefence.checks.environment import check_environment
 from computefence.checks.storage import check_disk_headroom, check_output_dir, check_storage
 from computefence.checks.dataset import check_dataset
 from computefence.telemetry import record_run
+from computefence.drift import save_env, check_drift
 
 console = Console()
 
@@ -28,6 +29,10 @@ def doctor():
     input_column = None
     label_column = None
     output_dir = None
+    save_env_flag = False
+    check_drift_flag = False
+    path_override = None
+
     args = sys.argv[1:]
     i = 0
     while i < len(args):
@@ -43,6 +48,15 @@ def doctor():
         elif args[i] == "--output-dir" and i + 1 < len(args):
             output_dir = args[i + 1]
             i += 2
+        elif args[i] == "--save-env":
+            save_env_flag = True
+            i += 1
+        elif args[i] == "--check-drift":
+            check_drift_flag = True
+            i += 1
+        elif args[i] == "--path" and i + 1 < len(args):
+            path_override = args[i + 1]
+            i += 2
         else:
             i += 1
 
@@ -82,6 +96,15 @@ def doctor():
     console.print("[bold blue]Dataset[/bold blue]")
     for result in dataset_results:
         print_result(result)
+
+    if check_drift_flag:
+        drift_results = check_drift(output_dir=output_dir, path_override=path_override)
+        console.print()
+        console.print("[bold blue]Drift[/bold blue]")
+        for result in drift_results:
+            print_result(result)
+        all_results = all_results + drift_results
+
     console.print()
     console.print("━" * 50)
     if failures:
@@ -97,6 +120,18 @@ def doctor():
     )
     console.print()
 
+    if save_env_flag:
+        if failures:
+            console.print("[yellow]⚠ --save-env skipped: blockers present. Fix errors first.[/yellow]")
+            console.print()
+        else:
+            success, msg = save_env(output_dir=output_dir, path_override=path_override)
+            if success:
+                console.print(f"[green]✓ Environment fingerprint saved to {msg}[/green]")
+            else:
+                console.print(f"[yellow]⚠ Could not save fingerprint: {msg}[/yellow]")
+            console.print()
+
     record_run(all_results)
 
 def main():
@@ -108,4 +143,4 @@ def main():
         console.print("Usage: computefence doctor")
 
 if __name__ == "__main__":
-    main()
+    main()

computefence-0.2.13/computefence/drift.py

@@ -0,0 +1,204 @@
+"""
+Drift detection for ComputeFence v0.2.13.
+
+--save-env  : capture a 4-vector environment fingerprint after a clean run
+              and write it to .computefence-lock.json in the persistent volume.
+--check-drift : compare the current environment against a saved fingerprint
+                and report differences as warnings (never blockers).
+"""
+
+import json
+import os
+from pathlib import Path
+
+
+LOCK_FILENAME = ".computefence-lock.json"
+
+PERSISTENT_VOLUME_CANDIDATES = [
+    "/workspace",
+    "/mnt/storage",
+    "/runpod-volume",
+    "/vast",
+]
+
+
+def _find_persistent_volume(path_override=None):
+    if path_override:
+        p = Path(path_override)
+        if p.exists():
+            return p
+        return None
+    for candidate in PERSISTENT_VOLUME_CANDIDATES:
+        p = Path(candidate)
+        if p.exists() and os.access(candidate, os.W_OK):
+            return p
+    return None
+
+
+def _get_lock_path(path_override=None):
+    vol = _find_persistent_volume(path_override)
+    if vol is None:
+        return None
+    return vol / LOCK_FILENAME
+
+
+def _vector_torch():
+    try:
+        import torch
+        return {
+            "torch_version": torch.__version__,
+            "cuda_version": torch.version.cuda or "none",
+        }
+    except ImportError:
+        return {"torch_version": "not_installed", "cuda_version": "none"}
+
+
+def _vector_storage(output_dir=None):
+    result = {}
+    hf_home = os.environ.get("HF_HOME", "")
+    result["hf_home"] = hf_home if hf_home else "unset"
+    result["hf_home_persistent"] = any(
+        hf_home.startswith(c) for c in PERSISTENT_VOLUME_CANDIDATES
+    ) if hf_home else False
+    result["output_dir"] = output_dir or "not_specified"
+    result["output_dir_persistent"] = any(
+        (output_dir or "").startswith(c) for c in PERSISTENT_VOLUME_CANDIDATES
+    )
+    return result
+
+
+def _vector_gpu():
+    try:
+        import torch
+        count = torch.cuda.device_count()
+        caps = []
+        for i in range(count):
+            props = torch.cuda.get_device_properties(i)
+            caps.append(f"{props.major}.{props.minor}")
+        return {"gpu_count": count, "compute_capabilities": caps}
+    except Exception:
+        return {"gpu_count": 0, "compute_capabilities": []}
+
+
+def _vector_libraries():
+    libs = {}
+    for lib in ["flash_attn", "transformers", "accelerate", "bitsandbytes"]:
+        try:
+            mod = __import__(lib)
+            libs[lib] = getattr(mod, "__version__", "unknown")
+        except ImportError:
+            libs[lib] = "not_installed"
+    return libs
+
+
+def capture_fingerprint(output_dir=None):
+    return {
+        "schema_version": 1,
+        "torch": _vector_torch(),
+        "storage": _vector_storage(output_dir),
+        "gpu": _vector_gpu(),
+        "libraries": _vector_libraries(),
+    }
+
+
+def save_env(output_dir=None, path_override=None):
+    lock_path = _get_lock_path(path_override)
+    if lock_path is None:
+        return False, (
+            "No persistent volume found. Cannot save environment fingerprint. "
+            "Use --path /your/persistent/dir to specify one."
+        )
+    fingerprint = capture_fingerprint(output_dir)
+    try:
+        with open(lock_path, "w") as f:
+            json.dump(fingerprint, f, indent=2)
+        return True, str(lock_path)
+    except Exception as e:
+        return False, f"Failed to write {lock_path}: {e}"
+
+
+def _diff_vectors(saved, current):
+    results = []
+
+    s_torch = saved.get("torch", {})
+    c_torch = current.get("torch", {})
+    if s_torch.get("torch_version") != c_torch.get("torch_version"):
+        results.append({
+            "status": "warn",
+            "message": f"[Drift] PyTorch version changed: {s_torch.get('torch_version')} → {c_torch.get('torch_version')}",
+            "fix": "Pin torch version in your requirements or Dockerfile.",
+        })
+    if s_torch.get("cuda_version") != c_torch.get("cuda_version"):
+        results.append({
+            "status": "warn",
+            "message": f"[Drift] CUDA version changed: {s_torch.get('cuda_version')} → {c_torch.get('cuda_version')}",
+            "fix": "Ensure your pod template uses the same CUDA base image.",
+        })
+
+    s_stor = saved.get("storage", {})
+    c_stor = current.get("storage", {})
+    if s_stor.get("hf_home") != c_stor.get("hf_home"):
+        results.append({
+            "status": "warn",
+            "message": f"[Drift] HF_HOME changed: {s_stor.get('hf_home')} → {c_stor.get('hf_home')}",
+            "fix": "Set HF_HOME consistently in your startup script.",
+        })
+    if s_stor.get("output_dir_persistent") and not c_stor.get("output_dir_persistent"):
+        results.append({
+            "status": "warn",
+            "message": "[Drift] Output directory was persistent before — now appears ephemeral.",
+            "fix": "Pass --output-dir pointing to /workspace or your persistent mount.",
+        })
+
+    s_gpu = saved.get("gpu", {})
+    c_gpu = current.get("gpu", {})
+    if s_gpu.get("gpu_count") != c_gpu.get("gpu_count"):
+        results.append({
+            "status": "warn",
+            "message": f"[Drift] GPU count changed: {s_gpu.get('gpu_count')} → {c_gpu.get('gpu_count')}",
+            "fix": "Check your pod configuration matches the saved environment.",
+        })
+    if s_gpu.get("compute_capabilities") != c_gpu.get("compute_capabilities"):
+        results.append({
+            "status": "warn",
+            "message": f"[Drift] GPU compute capability changed: {s_gpu.get('compute_capabilities')} → {c_gpu.get('compute_capabilities')}",
+            "fix": "Different GPU hardware detected. Verify model compatibility.",
+        })
+
+    s_libs = saved.get("libraries", {})
+    c_libs = current.get("libraries", {})
+    for lib in set(list(s_libs.keys()) + list(c_libs.keys())):
+        sv = s_libs.get(lib, "not_installed")
+        cv = c_libs.get(lib, "not_installed")
+        if sv != cv:
+            results.append({
+                "status": "warn",
+                "message": f"[Drift] {lib} version changed: {sv} → {cv}",
+                "fix": f"Pin {lib} version in your requirements.",
+            })
+
+    if not results:
+        results.append({
+            "status": "pass",
+            "message": "Environment matches saved fingerprint — no drift detected.",
+        })
+
+    return results
+
+
+def check_drift(output_dir=None, path_override=None):
+    lock_path = _get_lock_path(path_override)
+    if lock_path is None:
+        return [{"status": "warn", "message": "No persistent volume found.", "fix": "Use --path to specify your persistent directory."}]
+
+    if not lock_path.exists():
+        return [{"status": "warn", "message": f"No saved fingerprint at {lock_path}.", "fix": "Run: computefence doctor --save-env"}]
+
+    try:
+        with open(lock_path) as f:
+            saved = json.load(f)
+    except Exception as e:
+        return [{"status": "warn", "message": f"Could not read fingerprint: {e}", "fix": "Delete the file and re-run: computefence doctor --save-env"}]
+
+    current = capture_fingerprint(output_dir)
+    return _diff_vectors(saved, current)

{computefence-0.2.11 → computefence-0.2.13}/computefence/telemetry.py

@@ -1,6 +1,7 @@
 import hashlib
 import os
 import platform
+import subprocess
 import sys
 import threading
 import uuid
@@ -16,6 +17,57 @@ def _is_opted_out():
     return OPT_OUT_FILE.exists()
 
 
+def get_project_id() -> str:
+    # Primary: git remote URL hash — survives pod recreation
+    try:
+        git_url = subprocess.check_output(
+            ["git", "config", "--get", "remote.origin.url"],
+            stderr=subprocess.DEVNULL
+        ).decode().strip()
+        if git_url:
+            return hashlib.sha256(git_url.encode()).hexdigest()[:16]
+    except Exception:
+        pass
+
+    # Fallback: persistent volume token
+    token_path = "/workspace/.computefence_id"
+    try:
+        if os.path.exists(token_path):
+            with open(token_path) as f:
+                token = f.read().strip()
+                if token:
+                    return token
+    except Exception:
+        pass
+
+    # Last resort: ephemeral cwd hash
+    return "ephemeral-" + hashlib.sha256(os.getcwd().encode()).hexdigest()[:8]
+
+
+def get_execution_mode() -> str:
+    if os.environ.get("GITHUB_ACTIONS"):
+        return "github-action"
+    if os.environ.get("CI"):
+        return "ci"
+    try:
+        ppid = os.getppid()
+        result = subprocess.run(
+            ["ps", "-p", str(ppid), "-o", "comm="],
+            capture_output=True, text=True, timeout=2
+        )
+        parent = result.stdout.strip().lower()
+        if "bash" in parent or "sh" in parent:
+            cmdline_path = f"/proc/{ppid}/cmdline"
+            if os.path.exists(cmdline_path):
+                with open(cmdline_path, "rb") as f:
+                    cmdline = f.read().decode(errors="replace").replace("\x00", " ")
+                if "on-start" in cmdline or "startup" in cmdline or "entrypoint" in cmdline:
+                    return "on-start"
+    except Exception:
+        pass
+    return "manual"
+
+
 def _send(payload: dict):
     try:
         import requests
@@ -49,7 +101,6 @@ def record_run(results: list):
         gpu_count = torch.cuda.device_count()
     except Exception:
         try:
-            import subprocess
             result = subprocess.run(
                 ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
                 capture_output=True, text=True, timeout=5
@@ -69,8 +120,11 @@ def record_run(results: list):
         "blocker_count": blocker_count,
         "pass_count": pass_count,
         "opted_in": True,
+        "project_id": get_project_id(),
+        "run_id": str(uuid.uuid4()),
+        "execution_mode": get_execution_mode(),
     }
 
     thread = threading.Thread(target=_send, args=(payload,), daemon=True)
     thread.start()
-    thread.join(timeout=4)
+    thread.join(timeout=4)

{computefence-0.2.11 → computefence-0.2.13}/computefence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: computefence
-Version: 0.2.11
+Version: 0.2.13
 Summary: Don't lose another RunPod checkpoint to ephemeral disk before your job bills.
 License-Expression: MIT
 Keywords: runpod,vast.ai,gpu training,hf_home,cuda,preflight,machine learning,mlops,checkpoint

{computefence-0.2.11 → computefence-0.2.13}/computefence.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 computefence/__init__.py
 computefence/cli.py
+computefence/drift.py
 computefence/telemetry.py
 computefence.egg-info/PKG-INFO
 computefence.egg-info/SOURCES.txt

computefence-0.2.11/computefence/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.11"