fix: replace gr.Server with gr.Blocks + rewrite inference for Qwen2-VL

app.py

@@ -1,133 +1,177 @@
 """
-app.py
-──────
-GharScan — Building Defect Inspector
-HuggingFace Space entry point.
-
-Gradio version:  >= 6.14.0  (strict requirement for gr.Server)
-Hardware:        ZeroGPU (free tier on HF Spaces)
-Model:           MiniCPM-V 2.0 fine-tuned (2.8B, OpenBMB)
-
-Architecture:
-  gr.Server() → custom HTML/CSS/JS frontend (Off-Brand badge)
-  @app.api("analyze_defect") → ZeroGPU inference endpoint
-  @app.get("/") → serves static/index.html
-
-Watch-Out 1 (ZeroGPU Cold Start):
-  @spaces.GPU is scoped only around the inference function call.
-  Model is globally cached; device management (cpu ↔ cuda) is handled
-  inside inference.py's run_gharscan_pipeline().
+app.py — GharScan HuggingFace Space
+Uses gr.Blocks (ZeroGPU-compatible). Custom CSS for Off-Brand badge.
 """
-
 import os
-import json
-from pathlib import Path
-
-import spaces                          # HF Spaces ZeroGPU decorator
-from gradio import Server
-from fastapi import Request
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
+import spaces
+import gradio as gr
 from PIL import Image
+from pathlib import Path
 
 from inference import run_gharscan_pipeline
 from agent_trace import AgentTraceLogger
 
-
-# ── Static paths ───────────────────────────────────────────────────────────────
-STATIC_DIR = Path(__file__).parent / "static"
-
-# ── Trace logger (initialized once at startup) ────────────────────────────────
 trace_logger = AgentTraceLogger()
 
-
-# ── App initialization ─────────────────────────────────────────────────────────
-app = Server()
-
-# Serve static assets (CSS, JS, icons) at /static/*
-app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
-
-
-# ── Page routes ───────────────────────────────────────────────────────────────
-@app.get("/", response_class=HTMLResponse)
-async def homepage(request: Request):
-    """Serve the custom GharScan frontend."""
-    html = (STATIC_DIR / "index.html").read_text(encoding="utf-8")
-    return HTMLResponse(content=html)
-
-
-@app.get("/health")
-async def health():
-    return {"status": "ok", "model": "gharscan-minicpm-v2-lora"}
-
-
-# ── Core inference API ────────────────────────────────────────────────────────
-# ── Core inference API ────────────────────────────────────────────────────────
+# ── ZeroGPU-compatible inference ──────────────────────────────────────────────
 @spaces.GPU
-def _gpu_inference(image: Image.Image, language: str) -> dict:
-    """Standalone GPU function — must be at module level for ZeroGPU detection."""
+def analyze_image(image: Image.Image, language: str) -> dict:
+    if image is None:
+        return {}
     session = trace_logger.start_trace()
     report  = run_gharscan_pipeline(image, language=language, trace_session=session)
     trace_logger.save_trace(session)
     return report
 
