refactor: 2×2 CVD grid, route protanopia to VLM (#18)

* refactor: 2×2 CVD grid, route protanopia to VLM, rename branch to demo-wip

- Replace 10-variant CVD gallery with fixed 2×2 grid (Normal/Protanopia/Deuteranopia/Tritanopia)
- Send Protanopia-simulated image to VLM endpoint (not original screenshot)
- Add image_to_bytes() helper for CVD→VLM serialization
- Rename branch DemoWeep → demo-wip

* fix: send all 4 CVD perspectives to VLM, fix stale tests

- analyze_all_perspectives() calls MiniCPM endpoint for each CVD variant
(Normal, Protanopia, Deuteranopia, Tritanopia) with type-specific prompts
- _merge_cvd_results() deduplicates findings across perspectives
- Removed URL capture / Playwright code; file-upload only
- Removed MODELS dict; single SUPPORTED_MODEL constant
- Updated TestCVDGallery -> TestCVDGrid, TestMODELS -> TestSupportedModel

* add modal deploy script and test, remove duplicate test, update dependencies

.pr-body.md

@@ -0,0 +1,11 @@
+## Summary
+
+- **Multi-perspective VLM analysis**: The VLM endpoint now receives **all four CVD perspectives** (Normal, Protanopia, Deuteranopia, Tritanopia), each with a type-specific prompt so the model understands which color deficiency it's simulating. Findings are deduplicated into a single aggregated report — simulating a full panel of colorblind testers.
+
+- **2×2 CVD grid**: Fixed layout showing Normal (top-left), Protanopia (top-right), Deuteranopia (bottom-left), Tritanopia (bottom-right)
+
+- **Only file upload, no URL capture**: Removed all Playwright/URL capture code to comply with HF Spaces constraints. Only user-uploaded screenshots accepted.
+
+- **Single model, no dropdown clutter**: Model registry simplified to just `minicpm-v-4.6` since that's the only working endpoint. No unsupported model choices in the UI.
+
+- **Stale tests updated**: Renamed `TestCVDGallery` → `TestCVDGrid` with 4-item assertions; replaced `TestMODELS` → `TestSupportedModel`

app.py

@@ -2,56 +2,38 @@
 Color-UX-Access — Gradio application
 =====================================
 Single-file Gradio app for colorblind accessibility testing.
-
-Usage:
-  # HF Spaces (file upload only — no Playwright needed):
-  # app_file: app.py in Space settings → runs automatically
-
-  # Local development (file upload OR URL capture):
-  python app.py                      # file upload mode
+Only accepts user-uploaded screenshots (no URL capture / browser automation).
 
 Architecture:
   Screenshot (file upload)
-         │
-         ▼
-  Stage 1: CVD Simulation (CPU) → 10 variants
-         │
-         ▼
-  Stage 2: VLM Inference (GPU via Modal endpoint) → WCAG 2.1 JSON
-         │
-         ▼
+         |
+         v
+  Stage 1: CVD Simulation (CPU) -> 3-type comparison grid
+         |
+         v
+  Stage 2: VLM Inference (GPU via Modal endpoint) -> WCAG 2.1 JSON
+         |
+         v
   Stage 3: Report (Markdown)
 
 Requirements:
   - Python 3.12
-  - gradio>=6.0, spaces (for HF Space deployment)
-  - torch with CUDA libs
-  - openai, pillow, daltonlens, requests, python-dotenv
-  - huggingface_hub==0.25.2 (HfFolder removed in 0.26)
-  - playwright (optional, for URL capture mode — not needed on Space)
+  - gradio>=6.0, pillow, daltonlens, requests, python-dotenv
 
 Local setup:
   uv sync --python 3.12
-  playwright install chromium   # only for --url mode
+  cp .env.example .env  # set MODAL_INFERENCE_URL
 
 HF Space deploy:
   1. Push to GitHub
   2. Create HF Space (SDK: Gradio, hardware: T4/mega or A10G)
-  3. Add MODAL_URL secret in Space settings (or MODAL_INFERENCE_BASE_URL + MODAL_INFERENCE_API_KEY)
+  3. Add MODAL_INFERENCE_URL secret in Space settings
   4. Link to GitHub repo
-
-Note: HF_TOKEN in Space secrets is for Space management only.
-Inference goes through the Modal endpoint — no HF_TOKEN needed here.
-
-Two VLM modes:
-  A) Legacy  — MODAL_URL (Gradio API endpoint) — falls back automatically
-  B) Provider — MODAL_INFERENCE_BASE_URL + MODAL_INFERENCE_API_KEY (OpenAI-compatible)
 """
 
 import os
 import io
 import json
-import sys
 
 import gradio as gr
 from PIL import Image
@@ -59,9 +41,17 @@ import numpy as np
 from daltonlens import simulate
 import requests
 import base64
-from openai import OpenAI
 
-# ── CVD Simulators ────────────────────────────────────────────────────────────
+from custom_theme import color_ux_access_theme
+
+# -- Load .env if available ---------------------------------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+# -- CVD Simulators -----------------------------------------------------------
 
 simulator = simulate.Simulator_Machado2009()
 severe_simulator = simulate.Simulator_Vienot1999()
@@ -78,28 +68,8 @@ deficiency_config = {
     'tritanomaly':       {'simulator': tritan_simulator, 'severity': 0.4, 'deficiency': simulate.Deficiency.TRITAN},
 }
 
-# ── Swappable VLM Model Registry ──────────────────────────────────────────────
-# One-line swap for different sponsor prize eligibility:
-#   - aya-vision-32b  → CohereLabs/aya-vision-32b (default, Cohere prize)
-#   - minicpm-v-4.6   → openbmb/mini-cpm-v-4_6 (OpenBMB $5K prize)
-#   - nemotron-15b    → nvidia/Nemotron-4-15B-base (NVIDIA prize, if required)
-MODELS = {
-    "aya-vision-32b": {
-        "provider": "cohere",
-        "model_id": "CohereLabs/aya-vision-32b",
-        "description": "Default — 32B vision model via HF Router",
-    },
-    "minicpm-v-4.6": {
-        "provider": "openbmb",
-        "model_id": "openbmb/mini-cpm-v-4_6",
-        "description": "OpenBMB prize — MiniCPM-V 4.6 (~4B params, under 32B cap)",
-    },
-    "nemotron-15b": {
-        "provider": "nvidia",
-        "model_id": "nvidia/Nemotron-4-15B-base",
-        "description": "NVIDIA prize — confirm Nemotron requirement with organizers",
-    },
-}
+SUPPORTED_MODEL = "minicpm-v-4.6"
+_MODAL_INFERENCE_URL = os.environ.get('MODAL_INFERENCE_URL')
 
 
 def simulate_cvd(image: Image.Image, sim, deficiency, severity) -> Image.Image:
@@ -118,35 +88,51 @@ def simulate_achromatopsia(image: Image.Image, severity: float) -> Image.Image:
     return gray_rgb
 
 
+def image_to_bytes(img: Image.Image, fmt: str = 'PNG') -> bytes:
+    """Serialize a PIL Image to bytes for VLM transmission."""
+    buf = io.BytesIO()
+    img.save(buf, format=fmt)
+    return buf.getvalue()
+
 def generate_cvd_gallery(original: Image.Image) -> list[tuple[Image.Image, str]]:
-    """Generate all 10 CVD simulation variants for the gallery."""
-    results = []
-    for name, cfg in deficiency_config.items():
-        img = simulate_cvd(
-            original, cfg['simulator'], cfg['deficiency'], cfg['severity']
-        )
-        label = name.replace('_', ' ').title()
-        results.append((img, label))
-    results.append((simulate_achromatopsia(original, 1.0), 'Achromatopsia'))
-    results.append((simulate_achromatopsia(original, 0.5), 'Achromatomaly'))
-    return results
+    """Alias for generate_cvd_grid."""
+    return generate_cvd_grid(original)
+
+def generate_cvd_grid(original: Image.Image) -> list[tuple[Image.Image, str]]:
+    """Generate the 2x2 CVD comparison grid.
+
+    Fixed layout:
+      Top-left:     Normal vision (original design)
+      Top-right:    Protanopia (red-blind)
+      Bottom-left:  Deuteranopia (green-blind)
+      Bottom-right: Tritanopia (blue-blind)
+    """
+    protan = simulate_cvd(original, simulator, simulate.Deficiency.PROTAN, 0.8)
+    deuter = simulate_cvd(original, simulator, simulate.Deficiency.DEUTAN, 0.8)
+    tritan = simulate_cvd(original, tritan_simulator, simulate.Deficiency.TRITAN, 0.8)
+    return [
+        (original, "Normal vision (original design)"),
+        (protan,   "Protanopia (red-blind)"),
+        (deuter,   "Deuteranopia (green-blind)"),
+        (tritan,   "Tritanopia (blue-blind)"),
+    ]
 
 
 def format_wcag_report(vlm_result: dict) -> str:
     """Convert VLM JSON output into a formatted markdown report."""
     if 'error' in vlm_result:
-        return f"⚠️ **Error:** {vlm_result['error']}"
+        return f"Warning: {vlm_result['error']}"
 
     findings = vlm_result.get('findings', [])
     if not findings:
         if vlm_result.get('passes', False):
-            return "✅ Pass — No accessibility issues detected."
-        return "✅ **No accessibility issues detected.**"
+            return "Pass -- No accessibility issues detected."
+        return "No accessibility issues detected."
 
     report = "## WCAG Accessibility Report\n\n"
-    report += f"**Overall:** {'✅ Pass' if vlm_result.get('passes', False) else '❌ Fail'}\n\n"
+    report += f"**Overall:** {'Pass' if vlm_result.get('passes', False) else 'Fail'}\n\n"
 
-    severity_icons = {'critical': '🔴', 'serious': '🟠', 'moderate': '🟡'}
+    severity_icons = {'critical': ':red_circle:', 'serious': ':orange_circle:', 'moderate': ':yellow_circle:'}
     wcag_links = {
         '1.1.1':  'https://www.w3.org/WAI/WCAG21/Understanding/non-text-content',
         '1.4.1':  'https://www.w3.org/WAI/WCAG21/Understanding/use-of-color',
@@ -155,12 +141,15 @@ def format_wcag_report(vlm_result: dict) -> str:
     }
 
     for i, f in enumerate(findings, 1):
-        icon = severity_icons.get(f.get('severity', 'moderate'), '⚪')
+        icon = severity_icons.get(f.get('severity', 'moderate'))
         wcag = f.get('wcag_criterion', 'N/A')
         link = wcag_links.get(wcag, '#')
+        cvd_perspective = f.get('cvd_perspective', '')
         report += f"### {icon} Issue {i}: {f.get('type', 'Unknown')}\n\n"
         report += f"- **WCAG:** [{wcag}]({link})\n"
         report += f"- **Severity:** {f.get('severity', 'N/A').capitalize()}\n"
+        if cvd_perspective:
+            report += f"- **CVD Perspective:** {cvd_perspective}\n"
         report += f"- **Description:** {f.get('description', 'N/A')}\n"
         report += f"- **Location:** {f.get('location', 'N/A')}\n\n"
 
@@ -170,195 +159,146 @@ def format_wcag_report(vlm_result: dict) -> str:
     return report
 
 
-# ── URL Capture (optional — Playwright, local dev only) ───────────────────────
-
-def _get_playwright():
-    """Lazy-import Playwright only when URL mode is requested."""
-    try:
-        from playwright.sync_api import sync_playwright
-        return sync_playwright
-    except ImportError:
-        raise RuntimeError(
-            "Playwright not installed. Run: uv pip install playwright && playwright install chromium"
-        )
-
-
-def _capture_url(url: str) -> bytes:
-    """Capture a screenshot of a URL using Playwright (headless Chromium)."""
-    pw = _get_playwright()
-    with pw() as p:
-        browser = p.chromium.launch(
-            headless=True,
-            args=['--no-sandbox', '--disable-setuid-sandbox'],
-        )
-        page = browser.new_page(viewport={'width': 1280, 'height': 720})
-        page.goto(url, wait_until='networkidle', timeout=60000)
-        page.wait_for_timeout(3000)
-        screenshot = page.screenshot(full_page=True, timeout=60000)
-        browser.close()
-    return screenshot
-
-
-# ── Modal Endpoint Helper ──────────────────────────────────────────────────────
-# Inference runs via the deployed Modal app, not HF Router directly.
-# The Modal app (color_ux_access/modal_app.py) handles GPU/VLM internally.
-#
-# Two modes (selectable by env var):
-#   Legacy mode (default):     MODAL_URL
-#   Provider mode (OpenAI):    MODAL_INFERENCE_BASE_URL + MODAL_INFERENCE_API_KEY
-# If MODAL_INFERENCE_API_KEY is not set, analyze_with_vlm falls back to legacy.
-
-_MODAL_URL = os.environ.get('MODAL_URL', 'https://narwall-tech--color-ux-access-ui.modal.run')
-
-# Modal Inference Provider configuration
-_MODAL_INFERENCE_BASE_URL = os.environ.get('MODAL_INFERENCE_BASE_URL', 'https://inference.modal.com/v1')
-_MODAL_INFERENCE_API_KEY = os.environ.get('MODAL_INFERENCE_API_KEY')  # from modal secret modal-inference-key
-
+# -- VLM Inference ------------------------------------------------------------
+
+_VLM_CVD_PROMPTS = {
+    "Normal vision (original design)": (
+        "You are an accessibility expert viewing this page with normal color vision. "
+        "Analyze it for WCAG 2.1 compliance issues. "
+        "Focus on contrast, color usage, and text readability as a fully sighted user."
+    ),
+    "Protanopia (red-blind)": (
+        "You have protanopia (red-blind CVD). Analyze this page as it appears to you. "
+        "Focus on WCAG 2.1 compliance issues that affect a protanope: "
+        "red-green color confusion, information conveyed solely by red, "
+        "and contrast problems specific to your condition."
+    ),
+    "Deuteranopia (green-blind)": (
+        "You have deuteranopia (green-blind CVD). Analyze this page as it appears to you. "
+        "Focus on WCAG 2.1 compliance issues that affect a deuteranope: "
+        "green-red color confusion, information conveyed solely by green, "
+        "and contrast problems specific to your condition."
+    ),
+    "Tritanopia (blue-blind)": (
+        "You have tritanopia (blue-blind CVD). Analyze this page as it appears to you. "
+        "Focus on WCAG 2.1 compliance issues that affect a tritanope: "
+        "blue-yellow color confusion, information conveyed solely by blue, "
+        "and contrast problems specific to your condition."
+    ),
+}
 
-def _call_modal_analyze(image_bytes: bytes, timeout: int = 120) -> dict:
+_ACCESSIBILITY_SYSTEM_PROMPT = (
+    "Output a JSON object with this structure:\n"
+    "{\n"
+    '  "findings": [\n'
+    "    {\n"
+    '      "type": "Low Contrast | Color Only Information | Missing Text Alternative | Insufficient Non-Text Contrast",\n'
+    '      "wcag_criterion": "1.4.1 | 1.4.3 | 1.1.1 | 1.4.11",\n'
+    '      "description": "...",\n'
+    '      "severity": "critical | serious | moderate",\n'
+    '      "location": "Top-left, center, etc."\n'
+    "    }\n"
+    "  ],\n"
+    '  "summary": "Overall assessment from your perspective",\n'
+    '  "passes": true/false\n'
+    "}\n"
+    "Return ONLY valid JSON -- no markdown fences, no commentary."
+)
+
+
+def _call_minicpm_endpoint(image_bytes: bytes, system_prompt: str) -> dict:
     """
