computefence 0.2.12__tar.gz → 0.2.14__tar.gz

{computefence-0.2.12 → computefence-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: computefence
-Version: 0.2.12
+Version: 0.2.14
 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.14/computefence/__init__.py

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

{computefence-0.2.12 → computefence-0.2.14}/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.14/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.12 → computefence-0.2.14}/computefence/telemetry.py

@@ -29,7 +29,7 @@ def get_project_id() -> str:
     except Exception:
         pass
 
-    # Fallback: persistent volume token
+    # Fallback: persistent volume token — read or create
     token_path = "/workspace/.computefence_id"
     try:
         if os.path.exists(token_path):
@@ -37,6 +37,11 @@ def get_project_id() -> str:
                 token = f.read().strip()
                 if token:
                     return token
+        # No token exists — generate and write one
+        new_token = str(uuid.uuid4())
+        with open(token_path, "w") as f:
+            f.write(new_token)
+        return new_token
     except Exception:
         pass
 

{computefence-0.2.12 → computefence-0.2.14}/computefence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: computefence
-Version: 0.2.12
+Version: 0.2.14
 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.12 → computefence-0.2.14}/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.12/computefence/__init__.py

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