computefence 0.2.4__tar.gz → 0.2.6__tar.gz

computefence-0.2.6/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: computefence
+Version: 0.2.6
+Summary: Don't lose another RunPod checkpoint to ephemeral disk before your job bills.
+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
+
+**Don't lose another RunPod checkpoint to ephemeral disk before your job bills.**
+
+One command before your training job starts. Catches the configuration mistakes that cost you hours of GPU compute and lost weights before billing begins.
+
+Built for RunPod, Vast.ai, Lambda Labs, CoreWeave, Paperspace, and any bare metal GPU provider.
+
+---
+
+## Install
+
+```bash
+pip install computefence
+```
+
+No install required with UV:
+
+```bash
+uvx computefence doctor
+```
+
+---
+
+## Usage
+
+```bash
+computefence doctor
+```
+
+With dataset validation:
+
+```bash
+computefence doctor --dataset train.csv --input-column text --label-column label
+```
+
+With checkpoint directory validation:
+
+```bash
+computefence doctor --output-dir ./checkpoints
+```
+
+Add to your pod startup script so it runs automatically before every job:
+
+```bash
+pip install computefence && computefence doctor && python train.py
+```
+
+---
+
+## Example Output
+
+```
+ComputeFence v0.2.5 — 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 cache to ephemeral local disk.
+    Fix: export HF_HOME=/workspace/.cache/huggingface
+
+  ⚠ Root disk (/) — 14.3 GB free of 460.4 GB (below 20 GB threshold)
+    Fix: Free up disk space or move checkpoints to a larger volume
+         df -h to check usage
+
+Dataset
+  ✓ No dataset path provided — skipping dataset checks
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 warning(s) found. Review before launching.
+
+Anonymous run stats are collected to improve ComputeFence.
+To opt out: touch ~/.computefence_no_telemetry
+```
+
+---
+
+## What It Checks
+
+**CUDA and GPU visibility**
+Confirms PyTorch can see the GPU. Catches silent CPU fallback before it runs for eight hours at 24 seconds per iteration instead of 0.4.
+
+**HuggingFace cache path**
+Confirms model weights are writing to persistent storage. If HF_HOME points to ephemeral disk your weights disappear when the pod stops.
+
+**Accelerate GPU count**
+Confirms your distributed training config matches the GPUs actually on the instance. A mismatch leaves GPUs idle for the entire run with no error message.
+
+**Disk space headroom**
+Checks free space on workspace volumes and root disk. Warns below 20 GB. Blocks below 5 GB. Catches the failure where checkpoints stop saving at 90 percent completion because the disk filled.
+
+**Checkpoint output directory**
+Confirms your training script's output path is on persistent storage not ephemeral disk. HF_HOME and your checkpoint directory are separate paths — fixing one does not fix the other.
+
+**Dataset integrity**
+Optional scan for duplicates, missing values, and conflicting labels. Pass --dataset to enable.
+
+---
+
+## What It Does Not Check
+
+- Training script correctness
+- Model architecture compatibility
+- Learning rate or hyperparameter safety
+- Runtime behaviour during the job
+- GPU utilisation or dataloader throughput during training
+
+ComputeFence addresses the job configuration layer before launch. It does not monitor the run.
+
+---
+
+## Why This Exists
+
+I burned approximately £1,000 on GPU training runs that failed silently.
+
+CUDA fell back to CPU with no error message. 24 seconds per iteration instead of 0.4. Class weights caused loss to collapse to 0.693 immediately. My dataset had 28,432 duplicate rows and 312 conflicting labels I only found after the run finished.
+
+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.
+
+**Shahzeb Ali**, a computer vision engineer running client training jobs on RunPod, confirmed the storage warning matches real pod behaviour. He would not have caught the HF_HOME issue without the tool.
+
+**An independent Vast.ai operator** ran computefence doctor six times overnight before a real training job without being prompted or paid to do so.
+
+Thirteen independent ML engineers confirmed this problem across RunPod, Vast.ai, and AWS. Nine had lost checkpoints to ephemeral disk. Five confirmed Docker does not solve job-specific configuration mistakes.
+
+---
+
+## The Problem It Solves
+
+A healthy GPU does not mean you are running the right job.
+
+Docker makes environments reproducible. It does not check whether your HuggingFace cache is writing to ephemeral storage that disappears on pod stop, whether your Accelerate config matches the GPUs on the instance, or whether your checkpoint output directory is on persistent storage.
+
+ComputeFence addresses the job configuration layer — not the environment layer.
+
+HF_HOME and your checkpoint output directory are separate paths. Fixing one does not fix the other. Both disappear on pod restart if they point to ephemeral disk.
+
+---
+
+## Founding Design Partner Pilot
+
+Running high-cost GPU training jobs on RunPod or Vast.ai?
+
+Three founding design partner spots at $99 for three months:
+
+- Personal audit of your launch templates and persistent storage configuration
+- ComputeFence installed into your pod startup scripts — pre-flight runs automatically before every job
+- Slack or Discord webhook alert when a check fails or blocks a launch
+- Monthly 30-minute call where you shape what gets built next
+- Money back if it does not catch one actionable issue in three months
+
+Email francisco@booth.ws to apply.
+
+---
+
+## Links
+
+- GitHub: https://github.com/Francisco-Booth/ComputeFence
+- PyPI: https://pypi.org/project/computefence
+```

computefence-0.2.6/README.md

@@ -0,0 +1,171 @@
+# ComputeFence
+
+**Don't lose another RunPod checkpoint to ephemeral disk before your job bills.**
+
+One command before your training job starts. Catches the configuration mistakes that cost you hours of GPU compute and lost weights before billing begins.
+
+Built for RunPod, Vast.ai, Lambda Labs, CoreWeave, Paperspace, and any bare metal GPU provider.
+
+---
+
+## Install
+
+```bash
+pip install computefence
+```
+
+No install required with UV:
+
+```bash
+uvx computefence doctor
+```
+
+---
+
+## Usage
+
+```bash
+computefence doctor
+```
+
+With dataset validation:
+
+```bash
+computefence doctor --dataset train.csv --input-column text --label-column label
+```
+
+With checkpoint directory validation:
+
+```bash
+computefence doctor --output-dir ./checkpoints
+```
+
+Add to your pod startup script so it runs automatically before every job:
+
+```bash
+pip install computefence && computefence doctor && python train.py
+```
+
+---
+
+## Example Output
+
+```
+ComputeFence v0.2.5 — 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 cache to ephemeral local disk.
+    Fix: export HF_HOME=/workspace/.cache/huggingface
+
+  ⚠ Root disk (/) — 14.3 GB free of 460.4 GB (below 20 GB threshold)
+    Fix: Free up disk space or move checkpoints to a larger volume
+         df -h to check usage
+
+Dataset
+  ✓ No dataset path provided — skipping dataset checks
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 warning(s) found. Review before launching.
+
+Anonymous run stats are collected to improve ComputeFence.
+To opt out: touch ~/.computefence_no_telemetry
+```
+
+---
+
+## What It Checks
+
+**CUDA and GPU visibility**
+Confirms PyTorch can see the GPU. Catches silent CPU fallback before it runs for eight hours at 24 seconds per iteration instead of 0.4.
+
+**HuggingFace cache path**
+Confirms model weights are writing to persistent storage. If HF_HOME points to ephemeral disk your weights disappear when the pod stops.
+
+**Accelerate GPU count**
+Confirms your distributed training config matches the GPUs actually on the instance. A mismatch leaves GPUs idle for the entire run with no error message.
+
+**Disk space headroom**
+Checks free space on workspace volumes and root disk. Warns below 20 GB. Blocks below 5 GB. Catches the failure where checkpoints stop saving at 90 percent completion because the disk filled.
+
+**Checkpoint output directory**
+Confirms your training script's output path is on persistent storage not ephemeral disk. HF_HOME and your checkpoint directory are separate paths — fixing one does not fix the other.
+
+**Dataset integrity**
+Optional scan for duplicates, missing values, and conflicting labels. Pass --dataset to enable.
+
+---
+
+## What It Does Not Check
+
+- Training script correctness
+- Model architecture compatibility
+- Learning rate or hyperparameter safety
+- Runtime behaviour during the job
+- GPU utilisation or dataloader throughput during training
+
+ComputeFence addresses the job configuration layer before launch. It does not monitor the run.
+
+---
+
+## Why This Exists
+
+I burned approximately £1,000 on GPU training runs that failed silently.
+
+CUDA fell back to CPU with no error message. 24 seconds per iteration instead of 0.4. Class weights caused loss to collapse to 0.693 immediately. My dataset had 28,432 duplicate rows and 312 conflicting labels I only found after the run finished.
+
+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.
+
+**Shahzeb Ali**, a computer vision engineer running client training jobs on RunPod, confirmed the storage warning matches real pod behaviour. He would not have caught the HF_HOME issue without the tool.
+
+**An independent Vast.ai operator** ran computefence doctor six times overnight before a real training job without being prompted or paid to do so.
+
+Thirteen independent ML engineers confirmed this problem across RunPod, Vast.ai, and AWS. Nine had lost checkpoints to ephemeral disk. Five confirmed Docker does not solve job-specific configuration mistakes.
+
+---
+
+## The Problem It Solves
+
+A healthy GPU does not mean you are running the right job.
+
+Docker makes environments reproducible. It does not check whether your HuggingFace cache is writing to ephemeral storage that disappears on pod stop, whether your Accelerate config matches the GPUs on the instance, or whether your checkpoint output directory is on persistent storage.
+
+ComputeFence addresses the job configuration layer — not the environment layer.
+
+HF_HOME and your checkpoint output directory are separate paths. Fixing one does not fix the other. Both disappear on pod restart if they point to ephemeral disk.
+
+---
+
+## Founding Design Partner Pilot
+
+Running high-cost GPU training jobs on RunPod or Vast.ai?
+
+Three founding design partner spots at $99 for three months:
+
+- Personal audit of your launch templates and persistent storage configuration
+- ComputeFence installed into your pod startup scripts — pre-flight runs automatically before every job
+- Slack or Discord webhook alert when a check fails or blocks a launch
+- Monthly 30-minute call where you shape what gets built next
+- Money back if it does not catch one actionable issue in three months
+
+Email francisco@booth.ws to apply.
+
+---
+
+## Links
+
+- GitHub: https://github.com/Francisco-Booth/ComputeFence
+- PyPI: https://pypi.org/project/computefence
+```

