computefence 0.1.2__tar.gz → 0.2.1__tar.gz

computefence-0.2.1/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: computefence
+Version: 0.2.1
+Summary: Pre-flight validation for GPU training runs on rented infrastructure
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# ComputeFence
+
+Pre-flight safety gate for ML training jobs on rented GPU compute. Built specifically for RunPod, Vast.ai, Lambda Labs, and similar bare metal providers.
+
+## Install
+
+```bash
+pip install computefence
+```
+
+## Usage
+
+```bash
+computefence doctor
+```
+
+With a dataset:
+
+```bash
+computefence doctor --dataset train.csv --input-column text --label-column label
+```
+
+## Example output
+
+ComputeFence v0.1.2 — Pre-flight diagnostic
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 WARNINGS · 0 BLOCKERS · 3 PASSED
+
+Environment
+✓ Python 3.11.4
+✓ PyTorch 2.1.0 detected
+✓ CUDA available — NVIDIA A40
+
+Storage
+⚠ HF_HOME is not set. HuggingFace will use default local cache.
+Fix: Set HF_HOME to a persistent volume path before training
+⚠ No mounted persistent volumes detected at /workspace, /runpod-volume, or /vast
+Fix: Attach a network volume before training to persist checkpoints and cache
+
+Dataset
+✓ No dataset path provided — skipping dataset checks
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 warning(s) found. Review before launching.
+
+## What it checks
+
+- **CUDA and GPU visibility** — confirms PyTorch can see the GPU and training will not silently fall back to CPU
+- **HuggingFace cache path** — confirms model files go to persistent storage not ephemeral disk
+- **Accelerate GPU count** — confirms your distributed training config matches the GPUs actually on the instance
+- **Dataset integrity** — optional scan for duplicates, missing values, and conflicting labels
+
+## What it does not check
+
+- Training script correctness
+- Model architecture compatibility
+- Learning rate or hyperparameter safety
+- Runtime monitoring during the job
+- Slow dataloader or data pipeline throughput
+
+## Why this exists
+
+I burned approximately £1,000 on GPU training runs that failed silently. CUDA fell back to CPU with no error. Class weights caused loss collapse to 0.693 immediately. My dataset had 28,432 duplicate rows and 312 conflicting labels I only found after the run.
+
+Nothing existed that caught these before the job started. So I built it.
+
+## Real operator results
+
+David at Neuralic ran ComputeFence on a RunPod A100. It caught HF_HOME writing to /root/.cache and an Accelerate GPU count mismatch. He fixed both before launch.
+
+## GitHub
+
+github.com/Francisco-Booth/ComputeFence
+
+## PyPI
+
+pypi.org/project/computefence

computefence-0.2.1/README.md

@@ -0,0 +1,77 @@
+# ComputeFence
+
+Pre-flight safety gate for ML training jobs on rented GPU compute. Built specifically for RunPod, Vast.ai, Lambda Labs, and similar bare metal providers.
+
+## Install
+
+```bash
+pip install computefence
+```
+
+## Usage
+
+```bash
+computefence doctor
+```
+
+With a dataset:
+
+```bash
+computefence doctor --dataset train.csv --input-column text --label-column label
+```
+
+## Example output
+
+ComputeFence v0.1.2 — Pre-flight diagnostic
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 WARNINGS · 0 BLOCKERS · 3 PASSED
+
+Environment
+✓ Python 3.11.4
+✓ PyTorch 2.1.0 detected
+✓ CUDA available — NVIDIA A40
+
+Storage
+⚠ HF_HOME is not set. HuggingFace will use default local cache.
+Fix: Set HF_HOME to a persistent volume path before training
+⚠ No mounted persistent volumes detected at /workspace, /runpod-volume, or /vast
+Fix: Attach a network volume before training to persist checkpoints and cache
+
+Dataset
+✓ No dataset path provided — skipping dataset checks
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 warning(s) found. Review before launching.
+
+## What it checks
+
+- **CUDA and GPU visibility** — confirms PyTorch can see the GPU and training will not silently fall back to CPU
+- **HuggingFace cache path** — confirms model files go to persistent storage not ephemeral disk
+- **Accelerate GPU count** — confirms your distributed training config matches the GPUs actually on the instance
+- **Dataset integrity** — optional scan for duplicates, missing values, and conflicting labels
+
+## What it does not check
+
+- Training script correctness
+- Model architecture compatibility
+- Learning rate or hyperparameter safety
+- Runtime monitoring during the job
+- Slow dataloader or data pipeline throughput
+
+## Why this exists
+
+I burned approximately £1,000 on GPU training runs that failed silently. CUDA fell back to CPU with no error. Class weights caused loss collapse to 0.693 immediately. My dataset had 28,432 duplicate rows and 312 conflicting labels I only found after the run.
+
+Nothing existed that caught these before the job started. So I built it.
+
+## Real operator results
+
+David at Neuralic ran ComputeFence on a RunPod A100. It caught HF_HOME writing to /root/.cache and an Accelerate GPU count mismatch. He fixed both before launch.
+
+## GitHub
+
+github.com/Francisco-Booth/ComputeFence
+
+## PyPI
+
+pypi.org/project/computefence