+def analyze_and_render(image, language):
+    if image is None:
+        return "<p style='color:#6b7280;padding:20px'>Please upload or take a photo first.</p>"
+    r = analyze_image(image, language)
+    if not r.get("analysis_ok"):
+        return f"<p style='color:#ef4444;padding:20px'>⚠️ {r.get('description','Analysis failed.')}</p>"
+    
+    color  = r.get("severity_color", "#6b7280")
+    sev    = r.get("severity", 0)
+    pct    = sev * 20
+
+    struct_html = ""
+    if r.get("is_structural"):
+        struct_html = f"""<div style='background:rgba(127,29,29,0.25);border:1px solid #7f1d1d;border-radius:8px;padding:12px;margin-bottom:12px;color:#fca5a5'>
+        ⚠️ <strong>STRUCTURAL RISK</strong> — {r.get("structural_reasoning","")}
+        </div>"""
+    else:
+        struct_html = "<div style='background:rgba(21,128,61,0.2);border:1px solid #166534;border-radius:8px;padding:10px;margin-bottom:12px;color:#86efac'>✅ Not Structural — No immediate safety risk</div>"
+
+    liability = ""
+    if r.get("show_liability_banner"):
+        liability = f"<div style='background:rgba(239,68,68,0.1);border:1px solid rgba(239,68,68,0.3);border-radius:8px;padding:12px;color:#fca5a5;font-size:12px;margin-top:10px'>⚠️ {r.get('liability_text','')}</div>"
+
+    disclaimer = ""
+    if r.get("disclaimer"):
+        disclaimer = f"<div style='border-left:3px solid #f59e0b;padding:10px 14px;font-size:12px;color:#9ca3af;margin-top:8px'>{r['disclaimer']}</div>"
+
+    monsoon = ""
+    if r.get("monsoon_risk"):
+        monsoon = "<div style='background:rgba(234,179,8,0.1);border:1px solid rgba(234,179,8,0.3);border-radius:6px;padding:10px;color:#fde68a;font-size:13px;margin-top:10px'>🌧️ <strong>Monsoon Risk:</strong> This defect worsens during heavy rainfall. Address before June.</div>"
+
+    return f"""
+    <div style='background:#181b20;border:1px solid #2a2f38;border-radius:14px;padding:20px;font-family:Inter,sans-serif;color:#e8eaed;max-width:600px'>
+        {struct_html}
+        <div style='display:flex;justify-content:space-between;align-items:flex-start;margin-bottom:14px'>
+            <div>
+                <div style='font-size:18px;font-weight:700'>{r.get("defect_display","")}</div>
+                <div style='font-size:11px;color:#8b9099;margin-top:3px'>{r.get("defect_type","").replace("_"," ").upper()}</div>
+            </div>
+            <div style='background:#20242b;border:2px solid {color};border-radius:10px;padding:8px 14px;text-align:center'>
+                <div style='font-size:22px;font-weight:700;color:{color}'>{sev}</div>
+                <div style='font-size:10px;color:#8b9099'>{r.get("severity_label","").upper()}</div>
+            </div>
+        </div>
+        <div style='background:#20242b;border-radius:4px;height:8px;margin-bottom:4px'>
+            <div style='width:{pct}%;height:8px;border-radius:4px;background:{color}'></div>
+        </div>
+        <div style='display:flex;justify-content:space-between;font-size:10px;color:#555d6b;margin-bottom:14px'>
+            <span>Cosmetic</span><span>Moderate</span><span>Critical</span>
+        </div>
+        <div style='height:1px;background:#1e2229;margin:12px 0'></div>
+        <div style='margin-bottom:10px'>
+            <div style='font-size:10px;color:#6fb3e0;font-family:monospace;letter-spacing:.06em'>WHAT IT IS</div>
+            <div style='font-size:14px;margin-top:4px'>{r.get("description","")}</div>
+        </div>
+        <div style='margin-bottom:10px'>
+            <div style='font-size:10px;color:#6fb3e0;font-family:monospace;letter-spacing:.06em'>WHY IT HAPPENS</div>
+            <div style='font-size:14px;margin-top:4px'>{r.get("primary_cause","")}</div>
+        </div>
+        <div style='height:1px;background:#1e2229;margin:12px 0'></div>
+        <div style='background:rgba(59,130,246,0.08);border:1px solid rgba(59,130,246,0.2);border-radius:10px;padding:12px;margin-bottom:10px'>
+            <div style='font-size:10px;color:#6fb3e0;font-family:monospace'>WHAT TO DO</div>
+            <div style='font-size:14px;font-weight:500;color:#93c5fd;margin-top:4px'>{r.get("immediate_action","")}</div>
+        </div>
+        <div style='margin-bottom:12px'>
+            <div style='font-size:10px;color:#6fb3e0;font-family:monospace'>WHEN TO ACT</div>
+            <div style='font-size:14px;font-weight:500;margin-top:4px'>{r.get("urgency_display","")}</div>
+        </div>
+        <div style='height:1px;background:#1e2229;margin:12px 0'></div>
+        <div style='background:#20242b;border-radius:10px;padding:14px'>
+            <div style='font-size:22px;font-weight:700;color:#22c55e'>{r.get("cost_range_inr","")}</div>
+            <div style='font-size:13px;color:#8b9099;margin-top:6px'>👷 {r.get("professional_display","")}</div>
+        </div>
+        {monsoon}
+        {liability}
+        {disclaimer}
+    </div>
+    """
 