computefence-0.2.6/computefence/__init__.py

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

{computefence-0.2.4 → computefence-0.2.6}/computefence/checks/storage.py

@@ -134,3 +134,51 @@ def check_disk_headroom():
             })
 
     return results
+
+
+# Paths that are wiped when a rented instance stops.
+EPHEMERAL_PREFIXES = ["/root", "/tmp"]
+# Paths that survive an instance restart.
+PERSISTENT_PREFIXES = ["/workspace", "/runpod-volume", "/vast", "/home"]
+OUTPUT_DIR_FIX = "Move your output_dir to /workspace/checkpoints or your mounted volume"
+
+
+def _is_under(path, prefix):
+    """True when path sits at or below prefix.
+
+    Compares path components rather than string prefixes so /workspace-old is
+    not mistaken for a child of /workspace. Avoids Path.is_relative_to, which
+    needs Python 3.9 while this package supports 3.8.
+    """
+    path_parts = Path(path).parts
+    prefix_parts = Path(prefix).parts
+    return path_parts[: len(prefix_parts)] == prefix_parts
+
+
+def check_output_dir(output_dir=None):
+    """Flag a checkpoint directory that will not survive the instance stopping.
+
+    Uses abspath rather than resolve() so a path is judged as written: on macOS
+    /tmp is a symlink to /private/tmp, and resolving it first would hide the
+    very ephemeral prefix this check exists to catch.
+    """
+    if output_dir is None:
+        return []
+
+    path = Path(os.path.abspath(os.path.expanduser(str(output_dir))))
+
+    is_ephemeral = any(_is_under(path, prefix) for prefix in EPHEMERAL_PREFIXES) or not any(
+        _is_under(path, prefix) for prefix in PERSISTENT_PREFIXES
+    )
+
+    if is_ephemeral:
+        return [{
+            "status": "fail",
+            "message": f"Output directory {path} is on ephemeral storage and will be lost when the instance stops",
+            "fix": OUTPUT_DIR_FIX
+        }]
+
+    return [{
+        "status": "pass",
+        "message": f"Output directory {path} is on persistent storage"
+    }]