-    Call the Modal Gradio endpoint's /analyze_screenshot API.
-    Upload image → POST predict → poll SSE for result.
-
-    Args:
-        image_bytes: PNG/JPEG bytes of the screenshot.
-        timeout: Max seconds to wait for VLM inference result.
-
-    Returns:
-        WCAG JSON dict with keys: findings, passes, summary.
-
-    Raises:
-        RuntimeError: If upload, predict, or polling fails.
+    Call the MiniCPM vLLM endpoint on Modal directly.
+    POST to MODAL_INFERENCE_URL with base64 image + accessibility prompt.
     """
-    gradio_api = f"{_MODAL_URL}/gradio_api"
-
-    upload_resp = requests.post(
-        f"{gradio_api}/upload",
-        files={'files': ('screenshot.png', image_bytes, 'image/png')},
-        timeout=30,
-    )
-    if upload_resp.status_code != 200:
-        raise RuntimeError(f"Modal file upload failed: {upload_resp.status_code} {upload_resp.text[:100]}")
+    if not _MODAL_INFERENCE_URL:
+        return {"error": "MODAL_INFERENCE_URL not set. Configure in .env or Space secrets.", "findings": [], "passes": False}
 
-    file_paths = upload_resp.json()
-    if not file_paths:
-        raise RuntimeError(f"Modal file upload returned no paths: {upload_resp.text[:100]}")
+    image_b64 = base64.b64encode(image_bytes).decode('utf-8')
+    payload = {"prompt": system_prompt, "image_base64": image_b64}
 
-    file_path = file_paths[0]
+    try:
+        resp = requests.post(_MODAL_INFERENCE_URL, json=payload, timeout=180)
+        resp.raise_for_status()
+        data = resp.json()
+    except requests.exceptions.Timeout:
+        return {"error": "MiniCPM endpoint timed out (cold-start may need ~90s). Try again.", "findings": [], "passes": False}
+    except Exception as e:
+        return {"error": f"MiniCPM endpoint call failed: {e}", "findings": [], "passes": False}
 
-    predict_resp = requests.post(
-        f"{gradio_api}/call/analyze_screenshot",
-        json={'data': [{'path': file_path, 'meta': {'_type': 'gradio.FileData'}}]},
-        timeout=10,
-    )
-    if predict_resp.status_code != 200:
-        raise RuntimeError(f"Modal predict call failed: {predict_resp.status_code} {predict_resp.text[:100]}")
+    raw = data.get("response", "")
+    if not raw:
+        return {"error": "MiniCPM returned empty response", "findings": [], "passes": False}
 
-    event_id = predict_resp.json().get('event_id')
-    if not event_id:
-        raise RuntimeError(f"Modal predict returned no event_id: {predict_resp.text[:100]}")
+    if raw.startswith("```"):
+        lines = raw.split("\n")
+        raw = "\n".join(lines[1:-1])
 
-    poll_url = f"{gradio_api}/call/analyze_screenshot/{event_id}"
-    with requests.get(poll_url, timeout=timeout, stream=True) as poll_resp:
-        if poll_resp.status_code != 200:
-            raise RuntimeError(f"Modal poll failed: {poll_resp.status_code}")
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return {"error": f"MiniCPM returned non-JSON: {raw[:500]}", "findings": [], "passes": False}
 
-        full_data = ''
-        for line in poll_resp.iter_lines():
-            if line:
-                decoded = line.decode('utf-8')
-                if decoded.startswith('data: '):
-                    full_data = decoded[6:]
 
-        if not full_data:
-            raise RuntimeError("Modal poll returned no data")
+def _merge_cvd_results(results: dict[str, dict]) -> dict:
+    """
+    Merge VLM results from multiple CVD perspectives into a single report.
 
