from torch.utils.data import Dataset
import torch
from vigilcv.integrations.torch import FastTensorSentinel

class ResilientVisionDataset(Dataset):
    def __init__(self, records):
        self.records = records
        self.sentinel = FastTensorSentinel(strict_mode=False)

    def __getitem__(self, index: int):
        tensor = self._load_tensor(self.records[index])
        
        is_valid, diag = self.sentinel.validate_tensor(tensor)
        if not is_valid:
            # Mask corrupted sample with running batch median to protect gradient stability
            return torch.zeros_like(tensor), -1
            
        return tensor, 1

import cv2
from vigilcv import VisionSentinel

sentinel = VisionSentinel()
cap = cv2.VideoCapture("rtsp://camera_ip:554/stream")

while True:
    ret, frame = cap.read()
    if not ret:
        break
        
    metrics = sentinel.audit(frame)
    if metrics.is_degraded:
        # Trigger alarm or skip frame
        cv2.putText(frame, "CORRUPTED", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
        
    cv2.imshow("Stream", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

VisionSentinel(
    blur_threshold: float = 100.0,
    min_entropy: float = 3.0,
    max_underexposure_ratio: float = 0.20,
    max_overexposure_ratio: float = 0.20,
    raise_on_fail: bool = True,
)

metrics = sentinel.guard("path/to/image.jpg")
metrics = sentinel.guard(Path("image.png"))
metrics = sentinel.guard(io.BytesIO(image_bytes))  # FastAPI UploadFile

for frame, metrics in sentinel.audit_stream(cap):
    if metrics and metrics.passed:
        process(frame)

BatchAuditor(
    directory: str | Path,
    workers: int = 4,
    sentinel: VisionSentinel | None = None,
    glob_pattern: str = "**/*.{jpg,jpeg,png,webp}",
)

auditor = BatchAuditor("dataset/train/", workers=8)
summary = auditor.run()

@dataclass(frozen=True)
class QualityMetrics:
    path: Path | None           # Source file path (None for BytesIO)
    blur_score: float           # Laplacian variance
    shannon_entropy: float      # Shannon entropy (bits)
    underexposure_ratio: float  # Fraction of dark-clipped pixels
    overexposure_ratio: float   # Fraction of saturated pixels
    width: int                  # Image width in pixels
    height: int                 # Image height in pixels
    passed: bool                # True if all gates passed
    warnings: list[str]         # Human-readable failure reasons
    latency_ms: float           # Wall-clock audit time in milliseconds

@dataclass(frozen=True)
class AuditSummary:
    total_images: int
    valid_images: int
    corrupted_count: int
    blurred_count: int
    underexposed_count: int
    overexposed_count: int
    throughput_fps: float
    total_duration_s: float
    drift_report: DriftReport | None  # Only if baseline provided
    per_image_metrics: list[QualityMetrics]

@dataclass(frozen=True)
class DriftReport:
    is_drifted: bool
    wasserstein_distance: float
    mmd_score: float
    top_drift_features: list[str]
    reference_n: int
    query_n: int
    threshold: float

from vigilcv.exceptions import (
    VigilCVError,              # Base exception
    CorruptImageError,         # Unreadable / truncated file
    QualityThresholdExceeded,  # Quality gate failure
    DriftDetectedError,        # Distribution drift exceeds threshold
)

try:
    sentinel.guard("image.jpg")
except QualityThresholdExceeded as e:
    print(e.metrics.blur_score)  # Access the actual scores
    print(e.metrics.warnings)

from vigilcv.core.drift import DriftEngine

engine = DriftEngine()
engine.fit(reference_directory="dataset/train/")
engine.save("baseline.pkl")

report = engine.detect(query_directory="dataset/new_batch/")

if report.is_drifted:
    print(f"DRIFT DETECTED: {report.wasserstein_distance:.4f} W1")

# Inspect a single image
vigilcv inspect photo.jpg --blur-threshold 150

# Audit a massive directory in parallel
vigilcv audit dataset/train/ --workers 16 --report quality_report.html

# Detect distribution drift against baseline
vigilcv drift dataset/new/ --baseline baselines/prod_v1.pkl --threshold 0.20