{computefence-0.2.4 → computefence-0.2.6}/computefence/cli.py

@@ -2,7 +2,7 @@ import sys
 from rich.console import Console
 from computefence import __version__
 from computefence.checks.environment import check_environment
-from computefence.checks.storage import check_disk_headroom, check_storage
+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
 
@@ -27,6 +27,7 @@ def doctor():
     dataset = None
     input_column = None
     label_column = None
+    output_dir = None
     args = sys.argv[1:]
     i = 0
     while i < len(args):
@@ -39,6 +40,9 @@ def doctor():
         elif args[i] == "--label-column" and i + 1 < len(args):
             label_column = args[i + 1]
             i += 2
+        elif args[i] == "--output-dir" and i + 1 < len(args):
+            output_dir = args[i + 1]
+            i += 2
         else:
             i += 1
 
@@ -47,7 +51,7 @@ def doctor():
     console.print("━" * 50)
 
     env_results = check_environment()
-    storage_results = check_storage() + check_disk_headroom()
+    storage_results = check_storage() + check_disk_headroom() + check_output_dir(output_dir)
     dataset_results = check_dataset(
         dataset_path=dataset,
         input_column=input_column,

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

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: computefence
+Version: 0.2.6
+Summary: Don't lose another RunPod checkpoint to ephemeral disk before your job bills.
+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
+
+**Don't lose another RunPod checkpoint to ephemeral disk before your job bills.**
+
+One command before your training job starts. Catches the configuration mistakes that cost you hours of GPU compute and lost weights before billing begins.
+
+Built for RunPod, Vast.ai, Lambda Labs, CoreWeave, Paperspace, and any bare metal GPU provider.
+
+---
+
+## Install
+
+```bash
+pip install computefence
+```
+
+No install required with UV:
+
+```bash
+uvx computefence doctor
+```
+
+---
+
+## Usage
+
+```bash
+computefence doctor
+```
+
+With dataset validation:
+
+```bash
+computefence doctor --dataset train.csv --input-column text --label-column label
+```
+
+With checkpoint directory validation:
+
+```bash
+computefence doctor --output-dir ./checkpoints
+```
+
+Add to your pod startup script so it runs automatically before every job:
+
+```bash
+pip install computefence && computefence doctor && python train.py
+```
+
+---
+
+## Example Output
+
+```
+ComputeFence v0.2.5 — 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 cache to ephemeral local disk.
+    Fix: export HF_HOME=/workspace/.cache/huggingface
+
+  ⚠ Root disk (/) — 14.3 GB free of 460.4 GB (below 20 GB threshold)
+    Fix: Free up disk space or move checkpoints to a larger volume
+         df -h to check usage
+
+Dataset
+  ✓ No dataset path provided — skipping dataset checks
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2 warning(s) found. Review before launching.
+
+Anonymous run stats are collected to improve ComputeFence.
+To opt out: touch ~/.computefence_no_telemetry
+```
+
+---
+
+## What It Checks
+
+**CUDA and GPU visibility**
+Confirms PyTorch can see the GPU. Catches silent CPU fallback before it runs for eight hours at 24 seconds per iteration instead of 0.4.
+
+**HuggingFace cache path**
+Confirms model weights are writing to persistent storage. If HF_HOME points to ephemeral disk your weights disappear when the pod stops.
+
+**Accelerate GPU count**
+Confirms your distributed training config matches the GPUs actually on the instance. A mismatch leaves GPUs idle for the entire run with no error message.
+
+**Disk space headroom**
+Checks free space on workspace volumes and root disk. Warns below 20 GB. Blocks below 5 GB. Catches the failure where checkpoints stop saving at 90 percent completion because the disk filled.
+
+**Checkpoint output directory**
+Confirms your training script's output path is on persistent storage not ephemeral disk. HF_HOME and your checkpoint directory are separate paths — fixing one does not fix the other.
+
+**Dataset integrity**
+Optional scan for duplicates, missing values, and conflicting labels. Pass --dataset to enable.
+
+---
+
+## What It Does Not Check
+
+- Training script correctness
+- Model architecture compatibility
+- Learning rate or hyperparameter safety
+- Runtime behaviour during the job
+- GPU utilisation or dataloader throughput during training
+
+ComputeFence addresses the job configuration layer before launch. It does not monitor the run.
+
+---
+
+## Why This Exists
+
+I burned approximately £1,000 on GPU training runs that failed silently.
+
+CUDA fell back to CPU with no error message. 24 seconds per iteration instead of 0.4. Class weights caused loss to collapse to 0.693 immediately. My dataset had 28,432 duplicate rows and 312 conflicting labels I only found after the run finished.
+
+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.
+
+**Shahzeb Ali**, a computer vision engineer running client training jobs on RunPod, confirmed the storage warning matches real pod behaviour. He would not have caught the HF_HOME issue without the tool.
+
+**An independent Vast.ai operator** ran computefence doctor six times overnight before a real training job without being prompted or paid to do so.
+
+Thirteen independent ML engineers confirmed this problem across RunPod, Vast.ai, and AWS. Nine had lost checkpoints to ephemeral disk. Five confirmed Docker does not solve job-specific configuration mistakes.
+
+---
+
+## The Problem It Solves
+
+A healthy GPU does not mean you are running the right job.
+
+Docker makes environments reproducible. It does not check whether your HuggingFace cache is writing to ephemeral storage that disappears on pod stop, whether your Accelerate config matches the GPUs on the instance, or whether your checkpoint output directory is on persistent storage.
+
+ComputeFence addresses the job configuration layer — not the environment layer.
+
+HF_HOME and your checkpoint output directory are separate paths. Fixing one does not fix the other. Both disappear on pod restart if they point to ephemeral disk.
+
+---
+
+## Founding Design Partner Pilot
+
+Running high-cost GPU training jobs on RunPod or Vast.ai?
+
+Three founding design partner spots at $99 for three months:
+
+- Personal audit of your launch templates and persistent storage configuration
+- ComputeFence installed into your pod startup scripts — pre-flight runs automatically before every job
+- Slack or Discord webhook alert when a check fails or blocks a launch
+- Monthly 30-minute call where you shape what gets built next
+- Money back if it does not catch one actionable issue in three months
+
+Email francisco@booth.ws to apply.
+
+---
+
+## Links
+
+- GitHub: https://github.com/Francisco-Booth/ComputeFence
+- PyPI: https://pypi.org/project/computefence
+```

{computefence-0.2.4 → computefence-0.2.6}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "computefence"
 dynamic = ["version"]
-description = "Pre-flight validation for GPU training runs on rented infrastructure"
+description = "Don't lose another RunPod checkpoint to ephemeral disk before your job bills."
 readme = "README.md"
 requires-python = ">=3.8"
 license = "MIT"

computefence-0.2.4/PKG-INFO

@@ -1,110 +0,0 @@
-Metadata-Version: 2.4
-Name: computefence
-Version: 0.2.4
-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 for RunPod, Vast.ai, Lambda Labs, and similar bare metal providers.
-
-## Install
-
-```bash
-pip install computefence
-```
-
-Or with UV:
-
-```bash
-uvx computefence doctor
-```
-
-## Usage
-
-```bash
-computefence doctor
-```
-
-With a dataset:
-
-```bash
-computefence doctor --dataset train.csv --input-column text --label-column label
-```
-
-## Example output
-
-ComputeFence v0.2.0 — 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: export HF_HOME=/workspace/.cache/huggingface
-⚠ Root disk (/) — 14.3 GB free of 460.4 GB (below 20 GB)
-Fix: Free up disk space or attach a larger volume before launching
-
-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
-- **Disk space headroom** — checks free space on workspace volumes and root disk. Warns below 20 GB, blocks below 5 GB
-- **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
-- Dataloader bottleneck causing low GPU utilisation
-
-## Why this exists
-
-I burned approximately £1,000 on GPU training runs that failed silently. CUDA fell back to CPU with no error. 24 seconds per iteration instead of 0.4. 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.
-
-Shahzeb Ali, a computer vision engineer running client training jobs on RunPod, confirmed the storage warning matches real pod behaviour and would not have caught the HF_HOME issue explicitly without the tool.
-
-## The problem it solves
-
-A healthy GPU does not mean you are training the right job.
-
-Docker makes environments reproducible. It does not check whether your HuggingFace cache is writing to ephemeral storage, whether your Accelerate config matches the GPUs actually on the instance, or whether your disk has enough headroom for checkpoints. ComputeFence addresses the job layer not the environment layer.
-
-Five independent operators confirmed this independently. Docker does not solve job-specific configuration mistakes.
-
-## GitHub
-
-github.com/Francisco-Booth/ComputeFence
-
-## PyPI
-
-pypi.org/project/computefence

computefence-0.2.4/README.md

@@ -1,96 +0,0 @@
-# ComputeFence
-
-Pre-flight safety gate for ML training jobs on rented GPU compute. Built for RunPod, Vast.ai, Lambda Labs, and similar bare metal providers.
-
-## Install
-
-```bash
-pip install computefence
-```
-
-Or with UV:
-
-```bash
-uvx computefence doctor
-```
-
-## Usage
-
-```bash
-computefence doctor
-```
-
-With a dataset:
-
-```bash
-computefence doctor --dataset train.csv --input-column text --label-column label
-```
-
-## Example output
-
-ComputeFence v0.2.0 — 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: export HF_HOME=/workspace/.cache/huggingface
-⚠ Root disk (/) — 14.3 GB free of 460.4 GB (below 20 GB)
-Fix: Free up disk space or attach a larger volume before launching
-
-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
-- **Disk space headroom** — checks free space on workspace volumes and root disk. Warns below 20 GB, blocks below 5 GB
-- **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
-- Dataloader bottleneck causing low GPU utilisation
-
-## Why this exists
-
-I burned approximately £1,000 on GPU training runs that failed silently. CUDA fell back to CPU with no error. 24 seconds per iteration instead of 0.4. 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.
-
-Shahzeb Ali, a computer vision engineer running client training jobs on RunPod, confirmed the storage warning matches real pod behaviour and would not have caught the HF_HOME issue explicitly without the tool.
-
-## The problem it solves
-
-A healthy GPU does not mean you are training the right job.
-
-Docker makes environments reproducible. It does not check whether your HuggingFace cache is writing to ephemeral storage, whether your Accelerate config matches the GPUs actually on the instance, or whether your disk has enough headroom for checkpoints. ComputeFence addresses the job layer not the environment layer.
-
-Five independent operators confirmed this independently. Docker does not solve job-specific configuration mistakes.
-
-## GitHub
-
-github.com/Francisco-Booth/ComputeFence
-
-## PyPI
-
-pypi.org/project/computefence

computefence-0.2.4/computefence/__init__.py

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

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

@@ -1,110 +0,0 @@
-Metadata-Version: 2.4
-Name: computefence
-Version: 0.2.4
-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 for RunPod, Vast.ai, Lambda Labs, and similar bare metal providers.
-
-## Install
-
-```bash
-pip install computefence
-```
-
-Or with UV:
-
-```bash
-uvx computefence doctor
-```
-
-## Usage
-
-```bash
-computefence doctor
-```
-
-With a dataset:
-
-```bash
-computefence doctor --dataset train.csv --input-column text --label-column label
-```
-
-## Example output
-
-ComputeFence v0.2.0 — 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: export HF_HOME=/workspace/.cache/huggingface
-⚠ Root disk (/) — 14.3 GB free of 460.4 GB (below 20 GB)
-Fix: Free up disk space or attach a larger volume before launching
-
-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
-- **Disk space headroom** — checks free space on workspace volumes and root disk. Warns below 20 GB, blocks below 5 GB
-- **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
-- Dataloader bottleneck causing low GPU utilisation
-
-## Why this exists
-
-I burned approximately £1,000 on GPU training runs that failed silently. CUDA fell back to CPU with no error. 24 seconds per iteration instead of 0.4. 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.
-
-Shahzeb Ali, a computer vision engineer running client training jobs on RunPod, confirmed the storage warning matches real pod behaviour and would not have caught the HF_HOME issue explicitly without the tool.
-
-## The problem it solves
-
-A healthy GPU does not mean you are training the right job.
-
-Docker makes environments reproducible. It does not check whether your HuggingFace cache is writing to ephemeral storage, whether your Accelerate config matches the GPUs actually on the instance, or whether your disk has enough headroom for checkpoints. ComputeFence addresses the job layer not the environment layer.
-
-Five independent operators confirmed this independently. Docker does not solve job-specific configuration mistakes.
-
-## GitHub
-
-github.com/Francisco-Booth/ComputeFence
-
-## PyPI
-
-pypi.org/project/computefence