computefence-0.2.1/computefence/__init__.py

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

computefence-0.2.1/computefence/checks/storage.py

@@ -0,0 +1,136 @@
+import os
+import shutil
+from pathlib import Path
+
+# Persistent volume mount points used by the common GPU rental providers.
+MOUNT_CANDIDATES = ["/workspace", "/runpod-volume", "/vast"]
+
+GB = 1024 ** 3
+BLOCKER_BELOW_GB = 5
+WARNING_BELOW_GB = 20
+DISK_FIX = "Free up disk space or attach a larger volume before launching"
+
+
+def check_storage():
+    results = []
+
+    # Read HuggingFace cache environment variables
+    hf_home = os.environ.get("HF_HOME")
+    hf_hub_cache = os.environ.get("HF_HUB_CACHE")
+    xdg_cache = os.environ.get("XDG_CACHE_HOME")
+
+    # Detect mounted persistent volumes
+    mounted_volumes = []
+    for path in MOUNT_CANDIDATES:
+        if Path(path).exists():
+            mounted_volumes.append(path)
+
+    # Check HF_HOME
+    if hf_home is None:
+        if mounted_volumes:
+            results.append({
+                "status": "warn",
+                "message": f"HF_HOME is not set. Mounted volume detected at {mounted_volumes[0]} but HuggingFace will cache to default local path.",
+                "fix": f"export HF_HOME={mounted_volumes[0]}/.cache/huggingface"
+            })
+        else:
+            results.append({
+                "status": "warn",
+                "message": "HF_HOME is not set. HuggingFace will use default local cache.",
+                "fix": "Set HF_HOME to a persistent volume path before training"
+            })
+    elif hf_home.startswith("/root") or hf_home.startswith("/tmp"):
+        results.append({
+            "status": "warn",
+            "message": f"HF_HOME appears to point to ephemeral storage: {hf_home}",
+            "fix": f"export HF_HOME=/workspace/.cache/huggingface"
+        })
+    elif mounted_volumes and not any(hf_home.startswith(v) for v in mounted_volumes):
+        results.append({
+            "status": "warn",
+            "message": f"HF_HOME ({hf_home}) does not appear to be on a mounted volume.",
+            "fix": f"export HF_HOME={mounted_volumes[0]}/.cache/huggingface"
+        })
+    else:
+        results.append({
+            "status": "pass",
+            "message": f"HF_HOME is set to {hf_home}"
+        })
+
+    # Report mounted volumes found
+    if mounted_volumes:
+        results.append({
+            "status": "pass",
+            "message": f"Persistent volume(s) detected: {', '.join(mounted_volumes)}"
+        })
+    else:
+        results.append({
+            "status": "warn",
+            "message": "No mounted persistent volumes detected at /workspace, /runpod-volume, or /vast",
+            "fix": "Attach a network volume before training to persist checkpoints and cache"
+        })
+
+    return results
+
+def check_disk_headroom():
+    """Report free space on the workspace volume(s) and the root disk.
+
+    Uses shutil.disk_usage rather than shelling out to df: it returns the same
+    numbers as exact bytes, with no output parsing and no subprocess.
+    """
+    results = []
+
+    # Build the target list, skipping any path that shares a device with one
+    # already queued so a single filesystem is not reported twice.
+    targets = []
+    seen_devices = set()
+    for path in MOUNT_CANDIDATES + ["/"]:
+        candidate = Path(path)
+        if not candidate.exists():
+            continue
+        try:
+            device = candidate.stat().st_dev
+        except OSError:
+            device = None
+        if device is not None:
+            if device in seen_devices:
+                continue
+            seen_devices.add(device)
+        targets.append(candidate)
+
+    for target in targets:
+        label = "Root disk (/)" if str(target) == "/" else f"Volume {target}"
+
+        try:
+            usage = shutil.disk_usage(target)
+        except OSError as e:
+            results.append({
+                "status": "warn",
+                "message": f"{label} — could not read disk usage: {e}",
+                "fix": DISK_FIX
+            })
+            continue
+
+        free_gb = usage.free / GB
+        total_gb = usage.total / GB
+        summary = f"{label} — {free_gb:.1f} GB free of {total_gb:.1f} GB"
+
+        if free_gb < BLOCKER_BELOW_GB:
+            results.append({
+                "status": "fail",
+                "message": f"{summary} (below {BLOCKER_BELOW_GB} GB)",
+                "fix": DISK_FIX
+            })
+        elif free_gb < WARNING_BELOW_GB:
+            results.append({
+                "status": "warn",
+                "message": f"{summary} (below {WARNING_BELOW_GB} GB)",
+                "fix": DISK_FIX
+            })
+        else:
+            results.append({
+                "status": "pass",
+                "message": summary
+            })
+
+    return results