-@app.api(name="analyze_defect")
-def analyze_defect(image_path: dict, language: str = "en") -> dict:
-    try:
-        img_path = image_path.get("path") or image_path.get("url")
-        if img_path is None:
-            return _error_response("No image path received.")
-        image = Image.open(img_path).convert("RGB")
-    except Exception as e:
-        return _error_response(f"Could not read image: {e}")
-
-    try:
-        return _gpu_inference(image, language)
-    except Exception as e:
-        return _error_response(f"Inference failed: {e}")
-
+# ── Custom CSS ─────────────────────────────────────────────────────────────────
+CSS = """
+body, .gradio-container { background: #0f1114 !important; color: #e8eaed !important; }
+.gradio-container { max-width: 700px !important; margin: 0 auto !important; }
+.gr-button-primary { background: linear-gradient(135deg,#2563eb,#1d4ed8) !important; border: none !important; }
+.gr-button-primary:hover { opacity: 0.9 !important; }
+footer { display: none !important; }
+#component-0 { padding: 20px !important; }
+.dark { --background-fill-primary: #181b20; --background-fill-secondary: #20242b; --border-color-primary: #2a2f38; --color-text-body: #e8eaed; }
+"""
 
-# ── Trace export endpoint (for Sharing is Caring badge) ──────────────────────
-@app.get("/flush-traces")
-async def flush_traces(request: Request):
-    """
-    Manually flush buffered traces to HF Hub.
-    Called automatically on Space shutdown or can be triggered manually.
-    """
-    api_key = request.headers.get("X-Admin-Key", "")
-    if api_key != os.getenv("ADMIN_KEY", "gharscan-admin"):
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-
-    trace_logger.force_flush()
-    return {"status": "flushed"}
-
-
-# ── Helper ─────────────────────────────────────────────────────────────────────
-def _error_response(msg: str) -> dict:
-    return {
-        "analysis_ok":          False,
-        "defect_type":          "no_defect",
-        "defect_display":       "Analysis Failed",
-        "description":          msg,
-        "severity":             0,
-        "severity_label":       "Unknown",
-        "severity_color":       "#6b7280",
-        "is_structural":        False,
-        "structural_reasoning": "",
-        "immediate_action":     "Please retake the photo with better lighting and a clearer view of the defect.",
-        "cost_range_inr":       "N/A",
-        "professional_display": "N/A",
-        "urgency_display":      "N/A",
-        "monsoon_risk":         False,
-        "show_liability_banner":False,
-        "liability_text":       None,
-        "requires_engineer":    False,
-        "disclaimer":           None,
-    }
-
-
-# ── Launch ─────────────────────────────────────────────────────────────────────
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
+# ── UI ──────────────────────────────────────────────────────────────────────────
+with gr.Blocks(
+    css=CSS,
+    title="GharScan — Building Defect Inspector",
+    theme=gr.themes.Base(
+        primary_hue="blue",
+        neutral_hue="slate",
+    )
+) as demo:
+    gr.HTML("""
+    <div style='display:flex;align-items:center;justify-content:space-between;
+                padding:14px 0;border-bottom:1px solid #2a2f38;margin-bottom:20px'>
+        <div style='display:flex;align-items:center;gap:10px'>
+            <span style='font-size:26px'>🏗️</span>
+            <div>
+                <div style='font-size:18px;font-weight:700;color:#e8eaed'>GharScan</div>
+                <div style='font-size:11px;color:#8b9099'>AI Building Defect Inspector · India</div>
+            </div>
+        </div>
+        <div style='background:#20242b;border:1px solid #2a2f38;border-radius:20px;padding:4px 12px;
+                    font-size:11px;color:#6fb3e0;font-family:monospace'>
+            ● Qwen2-VL-2B · 2.07B
+        </div>
+    </div>
+    """)
+
+    with gr.Row():
+        image_input = gr.Image(
+            sources=["upload", "webcam"],
+            type="pil",
+            label="📸 Take Photo or Upload",
+            height=300,
+        )
+
+    language = gr.Radio(
+        choices=["en", "hi"],
+        value="en",
+        label="Output language",
+    )
+
+    analyze_btn = gr.Button("🔍 Analyse Defect", variant="primary", size="lg")
+    report_output = gr.HTML(label="Inspection Report")
+
+    analyze_btn.click(
+        fn=analyze_and_render,
+        inputs=[image_input, language],
+        outputs=report_output,
+        api_name="analyze"
+    )
+
+    gr.HTML("""
+    <div style='text-align:center;padding:20px 0;font-size:11px;color:#555d6b;
+                border-top:1px solid #1e2229;margin-top:20px'>
+        <p>Qwen2-VL-2B fine-tuned on Indian building defects · No cloud APIs</p>
+        <p>🏗️ Built for <a href="https://huggingface.co/build-small-hackathon" 
+           style='color:#8b9099'>Build Small Hackathon 2026</a> · Backyard AI Track</p>
+        <p style='color:#374151'>GharScan is a triage aid, not a substitute for professional structural assessment.</p>
+    </div>
+    """)
+
+demo.queue()
+demo.launch()