-        result = json.loads(full_data)
-        if isinstance(result, list):
-            result = result[0]
-        return result
+    Deduplicates findings by description (same issue flagged by multiple
+    CVD types only appears once) and aggregates summaries.
+    """
+    all_findings = []
+    summaries = []
+    overall_passes = True
+
+    for cvd_label, result in results.items():
+        if "error" in result:
+            summaries.append(f"{cvd_label}: {result['error']}")
+            continue
+        if not result.get("passes", False):
+            overall_passes = False
+        for finding in result.get("findings", []):
+            finding["cvd_perspective"] = cvd_label
+            all_findings.append(finding)
+        if result.get("summary"):
+            summaries.append(f"{cvd_label}: {result['summary']}")
+
+    # Deduplicate by description hash
+    seen = set()
+    unique = []
+    for f in all_findings:
+        key = f.get("description", "")[:80]
+        if key and key not in seen:
+            seen.add(key)
+            unique.append(f)
+
+    return {
+        "findings": unique,
+        "summary": " | ".join(summaries) if summaries else "Multi-perspective analysis complete.",
+        "passes": overall_passes,
+    }
 
 
-# ── VLM Inference (via Modal Inference Provider) ──────────────────────────────────────
-def analyze_with_vlm(image_bytes: bytes, model: str = "aya-vision-32b") -> dict:
+def analyze_all_perspectives(cvd_grid: list) -> dict:
     """
