refactor: clean up backend utilities and background job handler

- Simplify background.py exception handling (merge two except blocks)
- Remove unused imports and dead code in models.py, isr/utils.py
- Use get_pil_rgb() in frame_store adapter instead of manual BGR conversion
- Remove redundant dd benchmark variables in hardware_info.py
- Remove unused decode timing vars in profiler.py

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

jobs/background.py

@@ -17,8 +17,6 @@ async def process_video_async(job_id: str) -> None:
 
     detection_path = None
     depth_path = None
-    depth_error = None
-    partial_success = False
     isr_task = None
 
     # Create stream for live view
@@ -47,9 +45,7 @@ async def process_video_async(job_id: str) -> None:
                 _ttfs_t0=job.ttfs_t0,
             )
         else:
-            detections_list = None
-            # Unified inference pipeline (handles depth internally if enabled)
-            result_pkg = await asyncio.to_thread(
+            detection_path, _ = await asyncio.to_thread(
                 run_inference,
                 job.input_video_path,
                 job.output_video_path,
@@ -63,20 +59,6 @@ async def process_video_async(job_id: str) -> None:
                 None,  # first_frame_detections
                 job.ttfs_t0,
             )
-            detection_path, detections_list = result_pkg
-
-            # If depth was requested, checking if output path exists for depth
-            # The unified pipeline creates 'output_video_path'.
-            # If depth enabled, it might have written depth there?
-            # Actually run_inference returns (video_path, detections).
-            # If depth was ON, the video at video_path *has* depth overlays.
-            # But the 'Depth Video' (heatmap only) is usually separate.
-            # Our Plan says: "Unified loop... Write Frame to Disk".
-            # If we want separate depth video, we need `run_inference` to handle it.
-            # Or just update 'depth_path' to be the same main video if it's merged?
-            # Let's keep it simple: If depth enabled, the main video IS the depth view (overlay).
-            # Or if we want separate `depth_output_path`, we need `run_inference` to handle it.
-            # Let's assume for now `run_inference` writes the main visualization path.
 
             if job.depth_estimator_name:
                  # In unified mode, the main video contains the depth viz
@@ -98,13 +80,11 @@ async def process_video_async(job_id: str) -> None:
             completed_at=datetime.utcnow(),
             output_video_path=detection_path,
             depth_output_path=depth_path,
-            partial_success=partial_success,
-            depth_error=depth_error,
         )
 
-    except RuntimeError as exc:
-        # Handle cancellation specifically
-        if "cancelled" in str(exc).lower():
+    except Exception as exc:
+        is_cancel = isinstance(exc, RuntimeError) and "cancelled" in str(exc).lower()
+        if is_cancel:
             logging.info("Job %s was cancelled", job_id)
             storage.update(
                 job_id,
@@ -120,13 +100,5 @@ async def process_video_async(job_id: str) -> None:
                 completed_at=datetime.utcnow(),
                 error=str(exc),
             )
-    except Exception as exc:
-        logging.exception("Background processing failed for job %s", job_id)
-        storage.update(
-            job_id,
-            status=JobStatus.FAILED,
-            completed_at=datetime.utcnow(),
-            error=str(exc),
-        )
     finally:
         remove_stream(job_id)

jobs/models.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 
 
 class JobStatus(str, Enum):

models/isr/utils.py

@@ -3,7 +3,6 @@
 import base64
 import json
 import logging
-import os
 
 import cv2
 import numpy as np
@@ -11,11 +10,6 @@ import numpy as np
 logger = logging.getLogger(__name__)
 
 
-def get_api_key(env_var: str) -> str | None:
-    """Load an API key from environment."""
-    return os.environ.get(env_var)
-
-
 def crop_and_encode(frame: np.ndarray, bbox: list, max_dim: int = 256, quality: int = 70) -> str | None:
     """Crop detection from frame and return base64 JPEG string.
 
@@ -83,6 +77,6 @@ def parse_llm_json(raw: str) -> dict | list | None:
     try:
         cleaned = strip_json_fences(raw)
         return json.loads(cleaned)
-    except (json.JSONDecodeError, Exception):
+    except (json.JSONDecodeError, ValueError):
         logger.warning("Failed to parse LLM JSON response")
         return None

utils/frame_store.py

@@ -140,10 +140,9 @@ class SAM2FrameAdapter:
             return self.images[idx]
 
         # TRANSFORM PARITY: Must match SAM2's _load_img_as_tensor exactly.
-        # SAM2 does: PIL Image → .convert("RGB") → .resize((size, size)) → /255 → permute → normalize
+        # SAM2 does: PIL Image -> .convert("RGB") -> .resize((size, size)) -> /255 -> permute -> normalize
         # PIL.resize default = BICUBIC. We must use PIL resize, NOT cv2.resize.
-        bgr = self._store.get_bgr(idx)
-        pil_img = Image.fromarray(cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB))
+        pil_img = self._store.get_pil_rgb(idx)
         pil_resized = pil_img.resize(
             (self._image_size, self._image_size)
         )  # BICUBIC default

utils/hardware_info.py

@@ -228,8 +228,6 @@ def get_gpu_info() -> List[GPUInfo]:
         nv = _nvidia_smi_query("driver_version")
         if nv:
             driver_version = nv.get("driver_version")
-        # nvidia-smi reports the max supported CUDA runtime
-        nv2 = _run_cmd(["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"])
         smi_out = _run_cmd(["nvidia-smi"])
         if smi_out:
             m = re.search(r"CUDA Version:\s+([\d.]+)", smi_out)
@@ -338,20 +336,14 @@ def get_storage_info() -> StorageInfo:
                         info.storage_type = "HDD" if parts[1] == "1" else "SSD"
                         break
 
-            # Quick sequential read test with dd (1GB)
-            dd_out = _run_cmd(
-                ["dd", "if=/dev/zero", "of=/dev/null", "bs=1M", "count=256"],
-                timeout=15,
-            )
-            # dd prints throughput to stderr, but _run_cmd only captures stdout
-            # Try a different approach
+            # Estimate sequential read speed (memory throughput proxy — real disk
+            # benchmarks require block device access unavailable in containers)
             try:
                 result = subprocess.run(
                     ["dd", "if=/dev/zero", "of=/dev/null", "bs=1M", "count=256"],
                     capture_output=True, text=True, timeout=15,
                 )
-                stderr = result.stderr
-                m = re.search(r"([\d.]+)\s*(GB|MB)/s", stderr)
+                m = re.search(r"([\d.]+)\s*(GB|MB)/s", result.stderr)
                 if m:
                     speed = float(m.group(1))
                     if m.group(2) == "GB":

utils/profiler.py

@@ -250,12 +250,6 @@ def run_profiled_detection(
         if frame_idx >= max_frames:
             break
 
-        # Decode timing
-        t_decode_start = time.perf_counter()
-        # frame is already decoded by VideoReader, so decode = iteration time
-        # We measure it before predict for consistency
-        decode_ms = 0.0  # Measured below
-
         if frame_idx < warmup_frames:
             # Warmup: run prediction but don't record
             if is_decomposable:
@@ -265,9 +259,6 @@ def run_profiled_detection(
             frame_idx += 1
             continue
 
-        # Time the decode (approximated as read time for next frame)
-        t_before = time.perf_counter()
-
         # Profile prediction
         if is_decomposable:
             timing = _profile_decomposed(detector, frame, queries)