{computefence-0.1.2 → computefence-0.2.1}/computefence/cli.py

@@ -1,19 +1,17 @@
 import sys
 from rich.console import Console
-
 from computefence import __version__
 from computefence.checks.environment import check_environment
-from computefence.checks.storage import check_storage
+from computefence.checks.storage import check_disk_headroom, check_storage
 from computefence.checks.dataset import check_dataset
+from computefence.telemetry import record_run
 
 console = Console()
 
-
 def print_result(result):
     status = result.get("status")
     message = result.get("message")
     fix = result.get("fix")
-
     if status == "pass":
         console.print(f"  [green]✓[/green] {message}")
     elif status == "warn":
@@ -25,12 +23,10 @@ def print_result(result):
         if fix:
             console.print(f"    [dim]Fix: {fix}[/dim]")
 
-
 def doctor():
     dataset = None
     input_column = None
     label_column = None
-
     args = sys.argv[1:]
     i = 0
     while i < len(args):
@@ -50,10 +46,8 @@ def doctor():
     console.print(f"[bold]ComputeFence v{__version__} — Pre-flight diagnostic[/bold]")
     console.print("━" * 50)
 
-    # Run every check up front so the verdict line can be counted and printed
-    # above the individual results.
     env_results = check_environment()
-    storage_results = check_storage()
+    storage_results = check_storage() + check_disk_headroom()
     dataset_results = check_dataset(
         dataset_path=dataset,
         input_column=input_column,
@@ -61,6 +55,9 @@ def doctor():
     )
 
     all_results = env_results + storage_results + dataset_results
+
+    record_run(all_results)
+
     failures = [r for r in all_results if r["status"] == "fail"]
     warnings = [r for r in all_results if r["status"] == "warn"]
     passed = [r for r in all_results if r["status"] == "pass"]
@@ -71,35 +68,32 @@ def doctor():
         f"[red]{len(failures)} BLOCKERS[/red]  ·  "
         f"[green]{len(passed)} PASSED[/green]"
     )
-
     console.print()
     console.print("[bold blue]Environment[/bold blue]")
     for result in env_results:
         print_result(result)
-
     console.print()
     console.print("[bold blue]Storage[/bold blue]")
     for result in storage_results:
         print_result(result)
-
     console.print()
     console.print("[bold blue]Dataset[/bold blue]")
     for result in dataset_results:
         print_result(result)