-    Analyze a screenshot for WCAG color-accessibility issues via Modal Inference Provider.
-    Falls back to the legacy Gradio endpoint (_call_modal_analyze) if the new
-    MODAL_INFERENCE_API_KEY environment variable is not configured.
-    """
-    if not _MODAL_INFERENCE_API_KEY:
-        return _call_modal_analyze(image_bytes)
+    Run VLM analysis on each CVD perspective sequentially.
 
-    try:
-        # Prepare OpenAI client pointing to Modal inference endpoint
-        client = OpenAI(
-            base_url=_MODAL_INFERENCE_BASE_URL,
-            api_key=_MODAL_INFERENCE_API_KEY,
-        )
-        
-        # Encode image to base64
-        image_b64 = base64.b64encode(image_bytes).decode('utf-8')
-        
-        # System prompt from modal_app.py (adjusted)
-        system_prompt = (
-            "You are an accessibility expert specializing in colorblind user experience. "
-            "Analyze screenshots for WCAG 2.1 compliance issues. "
-            "For each finding, cite the specific success criterion (1.1.1, 1.4.1, 1.4.3, or 1.4.11). "
-            "Output a JSON object with this structure:\n"
-            "{\n"
-            "  \"findings\": [\n"
-            "    {\n"
-            "      \"type\": \"Low Contrast | Color Only Information | Missing Text Alternative | Insufficient Non-Text Contrast\",\n"
-            "      \"wcag_criterion\": \"1.4.1 | 1.4.3 | 1.1.1 | 1.4.11\",\n"
-            "      \"description\": \"...\",\n"
-            "      \"severity\": \"critical | serious | moderate\",\n"
-            "      \"location\": \"Top-left, center, etc.\",\n"
-            "    }\n"
-            "  ],\n"
-            "  \"summary\": \"Overall assessment\",\n"
-            "  \"passes\": true/false\n"
-            "}\n"
-        )
-        
-        # Determine actual model ID from MODELS dict
-        model_info = MODELS.get(model, {})
-        model_id = model_info.get("model_id", model)  # fallback to model key
-        
-        response = client.chat.completions.create(
-            model=model_id,
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": system_prompt},
-                        {
-                            "type": "image_url",
-                            "image_url": {"url": f"data:image/png;base64,{image_b64}"},
-                        },
-                    ],
-                }
-            ],
-            max_tokens=1024,
-            temperature=0.1,
-        )
-        
-        content = response.choices[0].message.content
-        if content.startswith("```"):
-            # Strip code fences if present
-            lines = content.split("\n")
-            content = "\n".join(lines[1:-1])
-        return json.loads(content)
-    except Exception as e:
-        return {"error": str(e), "findings": [], "passes": False}
-
-# ── URL Mode Flag ──────────────────────────────────────────────────────────────
-# Set --url on the command line to enable URL capture input.
-# On HF Spaces, __file__ is set and --url is not passed, so URL mode stays off.
+    Each CVD variant gets a type-specific prompt so the model understands
+    which color deficiency it's simulating. Results are merged into a
+    single deduplicated report simulating a full panel of colorblind testers.
+    """
+    results = {}
+    for img, label in cvd_grid:
+        role_prompt = _VLM_CVD_PROMPTS.get(label, _VLM_CVD_PROMPTS["Normal vision (original design)"])
+        full_prompt = f"{role_prompt}\n\n{_ACCESSIBILITY_SYSTEM_PROMPT}"
+        img_bytes = image_to_bytes(img)
+        result = _call_minicpm_endpoint(img_bytes, full_prompt)
+        results[label] = result
 