inference.py

@@ -1,276 +1,131 @@
 """
-inference.py
-────────────
-GharScan VLM inference pipeline.
-
-Model:  MiniCPM-V 2.0 (2.8B) — fine-tuned LoRA adapter
-Engine: HuggingFace Transformers + ZeroGPU (HF Spaces)
-
-Watch-Out 1 (ZeroGPU Cold Start):
-  Model is loaded GLOBALLY at module level (CPU).
-  Inside @spaces.GPU, model.to("cuda") is called — GPU allocation is
-  only requested when actually needed. After inference, model.to("cpu")
-  frees the ZeroGPU allocation back to the pool.
+inference.py — GharScan Qwen2-VL-2B inference pipeline
 """
-
-import re
-import json
-import time
-import torch
+import re, json, time, torch
 from PIL import Image
 from loguru import logger
 from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
+from qwen_vl_utils import process_vision_info
 from cost_matrix import build_cost_response
 
-# ── Model Configuration ────────────────────────────────────────────────────────
-LORA_MODEL_ID = "ritvik360/gharscan-qwen2vl-lora"
-BASE_MODEL_ID  = "Qwen/Qwen2-VL-2B-Instruct"   # published after fine-tune
-MAX_NEW_TOKENS = 384
-TEMPERATURE    = 0.05     # Near-greedy for structured JSON output
+BASE_MODEL_ID  = "Qwen/Qwen2-VL-2B-Instruct"
+LORA_MODEL_ID  = "ritvik360/gharscan-qwen2vl-lora"
+MAX_NEW_TOKENS = 256
+TEMPERATURE    = 0.05
 
-
-# ── Global model references (loaded once, stays on CPU between calls) ─────────
 _model     = None
-_tokenizer = None
-
+_processor = None
 
 def _load_model_if_needed():
-    """
-    Lazy model loading. Called inside @spaces.GPU context.
-    First call: loads from HF Hub (~30s on cold boot).
-    Subsequent calls: instant (already in memory).
-    """
-    global _model, _tokenizer
-
+    global _model, _processor
     if _model is not None:
         return
-
-    logger.info(f"Loading GharScan model from {LORA_MODEL_ID} …")
+    logger.info(f"Loading {LORA_MODEL_ID} …")
     t0 = time.monotonic()
-
     try:
-        # Try fine-tuned LoRA model first
         from peft import PeftModel
-        base = AutoModel.from_pretrained(
-            BASE_MODEL_ID,
-            trust_remote_code=True,
-            torch_dtype=torch.bfloat16,
-        )
+        base = Qwen2VLForConditionalGeneration.from_pretrained(
+            BASE_MODEL_ID, torch_dtype=torch.bfloat16)
         _model = PeftModel.from_pretrained(base, LORA_MODEL_ID)
         _model = _model.merge_and_unload()
-        logger.info("Loaded fine-tuned LoRA adapter ✅")
-
+        logger.info("LoRA loaded ✅")
     except Exception as e:
-        logger.warning(f"LoRA load failed ({e}) — falling back to base model.")
-        _model = AutoModel.from_pretrained(
-            BASE_MODEL_ID,
-            trust_remote_code=True,
-            torch_dtype=torch.bfloat16,
-        )
-
-    _tokenizer = AutoTokenizer.from_pretrained(
-        BASE_MODEL_ID, trust_remote_code=True
-    )
+        logger.warning(f"LoRA failed ({e}) — using base model")
+        _model = Qwen2VLForConditionalGeneration.from_pretrained(
+            BASE_MODEL_ID, torch_dtype=torch.bfloat16)
+    _processor = AutoProcessor.from_pretrained(BASE_MODEL_ID)
     _model.eval()
     logger.info(f"Model ready in {time.monotonic()-t0:.1f}s")
 