-
     console.print()
     console.print("━" * 50)
-
     if failures:
         console.print("[red]" + str(len(failures)) + " error(s) and " + str(len(warnings)) + " warning(s) found. Fix errors before launching.[/red]")
     elif warnings:
         console.print("[yellow]" + str(len(warnings)) + " warning(s) found. Review before launching.[/yellow]")
     else:
         console.print("[green]All checks passed. Safe to launch.[/green]")
-
+    console.print(
+        "[dim]Anonymous usage stats help improve ComputeFence. "
+        "Opt out: touch ~/.computefence_no_telemetry[/dim]"
+    )
     console.print()
 
-
 def main():
     args = sys.argv[1:]
     if not args or args[0] == "doctor":
@@ -108,6 +102,5 @@ def main():
         console.print(f"[red]Unknown command: {args[0]}[/red]")
         console.print("Usage: computefence doctor")
 
-
 if __name__ == "__main__":
     main()

computefence-0.2.1/computefence/telemetry.py

@@ -0,0 +1,64 @@
+import hashlib
+import platform
+import sys
+import threading
+import uuid
+from pathlib import Path
+
+SUPABASE_URL = "https://pidpadpudbcdldyvrlog.supabase.co"
+SUPABASE_ANON_KEY = "sb_publishable_A2zwbfTFiOs63jz8313GXg_elw3F5dy"
+TABLE = "computefence_runs"
+OPT_OUT_FILE = Path.home() / ".computefence_no_telemetry"
+
+
+def _is_opted_out():
+    return OPT_OUT_FILE.exists()
+
+
+def _send(payload: dict):
+    try:
+        import requests
+        requests.post(
+            f"{SUPABASE_URL}/rest/v1/{TABLE}",
+            headers={
+                "apikey": SUPABASE_ANON_KEY,
+                "Authorization": f"Bearer {SUPABASE_ANON_KEY}",
+                "Content-Type": "application/json",
+                "Prefer": "return=minimal",
+            },
+            json=payload,
+            timeout=3,
+        )
+    except Exception:
+        pass
+
+
+def record_run(results: list):
+    if _is_opted_out():
+        return
+
+    warning_count = sum(1 for r in results if r.get("status") == "warn")
+    blocker_count = sum(1 for r in results if r.get("status") == "fail")
+    pass_count = sum(1 for r in results if r.get("status") == "pass")
+
+    try:
+        import torch
+        gpu_count = torch.cuda.device_count()
+    except Exception:
+        gpu_count = 0
+
+    from computefence import __version__
+
+    payload = {
+        "version": __version__,
+        "python_version": f"{sys.version_info.major}.{sys.version_info.minor}",
+        "platform": platform.system(),
+        "gpu_count": gpu_count,
+        "warning_count": warning_count,
+        "blocker_count": blocker_count,
+        "pass_count": pass_count,
+        "opted_in": True,
+    }
+
+    thread = threading.Thread(target=_send, args=(payload,), daemon=True)
+    thread.start()

