Update app.py

app.py

@@ -5,61 +5,62 @@ import gradio as gr
 from gradio_client import Client, handle_file
 from huggingface_hub import hf_hub_download, list_repo_files
 
-# 1. SECRETS & BACKEND LINK
+# 1. SECRETS
 HF_TOKEN = os.environ.get("HF_TOKEN")
 PRIVATE_SPACE = "st192011/ASL-VLS-Private"
 
-try:
-    api_client = Client(PRIVATE_SPACE, hf_token=HF_TOKEN)
-except Exception as e:
-    print(f"Connection Error: {e}")
-    api_client = None
-
-# 2. LOAD SUPPORTED GLOSSARY
-# We load the JSON just to get the list of words for the UI
+# 2. LOAD SUPPORTED GLOSSARY (UI only)
 KB_FILE = "asl_rag_knowledge_base.json"
 supported_glosses = []
 if os.path.exists(KB_FILE):
-    with open(KB_FILE, 'r') as f:
-        kb_data = json.load(f)
-    supported_glosses = sorted(list(set([item['gloss'].upper() for item in kb_data])))
+    try:
+        with open(KB_FILE, 'r') as f:
+            kb_data = json.load(f)
+        supported_glosses = sorted(list(set([item['gloss'].upper() for item in kb_data])))
+    except:
+        supported_glosses = ["Error loading glossary"]
 
 # 3. DATASET DISCOVERY
 print("Syncing with WLASL Archive...")
-all_files = list_repo_files(repo_id="Voxel51/WLASL", repo_type="dataset")
-# Filter for data_0 videos only
-data_0_mp4s = [f for f in all_files if f.startswith("data/data_0/") and f.endswith(".mp4")]
-dataset_choices = {os.path.basename(f): f for f in data_0_mp4s}
+try:
+    all_files = list_repo_files(repo_id="Voxel51/WLASL", repo_type="dataset")
+    data_0_mp4s = [f for f in all_files if f.startswith("data/data_0/") and f.endswith(".mp4")]
+    dataset_choices = {os.path.basename(f): f for f in data_0_mp4s}
+except:
+    dataset_choices = {}
 
 # 4. LOGIC FUNCTIONS
 def update_video_display(selection):
-    """Downloads the file and moves it to a Gradio-accessible directory"""
     if not selection: return None
-    
-    hf_path = dataset_choices[selection]
-    # Download from HF cache
-    cache_path = hf_hub_download(repo_id="Voxel51/WLASL", filename=hf_path, repo_type="dataset")
-    
-    # FIX: Copy to /tmp to bypass Gradio InvalidPathError
-    local_path = os.path.join("/tmp", selection)
-    shutil.copy(cache_path, local_path)
-    
-    return local_path
+    try:
+        hf_path = dataset_choices[selection]
+        cache_path = hf_hub_download(repo_id="Voxel51/WLASL", filename=hf_path, repo_type="dataset")
+        local_path = os.path.join("/tmp", selection)
+        shutil.copy(cache_path, local_path)
+        return local_path
+    except Exception as e:
+        print(f"File Error: {e}")
+        return None
 
 def run_omnisign_analysis(video):
-    """Sends the active video (sample or user-recorded) to the private VLM engine"""
-    if not video: return {"Error: No Video Detected": 0.0}
-    if not api_client: return {"Error: Neural Backend Offline": 0.0}
+    if not video: 
+        return {"Error": "No video input detected."}
+    
+    # LAZY LOADING: Initialize client here to avoid startup crashes
+    try:
+        api_client = Client(PRIVATE_SPACE, hf_token=HF_TOKEN)
+    except Exception as e:
+        return {"Connection Error": f"Could not reach private engine. Please ensure it is running. ({str(e)})"}
     
     try:
-        # Use handle_file to safely stream the video to the private space
+        # Pass the video file to the private space
         result = api_client.predict(
             video_file=handle_file(video),
             api_name="/predict"
         )
         return result
     except Exception as e:
-        return {f"Neural Engine Error: {str(e)}": 0.0}
+        return {"Processing Error": f"The neural engine timed out or failed: {str(e)}"}
 
 # 5. UI DESIGN (PITCH FORMAT)
 with gr.Blocks(theme="glass") as demo:
@@ -67,30 +68,29 @@ with gr.Blocks(theme="glass") as demo:
     # 🧠 OmniSign VLM
     ### **Universal Neural Sign Language Protocol**
     
-    This demonstration introduces a revolutionary **VLM-based architecture** for sign language interpretation. 
-    Unlike traditional models that are prone to overfitting, the OmniSign protocol leverages **Temporal Neural Transduction** to generalize across all environments and signers instantly.
+    OmniSign is a proprietary architecture for sign language interpretation powered by **Large Vision-Language Models (VLM)**. 
+    Our **Temporal Neural Transduction** protocol enables zero-shot generalization across signers and environments.
     
-    **Proprietary Core Advantages:**
-    *   **Universal Generalization:** Robust performance in any environment, lighting, or camera angle.
-    *   **Instant Lexical Scaling:** The protocol allows for adding any new sign language word instantly without retraining.
-    *   **Person-Agnostic Reasoning:** The system analyzes movement logic rather than memorizing specific signers.
+    **Core Advantages:**
+    *   **Universal Generalization:** High performance regardless of lighting, background, or camera.
+    *   **Instant Lexical Scaling:** Vocabulary updates in seconds via semantic indexing.
+    *   **Person-Agnostic:** Analyzes movement logic rather than memorizing individual signers.
     
     ---
-    *Notice: This is a structural demonstration. The current engine is non-optimized and operates on a limited vocabulary subset.*
+    *Notice: This is a structural demonstration. The engine is currently non-optimized and operates on a limited vocabulary.*
     """)
     
     with gr.Row():
         with gr.Column():
             gr.Markdown("### 🎦 1. Input Interface")
-            # This player handles BOTH uploads and the samples from the dropdown
             video_display = gr.Video(label="Neural Input Buffer")
             
             dataset_drop = gr.Dropdown(
                 choices=[""] + sorted(list(dataset_choices.keys())), 
-                label="Explore WLASL data_0 Samples"
+                label="Explore WLASL data_0 Samples (Verified Support)",
+                value=""
             )
             
-            gr.Markdown("*Tip: Select a sample above to watch it, then sign it yourself or analyze the sample.*")
             run_btn = gr.Button("🚀 Execute Neural Analysis", variant="primary")
             
         with gr.Column():
@@ -98,12 +98,11 @@ with gr.Blocks(theme="glass") as demo:
             output_label = gr.Label(num_top_classes=3, label="Neural Confidence Score")
             
             with gr.Accordion("🔍 Supported Glossary", open=True):
-                gr.Markdown(f"**The system currently recognizes {len(supported_glosses)} signs:**")
                 gr.Markdown(", ".join(supported_glosses))
 
-    # Event Mapping
     dataset_drop.change(fn=update_video_display, inputs=dataset_drop, outputs=video_display)
     run_btn.click(fn=run_omnisign_analysis, inputs=video_display, outputs=output_label)
 
 if __name__ == "__main__":
-    demo.launch()
+    # Set ssr_mode=False to improve stability on Hugging Face
+    demo.launch(ssr_mode=False)