-
-# ── Prompts ────────────────────────────────────────────────────────────────────
-_CLASSIFY_PROMPT = """You are GharScan, an expert Indian building inspector.
-Analyze this image of a building defect and return ONLY valid JSON — no other text.
-
-Required JSON schema:
-{
-  "defect_type": "<hairline_crack|settlement_crack|structural_crack|water_seepage|efflorescence|spalling|rebar_rust|plaster_delamination|no_defect>",
-  "description": "<25-word plain English description of exactly what you see>",
-  "primary_cause": "<one sentence cause in simple language>",
-  "monsoon_risk": <true|false>,
-  "confidence": <0.0-1.0>
-}"""
-
-_SEVERITY_PROMPT = """You are GharScan. The defect in this image is: {defect_type}.
-Assess the severity and return ONLY valid JSON — no other text.
-
-Required JSON schema:
-{{
-  "severity": <1|2|3|4|5>,
-  "is_structural": <true|false>,
-  "structural_reasoning": "<one sentence explanation>",
-  "immediate_action": "<specific actionable instruction in plain language>",
-  "urgency_timeline": "<next_renovation|within_6_months|within_1_month|this_week|immediately>",
-  "visible_width_estimate": "<hairline|<1mm|1-3mm|3-10mm|>10mm|not_applicable>"
-}}
-
-Severity scale:
-1 = Cosmetic only, no action needed soon
-2 = Minor, address at next renovation
-3 = Moderate, fix within 6 months
-4 = Serious, fix within 1 month, consider engineer
-5 = Critical, structural risk, immediate attention"""
-
-
-# ── Core inference helpers ───────────────────────────────────────────��────────
 def _call_vlm(image: Image.Image, prompt: str) -> dict:
-    """Single VLM forward pass → parsed JSON dict."""
-    msgs = [{"role": "user", "content": [image, prompt]}]
-
-    raw_output = _model.chat(
-        image=None,
-        msgs=msgs,
-        tokenizer=_tokenizer,
-        sampling=True,
-        temperature=TEMPERATURE,
-        max_new_tokens=MAX_NEW_TOKENS,
-    )
-
-    return _parse_json(raw_output)
-
-
-def _parse_json(text: str) -> dict:
-    """Robustly extract JSON from model output, even with surrounding text."""
-    text = text.strip()
-
-    # Try direct parse first
+    messages = [{"role": "user", "content": [
+        {"type": "image", "image": image},
+        {"type": "text",  "text":  prompt}
+    ]}]
+    text = _processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    image_inputs, _ = process_vision_info(messages)
+    inputs = _processor(text=[text], images=image_inputs, return_tensors="pt").to(_model.device)
+    with torch.no_grad():
+        out = _model.generate(**inputs, max_new_tokens=MAX_NEW_TOKENS,
+                              temperature=TEMPERATURE, do_sample=TEMPERATURE > 0)
+    gen = out[0][inputs["input_ids"].shape[1]:]
+    raw = _processor.decode(gen, skip_special_tokens=True).strip()
     try:
-        return json.loads(text)
-    except json.JSONDecodeError:
-        pass
-
-    # Extract JSON object from surrounding text
-    match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)?\}', text, re.DOTALL)
-    if match:
+        return json.loads(raw)
+    except Exception:
+        m = re.search(r'\{.*\}', raw, re.DOTALL)
         try:
-            return json.loads(match.group())
-        except json.JSONDecodeError:
-            pass
-
-    # Final fallback: return safe defaults
-    logger.warning(f"JSON parse failed on: {text[:200]}")
-    return {
-        "defect_type":  "no_defect",
-        "description":  "Could not analyze image clearly. Please retake with better lighting.",
-        "primary_cause": "Analysis inconclusive.",
-        "monsoon_risk": False,
-        "confidence":   0.0,
-    }
-
+            return json.loads(m.group()) if m else {}
+        except Exception:
+            return {}
 