computefence-0.2.1/computefence.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: computefence
+Version: 0.2.1
+Summary: Pre-flight validation for GPU training runs on rented infrastructure
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# ComputeFence
+
+Pre-flight safety gate for ML training jobs on rented GPU compute. Built specifically for RunPod, Vast.ai, Lambda Labs, and similar bare metal providers.
+
+## Install
+
+```bash
+pip install computefence
+```
+
+## Usage
+
+```bash
+computefence doctor
+```
+
+With a dataset:
+
+```bash
+computefence doctor --dataset train.csv --input-column text --label-column label
+```
+
+## Example output
+
+ComputeFence v0.1.2 — Pre-flight diagnostic
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 WARNINGS · 0 BLOCKERS · 3 PASSED
+
+Environment
+✓ Python 3.11.4
+✓ PyTorch 2.1.0 detected
+✓ CUDA available — NVIDIA A40
+
+Storage
+⚠ HF_HOME is not set. HuggingFace will use default local cache.
+Fix: Set HF_HOME to a persistent volume path before training
+⚠ No mounted persistent volumes detected at /workspace, /runpod-volume, or /vast
+Fix: Attach a network volume before training to persist checkpoints and cache
+
+Dataset
+✓ No dataset path provided — skipping dataset checks
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 warning(s) found. Review before launching.
+
+## What it checks
+
+- **CUDA and GPU visibility** — confirms PyTorch can see the GPU and training will not silently fall back to CPU
+- **HuggingFace cache path** — confirms model files go to persistent storage not ephemeral disk
+- **Accelerate GPU count** — confirms your distributed training config matches the GPUs actually on the instance
+- **Dataset integrity** — optional scan for duplicates, missing values, and conflicting labels
+
+## What it does not check
+
+- Training script correctness
+- Model architecture compatibility
+- Learning rate or hyperparameter safety
+- Runtime monitoring during the job
+- Slow dataloader or data pipeline throughput
+
+## Why this exists
+
+I burned approximately £1,000 on GPU training runs that failed silently. CUDA fell back to CPU with no error. Class weights caused loss collapse to 0.693 immediately. My dataset had 28,432 duplicate rows and 312 conflicting labels I only found after the run.
+
+Nothing existed that caught these before the job started. So I built it.
+
+## Real operator results
+
+David at Neuralic ran ComputeFence on a RunPod A100. It caught HF_HOME writing to /root/.cache and an Accelerate GPU count mismatch. He fixed both before launch.
+
+## GitHub
+
+github.com/Francisco-Booth/ComputeFence
+
+## PyPI
+
+pypi.org/project/computefence

{computefence-0.1.2 → computefence-0.2.1}/computefence.egg-info/SOURCES.txt

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

computefence-0.1.2/PKG-INFO

@@ -1,49 +0,0 @@
-Metadata-Version: 2.4
-Name: computefence
-Version: 0.1.2
-Summary: Pre-flight validation for GPU training runs on rented infrastructure
-License-Expression: MIT
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: rich>=13.0.0
-Requires-Dist: pandas>=1.5.0
-Requires-Dist: typer>=0.9.0
-Requires-Dist: requests>=2.28.0
-Dynamic: license-file
-
-# ComputeFence
-
-Pre-flight validation for GPU training runs on rented infrastructure.
-Built specifically for RunPod, Vast.ai, Lambda, and similar providers.
-
-## Install
-
-pip install computefence
-
-## Usage
-
-computefence doctor
-computefence doctor --dataset train.csv
-
-## What it checks
-
-- CUDA and GPU availability
-- HuggingFace cache volume path (catches the RunPod /root vs /workspace conflict)
-- Accelerate GPU count vs config
-- Dataset duplicates and missing values
-
-## What it does not yet check
-
-- Training script correctness
-- Model architecture compatibility
-- Learning rate or hyperparameter safety
-- Runtime monitoring during the job
-
-## Why this exists
-
-I burned ~£1,000 on GPU training runs that failed silently. CUDA fell back to 
-CPU with no error. Class weights caused loss collapse. My dataset had 28,432 
-duplicate rows and 312 conflicting labels I only found during the rebuild.
-
-Nothing existed that caught these before the job started. So I built it.

computefence-0.1.2/README.md

@@ -1,35 +0,0 @@
-# ComputeFence
-
-Pre-flight validation for GPU training runs on rented infrastructure.
-Built specifically for RunPod, Vast.ai, Lambda, and similar providers.
-
-## Install
-
-pip install computefence
-
-## Usage
-
-computefence doctor
-computefence doctor --dataset train.csv
-
-## What it checks
-
-- CUDA and GPU availability
-- HuggingFace cache volume path (catches the RunPod /root vs /workspace conflict)
-- Accelerate GPU count vs config
-- Dataset duplicates and missing values
-
-## What it does not yet check
-
-- Training script correctness
-- Model architecture compatibility
-- Learning rate or hyperparameter safety
-- Runtime monitoring during the job
-
-## Why this exists
-
-I burned ~£1,000 on GPU training runs that failed silently. CUDA fell back to 
-CPU with no error. Class weights caused loss collapse. My dataset had 28,432 
-duplicate rows and 312 conflicting labels I only found during the rebuild.
-
-Nothing existed that caught these before the job started. So I built it.