-_url_mode = '--url' in sys.argv
+    return _merge_cvd_results(results)
 
 
-# ── Gradio App ────────────────────────────────────────────────────────────────
+# -- Gradio App ---------------------------------------------------------------
 
 _theme_css = """
 :root { --color-primary: #1E88E5; }
@@ -386,117 +326,60 @@ with gr.Blocks(
         '1. Capture your screen (OS/Browser screenshot tool)\n'
         '2. Upload the screenshot below\n'
         '3. Get CVD simulations + WCAG 2.1 accessibility report\n\n'
-        '⚠️ First analysis takes ~60–90s (model loads once, then stays cached).'
+        'The VLM analyzes **all four CVD perspectives** (Normal, Protanopia, Deuteranopia, '
+        'Tritanopia) -- simulating a full panel of colorblind testers.\n\n'
+        'Note: First analysis takes ~60-90s (MiniCPM cold-start on Modal GPU).'
     )
 
     with gr.Row():
-        if _url_mode:
-            url_input = gr.Textbox(label='Website URL', placeholder='https://example.com', scale=1)
-            submit_btn = gr.Button('Capture & Analyze', variant='primary', scale=0)
-        else:
-            file_input = gr.File(
-                label='Screenshot',
-                file_types=['.png', '.jpg', '.jpeg', '.webp'],
-                type='binary',
-                height=80,
-            )
-            submit_btn = gr.Button('Analyze', variant='primary', scale=0)
-
-        model_select = gr.Dropdown(
-            choices=list(MODELS.keys()),
-            value="aya-vision-32b",
-            label='VLM Model',
-            info='Switch models for different sponsor prize eligibility',
+        file_input = gr.File(
+            label='Screenshot',
+            file_types=['.png', '.jpg', '.jpeg', '.webp'],
+            type='binary',
+            height=80,
         )
+        submit_btn = gr.Button('Analyze', variant='primary', scale=0)
 
     with gr.Row():
-        with gr.Column(scale=1):
-            original_output = gr.Image(label='Original', type='pil')
-        with gr.Column(scale=2):
-            cvd_output = gr.Gallery(
-                label='CVD Simulations (10 types)',
-                columns=4,
-                rows=3,
-                object_fit='contain',
-                height='auto',
-            )
+        cvd_grid = gr.Gallery(
+            label='Color-Vision Comparison (2x2 grid)',
+            columns=2,
+            rows=2,
+            object_fit='contain',
+            height=600,
+        )
 
     report_output = gr.Markdown(label='Accessibility Report')
 
-    # ── Event Handlers ─────────────────────────────────────────────────────────
-
-    def run_analysis_from_file(file_obj, model: str = "aya-vision-32b"):
-        """File upload mode — used on HF Spaces."""
+    def run_analysis(file_obj):
+        """File upload mode -- receives screenshot bytes, returns CVD grid + report."""
         if file_obj is None:
-            return None, [], '⚠️ Please upload a screenshot first.'
+            return [], 'Please upload a screenshot first.'
 
         image_bytes = file_obj if isinstance(file_obj, bytes) else file_obj.read()
 
         try:
             original = Image.open(io.BytesIO(image_bytes)).convert('RGB')
         except Exception as e:
-            return None, [], f'⚠️ Could not open image: {e}'
+            return [], f'Could not open image: {e}'
 
-        cvd_gallery = generate_cvd_gallery(original)
+        grid = generate_cvd_grid(original)
 
+        # Send ALL CVD perspectives to the VLM endpoint
+        # Each variant gets a role-specific prompt (Normal, Protanopia, Deuteranopia, Tritanopia)
         try:
-            vlm_result = analyze_with_vlm(image_bytes, model=model)
+            vlm_result = analyze_all_perspectives(grid)
         except Exception as e:
             vlm_result = {'error': str(e), 'findings': [], 'passes': False}
 
         report_md = format_wcag_report(vlm_result)
-        return original, cvd_gallery, report_md
-
-    def run_analysis_from_url(url: str, model: str = "aya-vision-32b"):
-        """URL capture mode — Playwright local dev only."""
-        if not url:
-            return None, [], '⚠️ Please enter a URL first.'
-
-        try:
-            image_bytes = _capture_url(url)
-        except Exception as e:
-            return None, [], f'⚠️ Could not capture URL: {e}'
+        return grid, report_md
 
-        try:
-            original = Image.open(io.BytesIO(image_bytes)).convert('RGB')
-        except Exception as e:
-            return None, [], f'⚠️ Could not open screenshot: {e}'
-
-        cvd_gallery = generate_cvd_gallery(original)
-
-        try:
-            vlm_result = analyze_with_vlm(image_bytes, model=model)
-        except Exception as e:
-            vlm_result = {'error': str(e), 'findings': [], 'passes': False}
-
-        report_md = format_wcag_report(vlm_result)
-        return original, cvd_gallery, report_md
-
-    if _url_mode:
-        submit_btn.click(
-            fn=run_analysis_from_url,
-            inputs=[url_input, model_select],
-            outputs=[original_output, cvd_output, report_output],
-        )
-        gr.Examples(
-            examples=[
-                ["https://www.google.com"],
-                ["https://www.wikipedia.org"],
-                ["https://www.apple.com"],
-            ],
-            inputs=url_input,
-            outputs=[original_output, cvd_output, report_output],
-            fn=run_analysis_from_url,
-            cache_examples=False,
-        )
-    else:
-        submit_btn.click(
-            fn=run_analysis_from_file,
-            inputs=[file_input, model_select],
-            outputs=[original_output, cvd_output, report_output],
-        )
-        gr.Markdown('---')
-        gr.Markdown('*Upload a screenshot or use URL capture mode (`python app.py --url`).*')
+    submit_btn.click(
+        fn=run_analysis,
+        inputs=file_input,
+        outputs=[cvd_grid, report_output],
+    )
 
 
 if __name__ == '__main__':
@@ -504,11 +387,7 @@ if __name__ == '__main__':
         demo.launch(
             server_name='0.0.0.0',
             server_port=7860,
-            theme=gr.themes.Base(
-                primary_hue='blue',
-                secondary_hue='gray',
-                neutral_hue='gray',
-            ),
+            theme=color_ux_access_theme,
             css=_theme_css,
         )
     else:

pyproject.toml

@@ -26,6 +26,9 @@ dependencies = [
     "requests>=2.34.2",
     "modal>=1.4.3",
     "openai>=1.0",
+    "pytest>=9.0.3",
+    "dotenv>=0.9.9",
+    "colorspacious>=1.1.2",
 ]
 
 [project.optional-dependencies]

tests/test_app_space.py

@@ -31,24 +31,32 @@ def img_factory(width=100, height=100, color=(128, 128, 128)):
 
 # ── CVD Gallery Tests ─────────────────────────────────────────────────────────
 
-class TestCVDGallery:
-    def test_gallery_returns_ten_items(self):
+class TestCVDGrid:
+    def test_grid_returns_four_items(self):
         img = img_factory(200, 200)
-        gallery = app_module.generate_cvd_gallery(img)
-        assert len(gallery) == 10, f"Expected 10 CVD variants, got {len(gallery)}"
+        gallery = app_module.generate_cvd_grid(img)
+        assert len(gallery) == 4, f"Expected 4 CVD variants, got {len(gallery)}"
 
-    def test_gallery_items_are_pil_images(self):
+    def test_grid_items_are_pil_images(self):
         img = img_factory(200, 200)
-        gallery = app_module.generate_cvd_gallery(img)
+        gallery = app_module.generate_cvd_grid(img)
         for item, label in gallery:
             assert isinstance(item, Image.Image), f"Expected PIL Image, got {type(item)}"
 
-    def test_gallery_labels_not_empty(self):
+    def test_grid_labels_not_empty(self):
         img = img_factory(200, 200)
-        gallery = app_module.generate_cvd_gallery(img)
+        gallery = app_module.generate_cvd_grid(img)
         for _, label in gallery:
             assert label, "Gallery label must not be empty"
 
+    def test_grid_has_correct_labels(self):
+        img = img_factory(100, 100)
+        gallery = app_module.generate_cvd_grid(img)
+        expected = ["Normal vision (original design)", "Protanopia (red-blind)",
+                    "Deuteranopia (green-blind)", "Tritanopia (blue-blind)"]
+        for (_, label), expected_label in zip(gallery, expected):
+            assert label == expected_label, f"Expected '{expected_label}', got '{label}'"
+
     def test_achromatopsia_is_grayscale(self):
         img = img_factory(100, 100, (200, 50, 50))  # red image
         achro = app_module.simulate_achromatopsia(img, 1.0)
@@ -85,7 +93,7 @@ class TestWCAGReport:
     def test_report_error_handling(self):
         result = {"error": "Model timeout after 60s"}
         report = app_module.format_wcag_report(result)
-        assert "Error" in report or "⚠" in report
+        assert "Error" in report or "Warning" in report
 
     def test_report_no_findings_without_pass_flag(self):
         result = {"findings": [], "summary": "No issues detected"}
@@ -93,27 +101,17 @@ class TestWCAGReport:
         assert "No accessibility issues" in report
 
 
-# ── MODELS Dict Tests ─────────────────────────────────────────────────────────
-
-class TestMODELS:
-    def test_models_dict_exists(self):
-        assert hasattr(app_module, 'MODELS')
+# ── SUPPORTED_MODEL Tests ─────────────────────────────────────────────────────
 
-    def test_aya_vision_model_present(self):
-        assert "aya-vision-32b" in app_module.MODELS
-        entry = app_module.MODELS["aya-vision-32b"]
-        assert "model_id" in entry
-        assert entry["model_id"] == "CohereLabs/aya-vision-32b"
+class TestSupportedModel:
+    def test_supported_model_exists(self):
+        assert hasattr(app_module, 'SUPPORTED_MODEL')
 
-    def test_minicpm_model_present(self):
-        assert "minicpm-v-4.6" in app_module.MODELS
-        entry = app_module.MODELS["minicpm-v-4.6"]
-        assert "model_id" in entry
+    def test_supported_model_is_minicpm(self):
+        assert app_module.SUPPORTED_MODEL == "minicpm-v-4.6"
 
-    def test_all_models_have_required_keys(self):
-        for name, entry in app_module.MODELS.items():
-            assert "model_id" in entry, f"{name} missing model_id"
-            assert "provider" in entry, f"{name} missing provider"
+    def test_supported_model_is_string(self):
+        assert isinstance(app_module.SUPPORTED_MODEL, str)
 
 
 # ── Gradio 5/6 Compat Tests ───────────────────────────────────────────────────

tests/test_smoke.py

@@ -72,7 +72,7 @@ class TestGradioApps:
 
     def test_app_has_cvd_gallery(self):
         import app as app_module
-        assert callable(app_module.generate_cvd_gallery)
+        assert callable(app_module.generate_cvd_grid)
 
     def test_deficiency_config_has_8_types(self):
         import app as app_module
@@ -80,16 +80,9 @@ class TestGradioApps:
 
 
 class TestCVDVariants:
-    def test_ten_type_gallery_count(self):
-        """generate_cvd_gallery must produce exactly 10 variants (8 CVD + 2 grayscale)."""
-        import app as app_module
-        img = Image.new('RGB', (100, 100), (128, 128, 128))
-        gallery = app_module.generate_cvd_gallery(img)
-        assert len(gallery) == 10, f"Expected 10 CVD variants, got {len(gallery)}"
-
     def test_all_cvd_type_names_unique(self):
         import app as app_module
         img = Image.new('RGB', (50, 50), (100, 100, 100))
-        gallery = app_module.generate_cvd_gallery(img)
+        gallery = app_module.generate_cvd_grid(img)
         names = [label for _, label in gallery]
         assert len(names) == len(set(names)), "CVD type labels must be unique"

uv.lock

@@ -408,12 +408,15 @@ name = "color-ux-access"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
+    { name = "colorspacious" },
     { name = "daltonlens" },
+    { name = "dotenv" },
     { name = "gradio" },
     { name = "modal" },
     { name = "numpy" },
     { name = "openai" },
     { name = "pillow" },
+    { name = "pytest" },
     { name = "requests" },
 ]
 
@@ -449,8 +452,10 @@ space = [
 [package.metadata]
 requires-dist = [
     { name = "color-ux-access", extras = ["dev", "space", "modal"], marker = "extra == 'all'" },
+    { name = "colorspacious", specifier = ">=1.1.2" },
     { name = "colorspacious", marker = "extra == 'dev'", specifier = ">=1.1.2" },
     { name = "daltonlens", specifier = ">=0.1.5" },
+    { name = "dotenv", specifier = ">=0.9.9" },
     { name = "fastapi", extras = ["standard"], marker = "extra == 'modal'", specifier = ">=0.120" },
     { name = "gradio", specifier = ">=6.17.3" },
     { name = "modal", specifier = ">=1.4.3" },
@@ -460,6 +465,7 @@ requires-dist = [
     { name = "openai", marker = "extra == 'modal'", specifier = ">=1.0" },
     { name = "openai", marker = "extra == 'space'", specifier = ">=1.0" },
     { name = "pillow", specifier = ">=10.0" },
+    { name = "pytest", specifier = ">=9.0.3" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" },
     { name = "python-dotenv", marker = "extra == 'space'", specifier = ">=1.0" },
     { name = "python-multipart", marker = "extra == 'modal'", specifier = ">=0.0.20" },
@@ -596,6 +602,17 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },
 ]
 
+[[package]]
+name = "dotenv"
+version = "0.9.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dotenv" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892, upload-time = "2025-02-19T22:15:01.647Z" },
+]
+
 [[package]]
 name = "email-validator"
 version = "2.3.0"

vlm/accessibility_report.py

@@ -1,379 +0,0 @@
-"""
-Accessibility Report Generator based on WCAG Standards
-"""
-
-import json
-import re
-from datetime import datetime
-from typing import Dict, List, Any, Optional
-
-class WCAGStandards:
-    """WCAG 2.1/2.2 color contrast and color usage standards"""
-    
-    # Contrast ratios
-    CONTRAST_RATIOS = {
-        'AA_NORMAL_TEXT': 4.5,
-        'AA_LARGE_TEXT': 3.0,
-        'AA_UI_COMPONENTS': 3.0,  # WCAG 2.1
-        'AAA_NORMAL_TEXT': 7.0,
-        'AAA_LARGE_TEXT': 4.5
-    }
-    
-    # Success criteria references
-    SUCCESS_CRITERIA = {
-        '1.4.3': 'Contrast (Minimum) - AA',
-        '1.4.6': 'Contrast (Enhanced) - AAA',
-        '1.4.11': 'Non-text Contrast - AA (WCAG 2.1)',
-        '1.4.1': 'Use of Color - A'
-    }
-
-class AccessibilityReport:
-    """Generate accessibility reports based on VLM analysis"""
-    
-    def __init__(self):
-        self.standards = WCAGStandards()
-    
-    def parse_vlm_output(self, vlm_output: str) -> List[Dict[str, Any]]:
-        """
-        Parse VLM output to extract accessibility issues
-        Expected format: JSON array of issues with description, type, remediation, bbox
-        """
-        issues = []
-        
-        try:
-            # Try to extract JSON from the output
-            json_match = re.search(r'\[.*\]', vlm_output, re.DOTALL)
-            if json_match:
-                json_str = json_match.group()
-                parsed_issues = json.loads(json_str)
-                
-                if isinstance(parsed_issues, list):
-                    for issue in parsed_issues:
-                        if isinstance(issue, dict):
-                            # Standardize issue format
-                            standardized_issue = {
-                                'description': issue.get('description', ''),
-                                'type': issue.get('type', 'unknown'),
-                                'remediation': issue.get('remediation', ''),
-                                'bbox': issue.get('bbox', issue.get('point', [])),
-                                'wcag_references': self._map_to_wcag(issue.get('type', '')),
-                                'severity': self._assess_severity(issue.get('type', ''), issue.get('description', ''))
-                            }
-                            issues.append(standardized_issue)
-                else:
-                    # Single issue object
-                    if isinstance(parsed_issues, dict):
-                        issue = parsed_issues
-                        standardized_issue = {
-                            'description': issue.get('description', ''),
-                            'type': issue.get('type', 'unknown'),
-                            'remediation': issue.get('remediation', ''),
-                            'bbox': issue.get('bbox', issue.get('point', [])),
-                            'wcag_references': self._map_to_wcag(issue.get('type', '')),
-                            'severity': self._assess_severity(issue.get('type', ''), issue.get('description', ''))
-                        }
-                        issues.append(standardized_issue)
-            else:
-                # Fallback: treat as text analysis
-                issues = self._parse_text_analysis(vlm_output)
-                
-        except (json.JSONDecodeError, Exception) as e:
-            print(f"Error parsing VLM output: {e}")
-            # Fallback to text parsing
-            issues = self._parse_text_analysis(vlm_output)
-        
-        return issues
-    
-    def _map_to_wcag(self, issue_type: str) -> List[str]:
-        """Map issue type to WCAG success criteria."""
-        issue_type_lower = issue_type.lower()
-        wcag_refs = []
-
-        if 'contrast' in issue_type_lower and 'ui' in issue_type_lower:
-            wcag_refs.append('1.4.11')  # Non-text Contrast
-        if 'contrast' in issue_type_lower and 'text' in issue_type_lower:
-            wcag_refs.extend(['1.4.3', '1.4.6'])  # Contrast (Minimum and Enhanced)
-        if 'color-only' in issue_type_lower or 'color only' in issue_type_lower:
-            wcag_refs.append('1.4.1')  # Use of Color
-        if 'color-dependent' in issue_type_lower or 'color dependent' in issue_type_lower:
-            wcag_refs.append('1.4.1')
-        if 'ui' in issue_type_lower or 'component' in issue_type_lower or 'button' in issue_type_lower or 'input' in issue_type_lower:
-            if '1.4.11' not in wcag_refs:
-                wcag_refs.append('1.4.11')  # Non-text Contrast
-
-        return wcag_refs if wcag_refs else ['1.4.3']  # Default to contrast check
-
-    def _assess_severity(self, issue_type: str, description: str) -> str:
-        """Assess severity based on issue type and description."""
-        issue_type_lower = issue_type.lower()
-        desc_lower = description.lower()
-
-        # Critical: blocks core task completion
-        if any(word in issue_type_lower for word in ['critical', 'severe', 'major']):
-            return 'critical'
-        if any(word in desc_lower for word in [
-            'cannot submit', 'cannot complete', 'form submission blocked',
-            'invisible', 'unreadable', 'cannot see', 'cannot distinguish',
-            'error state invisible', 'no way to tell',
-        ]):
-            return 'critical'
-
-        # Serious: significant confusion or delay
-        if any(word in issue_type_lower for word in ['serious', 'error state', 'status indicator']):
-            return 'serious'
-        if any(word in desc_lower for word in [
-            'difficult', 'hard to see', 'low visibility', 'confusing',
-            'cannot identify', 'cannot tell which', 'ambiguous',
-        ]):
-            return 'serious'
-
-        # Moderate: workaround exists
-        if any(word in issue_type_lower for word in ['moderate', 'medium']):
-            return 'moderate'
-        if any(word in desc_lower for word in ['minor', 'slight', 'could be better']):
-            return 'moderate'
-
-        # Contrast-specific: extract ratio if mentioned
-        if 'contrast' in issue_type_lower:
-            contrast_match = re.search(r'(\d+(?:\.\d+)?):1', desc_lower)
-            if contrast_match:
-                ratio = float(contrast_match.group(1))
-                if ratio < 3.0:
-                    return 'critical'
-                elif ratio < 4.5:
-                    return 'serious'
-                else:
-                    return 'moderate'
-
-        return 'moderate'  # Default
-    
-    def _parse_text_analysis(self, text: str) -> List[Dict[str, Any]]:
-        """Parse free-text VLM analysis into structured issues"""
-        issues = []
-        
-        # Simple heuristic: look for common accessibility issue patterns
-        lines = text.split('\n')
-        current_issue = {}
-        
-        for line in lines:
-            line = line.strip()
-            if not line:
-                if current_issue:
-                    issues.append(self._finalize_issue(current_issue))
-                    current_issue = {}
-                continue
-                
-            # Look for issue indicators
-            if any(word in line.lower() for word in ['issue', 'problem', 'concern', 'violation', 'fail']):
-                if current_issue:
-                    issues.append(self._finalize_issue(current_issue))
-                current_issue = {
-                    'description': line,
-                    'type': self._infer_type_from_text(line),
-                    'remediation': '',
-                    'bbox': []
-                }
-            elif 'recommend' in line.lower() or 'suggest' in line.lower() or 'should' in line.lower():
-                if current_issue:
-                    current_issue['remediation'] = line
-            elif current_issue and 'description' in current_issue:
-                # Append to description
-                current_issue['description'] += ' ' + line
-        
-        # Don't forget the last issue
-        if current_issue:
-            issues.append(self._finalize_issue(current_issue))
-            
-        return issues
-    
-    def _infer_type_from_text(self, text: str) -> str:
-        """Infer issue type from text description"""
-        text_lower = text.lower()
-        if 'contrast' in text_lower:
-            return 'low contrast'
-        elif 'color' in text_lower and ('dependent' in text_lower or 'only' in text_lower):
-            return 'color-dependent element'
-        elif 'text' in text_lower and ('size' in text_lower or 'readable' in text_lower):
-            return 'text readability'
-        else:
-            return 'accessibility issue'
-    
-    def _finalize_issue(self, issue: Dict[str, Any]) -> Dict[str, Any]:
-        """Finalize issue with WCAG references and severity"""
-        issue['wcag_references'] = self._map_to_wcag(issue.get('type', ''))
-        issue['severity'] = self._assess_severity(issue.get('type', ''), issue.get('description', ''))
-        return issue
-    
-    def generate_report(self, url: str, vlm_analysis: str, screenshot_path: Optional[str] = None) -> Dict[str, Any]:
-        """
-        Generate a complete accessibility report
-        
-        Returns:
-            Dictionary containing the full report
-        """
-        issues = self.parse_vlm_output(vlm_analysis)
-        
-        # Calculate summary statistics
-        total_issues = len(issues)
-        high_severity = len([i for i in issues if i.get('severity') == 'high'])
-        medium_severity = len([i for i in issues if i.get('severity') == 'medium'])
-        low_severity = len([i for i in issues if i.get('severity') == 'low'])
-        
-        # Determine overall compliance level
-        if high_severity == 0 and medium_severity <= 2:
-            compliance_level = "Good"
-        elif high_severity == 0:
-            compliance_level = "Fair"
-        elif high_severity <= 2:
-            compliance_level = "Poor"
-        else:
-            compliance_level = "Non-compliant"
-        
-        report = {
-            'metadata': {
-                'url': url,
-                'timestamp': datetime.now().isoformat(),
-                'tool': 'Color-UX-Access with Qwen2.5-VL-32B-Instruct',
-                'wcag_version': '2.1/2.2',
-                'screenshot_analyzed': screenshot_path
-            },
-            'summary': {
-                'total_issues': total_issues,
-                'high_severity': high_severity,
-                'medium_severity': medium_severity,
-                'low_severity': low_severity,
-                'compliance_level': compliance_level,
-                'wcag_version_tested': '2.1/2.2 AA'
-            },
-            'issues': issues,
-            'wcag_standards_referenced': list(self.standards.SUCCESS_CRITERIA.values()),
-            'recommendations': self._generate_recommendations(issues)
-        }
-        
-        return report
-    
-    def _generate_recommendations(self, issues: List[Dict[str, Any]]) -> List[str]:
-        """Generate prioritized recommendations based on issues"""
-        recommendations = []
-        
-        # Group issues by type for batch recommendations
-        issue_types = {}
-        for issue in issues:
-            issue_type = issue.get('type', 'unknown')
-            if issue_type not in issue_types:
-                issue_types[issue_type] = []
-            issue_types[issue_type].append(issue)
-        
-        # Priority recommendations
-        if any('contrast' in issue_type.lower() for issue_type in issue_types.keys()):
-            recommendations.append({
-                'priority': 'high',
-                'category': 'Color Contrast',
-                'recommendation': 'Ensure all text and UI components meet WCAG 2.1 AA contrast ratios (4.5:1 for normal text, 3:1 for large text and UI components). Use a contrast checker to verify compliance.',
-                'wcag_reference': '1.4.3, 1.4.11'
-            })
-        
-        if any('color-dependent' in issue_type.lower() for issue_type in issue_types.keys()):
-            recommendations.append({
-                'priority': 'high',
-                'category': 'Use of Color',
-                'recommendation': 'Do not rely solely on color to convey information. Add text labels, icons, or patterns to supplement color coding.',
-                'wcag_reference': '1.4.1'
-            })
-        
-        # Add general recommendations
-        recommendations.append({
-            'priority': 'medium',
-            'category': 'Testing',
-            'recommendation': 'Test with actual users who have color vision deficiencies and use automated accessibility testing tools regularly.',
-            'wcag_reference': 'General'
-        })
-        
-        return recommendations
-    
-    def format_report_as_markdown(self, report: Dict[str, Any]) -> str:
-        """Format the report as readable Markdown"""
-        md = []
-        md.append(f"# Accessibility Audit Report")
-        md.append(f"**URL:** {report['metadata']['url']}")
-        md.append(f"**Timestamp:** {report['metadata']['timestamp']}")
-        md.append(f"**Tool:** {report['metadata']['tool']}")
-        md.append(f"**WCAG Version:** {report['metadata']['wcag_version']}")
-        md.append("")
-        
-        md.append("## Executive Summary")
-        summary = report['summary']
-        md.append(f"- **Total Issues Found:** {summary['total_issues']}")
-        md.append(f"- **High Severity:** {summary['high_severity']}")
-        md.append(f"- **Medium Severity:** {summary['medium_severity']}")
-        md.append(f"- **Low Severity:** {summary['low_severity']}")
-        md.append(f"- **Compliance Level:** {summary['compliance_level']}")
-        md.append(f"- **WCAG Level Tested:** {summary['wcag_version_tested']}")
-        md.append("")
-        
-        md.append("## Issues Found")
-        if not report['issues']:
-            md.append("No accessibility issues detected.")
-        else:
-            for i, issue in enumerate(report['issues'], 1):
-                md.append(f"### Issue {i}: {issue.get('type', 'Unknown').title()}")
-                md.append(f"- **Description:** {issue.get('description', 'N/A')}")
-                md.append(f"- **Type:** {issue.get('type', 'N/A')}")
-                md.append(f"- **Severity:** {issue.get('severity', 'N/A').title()}")
-                md.append(f"- **Location:** {issue.get('bbox', 'Not specified')}")
-                if issue.get('wcag_references'):
-                    md.append(f"- **WCAG References:** {', '.join(issue['wcag_references'])}")
-                md.append(f"- **Remediation:** {issue.get('remediation', 'No specific remediation provided')}")
-                md.append("")
-        
-        md.append("## Recommendations")
-        for rec in report['recommendations']:
-            md.append(f"### {rec['category']} ({rec['priority'].title()} Priority)")
-            md.append(f"{rec['recommendation']}")
-            md.append(f"*WCAG Reference: {rec['wcag_reference']}*")
-            md.append("")
-        
-        md.append("## WCAG Standards Referenced")
-        for standard in report['wcag_standards_referenced']:
-            md.append(f"- {standard}")
-        md.append("")
-        
-        md.append("--")
-        md.append(f"*Report generated by Color-UX-Access on {report['metadata']['timestamp']}*")
-        
-        return '\n'.join(md)
-
-def main():
-    """Test the report generator"""
-    import sys
-    
-    if len(sys.argv) < 2:
-        print("Usage: python accessibility_report.py <vlm_output_file_or_text> [url]")
-        sys.exit(1)
-    
-    # Read VLM output
-    vlm_input = sys.argv[1]
-    url = sys.argv[2] if len(sys.argv) > 2 else "https://example.com"
-    
-    # Try to read from file, otherwise treat as direct text
-    try:
-        with open(vlm_input, 'r', encoding='utf-8') as f:
-            vlm_output = f.read()
-    except FileNotFoundError:
-        vlm_output = vlm_input
-    
-    # Generate report
-    reporter = AccessibilityReport()
-    report = reporter.generate_report(url, vlm_output)
-    
-    # Output as JSON
-    print(json.dumps(report, indent=2))
-    
-    # Also output markdown version
-    print("\n" + "="*50)
-    print("MARKDOWN VERSION:")
-    print("="*50)
-    print(reporter.format_report_as_markdown(report))
-
-if __name__ == "__main__":
-    main()