Update app.py

app.py

@@ -1,59 +1,82 @@
 import gradio as gr
 import json
+from typing import Union
 
-def extract_bq_codes_from_json(input_data):
-    # Debug: Print raw input
-    print("Raw input received:", type(input_data), input_data)
-    
-    # Handle all possible input formats
-    if isinstance(input_data, dict):
-        if "data" in input_data:  # Gradio API format
-            try:
-                if isinstance(input_data["data"][0], str):
-                    data = json.loads(input_data["data"][0])
-                else:
-                    data = input_data["data"][0]
-            except Exception as e:
-                print("API format parse error:", e)
-                return {"error": f"Invalid API format: {str(e)}"}
-        else:  # Raw JSON format
-            data = input_data
-    elif isinstance(input_data, str):  # Direct text input
-        try:
-            data = json.loads(input_data)
-        except Exception as e:
-            print("String parse error:", e)
-            return {"error": f"Invalid JSON string: {str(e)}"}
-    else:
-        return {"error": "Input must be JSON string or object"}
-    
-    # Extraction logic with defensive programming
+def extract_bq_codes_from_json(input_data: Union[str, dict]):
+    """
+    Robust JSON processor that handles:
+    - Direct API calls (raw JSON)
+    - Gradio API format ({"data": [...]})
+    - String input from UI
+    """
     try:
+        # Debugging: Log raw input
+        print(f"\n--- Received input ---\nType: {type(input_data)}\nContent: {input_data}\n")
+        
+        # Phase 1: Parse input
+        if isinstance(input_data, dict):
+            if "data" in input_data:  # Gradio API format
+                if not input_data["data"]:
+                    return {"error": "Empty data array"}
+                content = input_data["data"][0]
+                data = json.loads(content) if isinstance(content, str) else content
+            else:  # Raw JSON format
+                data = input_data
+        elif isinstance(input_data, str):
+            data = json.loads(input_data)
+        else:
+            return {"error": f"Unsupported input type: {type(input_data)}"}
+        
+        # Debugging: Log parsed data
+        print(f"--- Parsed data ---\n{data}\n")
+        
+        # Phase 2: Process data
+        if not isinstance(data, dict):
+            return {"error": f"Expected dictionary, got {type(data)}"}
+        
         codes = set()
         for project in data.get("projecttemplates", []):
+            if not isinstance(project, dict):
+                continue
+                
             for detail in project.get("projecttemplatedetails", []):
-                if isinstance(detail, dict):
-                    bqcode = detail.get("bqcodelibrary", {}).get("bqcode")
-                    if bqcode:
-                        codes.add(bqcode)
-        return {"success": True, "codes": list(codes)}
+                if not isinstance(detail, dict):
+                    continue
+                    
+                bqcode = detail.get("bqcodelibrary", {}).get("bqcode")
+                if bqcode and isinstance(bqcode, str):
+                    codes.add(bqcode)
+        
+        return {
+            "success": True,
+            "codes": sorted(list(codes)),
+            "input_type": str(type(input_data)),
+            "processed_at": gr.utils.get_current_time()
+        }
+        
+    except json.JSONDecodeError as e:
+        return {"error": f"Invalid JSON: {str(e)}", "input": str(input_data)}
     except Exception as e:
-        return {"error": f"Processing error: {str(e)}", "received_data": data}
+        return {"error": f"Unexpected error: {str(e)}", "type": str(type(e))}
 
-# Create interface with explicit examples
+# Example data for the interface
 examples = [
-    {'projecttemplates': [{'projecttemplatedetails': [{'bqcodelibrary': {'bqcode': 'BQ123'}}]}]},
-    '{"projecttemplates":[{"projecttemplatedetails":[{"bqcodelibrary":{"bqcode":"BQ456"}}]}]'
+    json.dumps({"projecttemplates": [{"projecttemplatedetails": [{"bqcodelibrary": {"bqcode": "BQ001"}}]}]}),
+    {"projecttemplates": [{"projecttemplatedetails": [{"bqcodelibrary": {"bqcode": "BQ002"}}]}]}
 ]
 
 iface = gr.Interface(
     fn=extract_bq_codes_from_json,
-    inputs=gr.Textbox(lines=10, placeholder="Paste JSON here...", label="JSON Input"),
-    outputs=gr.JSON(label="Results"),
+    inputs=gr.Textbox(lines=10, label="JSON Input", placeholder='Paste JSON here or use examples below...'),
+    outputs=gr.JSON(label="Extraction Results"),
     examples=examples,
-    title="BQ Code Extractor",
-    description="Extracts BQ codes from JSON. Accepts both raw JSON objects and strings."
+    title="BQ Code Extractor (Robust Version)",
+    description="""Extracts BQ codes from JSON structures. Accepts:
+    - Raw JSON strings
+    - JSON objects
+    - Gradio API format""",
+    allow_flagging="never"
 )
 
 if __name__ == "__main__":
-    iface.launch(debug=True)
+    iface.launch(debug=True, show_error=True)