computefence-0.1.2/computefence/__init__.py

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

computefence-0.1.2/computefence/checks/storage.py

@@ -1,64 +0,0 @@
-import os
-from pathlib import Path
-
-
-def check_storage():
-    results = []
-
-    # Read HuggingFace cache environment variables
-    hf_home = os.environ.get("HF_HOME")
-    hf_hub_cache = os.environ.get("HF_HUB_CACHE")
-    xdg_cache = os.environ.get("XDG_CACHE_HOME")
-
-    # Detect mounted persistent volumes
-    mounted_volumes = []
-    for path in ["/workspace", "/runpod-volume", "/vast"]:
-        if Path(path).exists():
-            mounted_volumes.append(path)
-
-    # Check HF_HOME
-    if hf_home is None:
-        if mounted_volumes:
-            results.append({
-                "status": "warn",
-                "message": f"HF_HOME is not set. Mounted volume detected at {mounted_volumes[0]} but HuggingFace will cache to default local path.",
-                "fix": f"export HF_HOME={mounted_volumes[0]}/.cache/huggingface"
-            })
-        else:
-            results.append({
-                "status": "warn",
-                "message": "HF_HOME is not set. HuggingFace will use default local cache.",
-                "fix": "Set HF_HOME to a persistent volume path before training"
-            })
-    elif hf_home.startswith("/root") or hf_home.startswith("/tmp"):
-        results.append({
-            "status": "warn",
-            "message": f"HF_HOME appears to point to ephemeral storage: {hf_home}",
-            "fix": f"export HF_HOME=/workspace/.cache/huggingface"
-        })
-    elif mounted_volumes and not any(hf_home.startswith(v) for v in mounted_volumes):
-        results.append({
-            "status": "warn",
-            "message": f"HF_HOME ({hf_home}) does not appear to be on a mounted volume.",
-            "fix": f"export HF_HOME={mounted_volumes[0]}/.cache/huggingface"
-        })
-    else:
-        results.append({
-            "status": "pass",
-            "message": f"HF_HOME is set to {hf_home}"
-        })
-
-    # Report mounted volumes found
-    if mounted_volumes:
-        results.append({
-            "status": "pass",
-            "message": f"Persistent volume(s) detected: {', '.join(mounted_volumes)}"
-        })
-    else:
-        results.append({
-            "status": "warn",
-            "message": "No mounted persistent volumes detected at /workspace, /runpod-volume, or /vast",
-            "fix": "Attach a network volume before training to persist checkpoints and cache"
-        })
-
-    return results

computefence-0.1.2/computefence.egg-info/PKG-INFO

@@ -1,49 +0,0 @@
-Metadata-Version: 2.4
-Name: computefence
-Version: 0.1.2
-Summary: Pre-flight validation for GPU training runs on rented infrastructure
-License-Expression: MIT
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: rich>=13.0.0
-Requires-Dist: pandas>=1.5.0
-Requires-Dist: typer>=0.9.0
-Requires-Dist: requests>=2.28.0
-Dynamic: license-file
-
-# ComputeFence
-
-Pre-flight validation for GPU training runs on rented infrastructure.
-Built specifically for RunPod, Vast.ai, Lambda, and similar providers.
-
-## Install
-
-pip install computefence
-
-## Usage
-
-computefence doctor
-computefence doctor --dataset train.csv
-
-## What it checks
-
-- CUDA and GPU availability
-- HuggingFace cache volume path (catches the RunPod /root vs /workspace conflict)
-- Accelerate GPU count vs config
-- Dataset duplicates and missing values
-
-## What it does not yet check
-
-- Training script correctness
-- Model architecture compatibility
-- Learning rate or hyperparameter safety
-- Runtime monitoring during the job
-
-## Why this exists
-
-I burned ~£1,000 on GPU training runs that failed silently. CUDA fell back to 
-CPU with no error. Class weights caused loss collapse. My dataset had 28,432 
-duplicate rows and 312 conflicting labels I only found during the rebuild.
-
-Nothing existed that caught these before the job started. So I built it.