Update app.py

app.py

@@ -21,8 +21,11 @@ SUPPORTED_VIDEOS = [
     ("00943", "ADAPT"), ("00414", "ABOUT"), ("00376", "ABLE"), ("00832", "ACROSS"), 
     ("00627", "ACCIDENT"), ("00592", "ACCEPT"), ("00625", "ACCIDENT"), ("01012", "ADDRESS"), 
     ("00849", "ACT"), ("00663", "ACCOMPLISH"), ("00853", "ACTION"), ("00967", "ADD"), 
-    ("00692", "ACCOUNTANT"), ("00583", "ACCENT")
+    ("00692", "ACCOUNTANT"), ("00583", "ACCENT"), ("00341", "ACROSS"), ("00378", "ADDRESS"),
+    ("00433", "ADJECTIVE"), ("00384", "ACTOR"), ("00381", "ACTOR"), ("00377", "ACCIDENT"),
+    ("00382", "ACTOR"), ("00378", "ADDRESS")
 ]
+SUPPORTED_GLOSSES_UNIQUE = sorted(list(set([g for _, g in SUPPORTED_VIDEOS])))
 dataset_options = {f"{g} (Sample {vid})": f"data/data_0/{vid.zfill(5)}.mp4" for vid, g in SUPPORTED_VIDEOS}
 
 # 3. INITIALIZE CLIENT
@@ -33,50 +36,74 @@ except Exception as e:
 
 # 4. LOGIC FUNCTIONS
 def update_video_display(selection):
-    if not selection: return None
+    if not selection: return None, None
     try:
+        gloss_gt = selection.split('(')[0].strip()
         hf_path = dataset_options[selection]
         cache_path = hf_hub_download(repo_id="Voxel51/WLASL", filename=hf_path, repo_type="dataset")
         local_path = os.path.join("/tmp", os.path.basename(hf_path))
         shutil.copy(cache_path, local_path)
-        return local_path
+        return local_path, f"Ground Truth: {gloss_gt}"
     except:
-        return None
+        return None, "Error loading sample"
 
 def run_omnisign_vlm(video_path):
-    if not video_path: return "No Input"
-    if not client: return "Engine Offline"
+    if not video_path: return {"⚠️ No Input": 0.0}
+    if not client: return {"⚠️ Engine Offline": 0.0}
 
     try:
-        # PURE INQUIRY: Capture the raw response from the Private Space
-        raw_result = client.predict(
+        # Request from Private Space
+        result = client.predict(
             handle_file(video_path),
             api_name="/predict_sign"
         )
         
-        # RETURN RAW DATA FOR INSPECTION
-        # This will show the type and the content (e.g., <class 'tuple'> : ({"ADAPT": 0.9},))
-        return f"TYPE: {type(raw_result)}\n\nCONTENT: {raw_result}"
+        # --- PARSING LOGIC ---
+        # The Private Space returns: {'label': 'X', 'confidences': [{'label': 'X', 'confidence': 0.9}]}
+        # We need to extract the data for the gr.Label component
+        if isinstance(result, dict) and "confidences" in result:
+            return {item['label']: item['confidence'] for item in result["confidences"]}
+        
+        return result
 
     except Exception as e:
-        return f"API ERROR: {str(e)}"
+        return {f"❌ Neural Analysis Error": 0.0}
 
-# 5. UI DESIGN
+# 5. UI DESIGN (PROFESSIONAL PITCH)
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🧠 Diagnostic Mode: OmniSign VLM")
+    gr.Markdown(f"""
+    # 🧠 OmniSign VLM: Neural Universal SL Protocol
+    ### **Powered by Multimodal Temporal Reasoning**
+
+    This demonstration showcases a revolutionary **Structural Protocol** for sign language interpretation, powered by a Large Vision-Language Model (VLM) core. Our protocol focuses on extracting pure **kinetic semantics** from video streams.
+
+    **The OmniSign Protocol's Unique Advantages:**
+
+    1.  **Motion-Oriented Core:** The system is designed to analyze the physics and trajectory of movement, rendering the prediction robust against variations in the signer, lighting, or background environment.
+    2.  **Lexical Agnosticism:** The underlying VLM protocol is language-independent. It can be instantly updated to recognize new signs or expanded to include any sign language (e.g., ASL, BSL, LSF) with unparalleled efficiency.
+    3.  **Future-Proof Scalability:** New vocabulary can be integrated into the system's lexicon instantly, bypassing traditional, time-consuming retraining cycles.
+
+    ---
+    *Notice: This is a structural proof-of-concept. The current engine is unoptimized and operates on a limited vocabulary subset to showcase the protocol's power.*
+    """)
     
     with gr.Row():
         with gr.Column():
-            video_comp = gr.Video(label="Input Buffer", autoplay=True)
-            dataset_drop = gr.Dropdown(choices=[""] + sorted(list(dataset_options.keys())), label="Select Sample")
-            run_btn = gr.Button("Analyze Raw Response", variant="primary")
+            gr.Markdown("### 🎦 1. Input Source")
+            video_comp = gr.Video(label="Video Buffer", autoplay=True)
+            dataset_drop = gr.Dropdown(choices=[""] + sorted(list(dataset_options.keys())), label="Browse WLASL Archive")
+            gt_output = gr.Textbox(label="Ground Truth Reference", interactive=False)
+            run_btn = gr.Button("🚀 Execute Neural Analysis", variant="primary")
             
         with gr.Column():
-            # CHANGED: Using Textbox instead of Label to see the raw data structure
-            raw_output_box = gr.Textbox(label="Raw Data Received from Private Space", lines=10)
+            gr.Markdown("### 📊 2. VLM Perception Result")
+            output_label = gr.Label(num_top_classes=3, label="Confidence Score")
+            
+            with gr.Accordion("🔍 Supported Vocabulary List", open=True):
+                gr.Markdown(", ".join(SUPPORTED_GLOSSES_UNIQUE))
 
-    dataset_drop.change(fn=update_video_display, inputs=dataset_drop, outputs=video_comp)
-    run_btn.click(fn=run_omnisign_vlm, inputs=video_comp, outputs=raw_output_box)
+    dataset_drop.change(fn=update_video_display, inputs=dataset_drop, outputs=[video_comp, gt_output])
+    run_btn.click(fn=run_omnisign_vlm, inputs=video_comp, outputs=output_label)
 
 if __name__ == "__main__":
     demo.launch(ssr_mode=False)