-def _preprocess_image(image: Image.Image) -> Image.Image:
-    """Resize to MiniCPM-V optimal resolution without distorting aspect ratio."""
-    MAX_SIDE = 1344
-    w, h = image.size
-    if max(w, h) > MAX_SIDE:
-        scale = MAX_SIDE / max(w, h)
-        image = image.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
-    return image.convert("RGB")
-
-
-# ── Public pipeline function (called inside @spaces.GPU in app.py) ────────────
-def run_gharscan_pipeline(
-    image: Image.Image,
-    language: str = "en",
-    trace_session=None,
-) -> dict:
-    """
-    3-step agentic reasoning chain:
-      Step 1 → Defect classification
-      Step 2 → Severity + structural assessment
-      Step 3 → Cost lookup (deterministic, no model call)
+_CLASSIFY_PROMPT = """You are GharScan, an expert Indian building inspector.
+Analyze this image and return ONLY valid JSON:
+{"defect_type":"<hairline_crack|settlement_crack|structural_crack|water_seepage|efflorescence|spalling|rebar_rust|plaster_delamination|no_defect>","description":"<25-word description>","primary_cause":"<1 sentence>","monsoon_risk":<true|false>,"confidence":<0.0-1.0>}"""
+
+_SEVERITY_PROMPT = """You are GharScan. The defect is: {defect_type}.
+Return ONLY valid JSON:
+{{"severity":<1|2|3|4|5>,"is_structural":<bool>,"structural_reasoning":"<1 sentence>","immediate_action":"<specific action>","urgency_timeline":"<next_renovation|within_6_months|within_1_month|this_week|immediately>"}}"""
+
+_DEFECT_DISPLAY = {
+    "hairline_crack":"Hairline Plaster Crack","settlement_crack":"Settlement Crack",
+    "structural_crack":"Structural Crack","water_seepage":"Water Seepage / Damp Patch",
+    "efflorescence":"Efflorescence (Salt Deposits)","spalling":"Concrete Spalling",
+    "rebar_rust":"Rebar Rust Staining","plaster_delamination":"Plaster Delamination",
+    "no_defect":"No Defect Detected",
+}
 
-    Returns a fully structured report dict ready for the frontend.
-    """
-    # ── Ensure model is loaded (cold-start safe) ──────────────────────────────
+def run_gharscan_pipeline(image: Image.Image, language: str = "en", trace_session=None) -> dict:
     _load_model_if_needed()
-
-    # ── Move model to CUDA for this inference window ──────────────────────────
     _model.to("cuda")
-
     try:
-        image = _preprocess_image(image)
-
-        # ── Step 1: Classify defect ───────────────────────────────────────────
-        logger.info("Step 1: Classifying defect …")
-        classify_input  = {"prompt": _CLASSIFY_PROMPT}
-        classify_output = _call_vlm(image, _CLASSIFY_PROMPT)
+        image = image.convert("RGB").resize((448, 448))
 
-        defect_type = classify_output.get("defect_type", "no_defect")
-        logger.info(f"  → defect_type={defect_type}")
+        # Step 1: Classify
+        cls  = _call_vlm(image, _CLASSIFY_PROMPT)
+        defect_type = cls.get("defect_type", "no_defect")
 
         if trace_session:
-            trace_session.log_step("classify", classify_input, classify_output)
-
-        # ── Step 2: Severity assessment ───────────────────────────────────────
-        logger.info("Step 2: Assessing severity …")
-        severity_prompt = _SEVERITY_PROMPT.format(defect_type=defect_type)
-        severity_input  = {"defect_type": defect_type, "prompt": severity_prompt}
-        severity_output = _call_vlm(image, severity_prompt)
+            trace_session.log_step("classify", {}, cls)
 
-        severity = int(severity_output.get("severity", 2))
-        logger.info(f"  → severity={severity}, structural={severity_output.get('is_structural')}")
+        # Step 2: Severity
+        sev  = _call_vlm(image, _SEVERITY_PROMPT.format(defect_type=defect_type))
+        severity = max(1, min(5, int(sev.get("severity", 2))))
 
         if trace_session:
-            trace_session.log_step("severity", severity_input, severity_output)
+            trace_session.log_step("severity", {"defect_type": defect_type}, sev)
 
-        # ── Step 3: Cost lookup (deterministic) ───────────────────────────────
-        logger.info("Step 3: Cost lookup …")
-        cost_data   = build_cost_response(defect_type, severity)
-        cost_input  = {"defect_type": defect_type, "severity": severity}
+        # Step 3: Cost (deterministic)
+        cost = build_cost_response(defect_type, severity)
 
         if trace_session:
-            trace_session.log_step("cost", cost_input, cost_data)
+            trace_session.log_step("cost", {"defect_type": defect_type, "severity": severity}, cost)
 
-        # ── Assemble final report ─────────────────────────────────────────────
         report = {
-            # Classification
+            "analysis_ok":          defect_type != "no_defect",
             "defect_type":          defect_type,
-            "defect_display":       _DEFECT_DISPLAY_NAMES.get(defect_type, defect_type.replace("_", " ").title()),
-            "description":          classify_output.get("description", ""),
-            "primary_cause":        classify_output.get("primary_cause", ""),
-            "monsoon_risk":         classify_output.get("monsoon_risk", False),
-            "confidence":           round(float(classify_output.get("confidence", 0.7)), 2),
-            # Severity
+            "defect_display":       _DEFECT_DISPLAY.get(defect_type, defect_type.replace("_"," ").title()),
+            "description":          cls.get("description", ""),
+            "primary_cause":        cls.get("primary_cause", ""),
+            "monsoon_risk":         cls.get("monsoon_risk", False),
             "severity":             severity,
-            "severity_label":       cost_data["severity_label"],
-            "severity_color":       cost_data["severity_color"],
-            "is_structural":        severity_output.get("is_structural", False),
-            "structural_reasoning": severity_output.get("structural_reasoning", ""),
-            "immediate_action":     severity_output.get("immediate_action", ""),
-            "urgency_timeline":     severity_output.get("urgency_timeline", "within_6_months"),
-            "urgency_display":      cost_data["urgency_display"],
-            "visible_width":        severity_output.get("visible_width_estimate", "not_applicable"),
-            # Cost & professional
-            "cost_range_inr":       cost_data["cost_range_inr"],
-            "professional_type":    cost_data["professional_type"],
-            "professional_display": cost_data["professional_display"],
-            "requires_engineer":    cost_data["requires_engineer"],
-            "disclaimer":           cost_data["disclaimer"],
-            # Liability banner (Watch-Out 2: shown for severity >= 4)
-            "show_liability_banner":cost_data["show_liability_banner"],
-            "liability_text":       cost_data["liability_text"],
-            # Meta
-            "analysis_ok":          defect_type != "no_defect",
+            "severity_label":       cost["severity_label"],
+            "severity_color":       cost["severity_color"],
+            "is_structural":        sev.get("is_structural", False),
+            "structural_reasoning": sev.get("structural_reasoning", ""),
+            "immediate_action":     sev.get("immediate_action", ""),
+            "urgency_display":      cost["urgency_display"],
+            "cost_range_inr":       cost["cost_range_inr"],
+            "professional_display": cost["professional_display"],
+            "requires_engineer":    cost["requires_engineer"],
+            "disclaimer":           cost["disclaimer"],
+            "show_liability_banner":cost["show_liability_banner"],
+            "liability_text":       cost["liability_text"],
         }
-
         if trace_session:
             trace_session.finalize(report)
-
         return report
 
     finally:
-        # ── CRITICAL: Free ZeroGPU allocation after every call ────────────────
         _model.to("cpu")
-        torch.cuda.empty_cache()
-
-
-# ── Display name mapping ───────────────────────────────────────────────────────
-_DEFECT_DISPLAY_NAMES = {
-    "hairline_crack":       "Hairline Plaster Crack",
-    "settlement_crack":     "Settlement Crack (Diagonal)",
-    "structural_crack":     "Structural Crack",
-    "water_seepage":        "Water Seepage / Damp Patch",
-    "efflorescence":        "Efflorescence (Salt Deposits)",
-    "spalling":             "Concrete Spalling",
-    "rebar_rust":           "Rebar Rust Staining",
-    "plaster_delamination": "Plaster Delamination / Bubbling",
-    "no_defect":            "No Defect Detected",
-}
+        torch.cuda.empty_cache()

requirements.txt

@@ -1,12 +1,24 @@
+# gradio>=6.14.0
+# transformers==4.45.2
+# peft==0.10.0
+# torch==2.11.0 # UPDATED due to configuration error
+# Pillow>=10.0.0
+# huggingface_hub>=0.36.0
+# qwen-vl-utils>=0.0.8
+# loguru>=0.7.0
+# spaces>=0.28.0
+# fastapi>=0.111.0
+# uvicorn>=0.29.0
+# sentencepiece==0.1.99
+
+# GharScan HF Space requirements
 gradio>=6.14.0
 transformers==4.45.2
 peft==0.10.0
-torch==2.11.0 # UPDATED due to configuration error
+accelerate==0.27.0
+sentencepiece==0.1.99
 Pillow>=10.0.0
 huggingface_hub>=0.36.0
 qwen-vl-utils>=0.0.8
 loguru>=0.7.0
-spaces>=0.28.0
-fastapi>=0.111.0
-uvicorn>=0.29.0
-sentencepiece==0.1.99
+spaces>=0.28.0