Update app.py

app.py

@@ -1,40 +1,70 @@
 import gradio as gr
 import json
-from typing import Union
+from typing import Union, List, Dict, Any
 
-def extract_bq_codes_from_json(input_data: Union[str, dict]):
+def extract_bq_codes(input_data: Union[str, Dict]) -> Dict[str, Any]:
     """
     Robust JSON processor that handles:
     - Direct API calls (raw JSON)
     - Gradio API format ({"data": [...]})
     - String input from UI
+    
+    Returns:
+    {
+        "success": bool,
+        "codes": List[str],
+        "error": Optional[str],
+        "input_type": str
+    }
     """
     try:
         # Debugging: Log raw input
-        print(f"\n--- Received input ---\nType: {type(input_data)}\nContent: {input_data}\n")
+        print(f"\n--- Received input ---\nType: {type(input_data)}\nContent: {input_data[:200]}...\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"}
+                    return {"success": False, "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)
+            try:
+                data = json.loads(input_data)
+            except json.JSONDecodeError as e:
+                return {
+                    "success": False,
+                    "error": f"Invalid JSON string: {str(e)}",
+                    "input_type": str(type(input_data))
+                }
         else:
-            return {"error": f"Unsupported input type: {type(input_data)}"}
+            return {
+                "success": False,
+                "error": f"Unsupported input type: {type(input_data)}",
+                "input_type": str(type(input_data))
+            }
         
-        # Debugging: Log parsed data
-        print(f"--- Parsed data ---\n{data}\n")
-        
-        # Phase 2: Process data
+        # Phase 2: Validate data structure
         if not isinstance(data, dict):
-            return {"error": f"Expected dictionary, got {type(data)}"}
+            return {
+                "success": False,
+                "error": f"Expected dictionary, got {type(data)}",
+                "input_type": str(type(input_data))
+            }
+        
+        if "projecttemplates" not in data:
+            return {
+                "success": False,
+                "error": "Missing 'projecttemplates' in JSON",
+                "input_type": str(type(input_data))
+            }
         
+        # Phase 3: Process data
         codes = set()
+        
+        # Safely navigate through the complex nested structure
         for project in data.get("projecttemplates", []):
             if not isinstance(project, dict):
                 continue
@@ -43,40 +73,84 @@ def extract_bq_codes_from_json(input_data: Union[str, dict]):
                 if not isinstance(detail, dict):
                     continue
                     
-                bqcode = detail.get("bqcodelibrary", {}).get("bqcode")
-                if bqcode and isinstance(bqcode, str):
-                    codes.add(bqcode)
+                # Handle potential None values in bqcodelibrary
+                bqcode_lib = detail.get("bqcodelibrary")
+                if bqcode_lib and isinstance(bqcode_lib, dict):
+                    bqcode = bqcode_lib.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()
+            "count": len(codes)
         }
         
-    except json.JSONDecodeError as e:
-        return {"error": f"Invalid JSON: {str(e)}", "input": str(input_data)}
     except Exception as e:
-        return {"error": f"Unexpected error: {str(e)}", "type": str(type(e))}
+        return {
+            "success": False,
+            "error": f"Unexpected error: {str(e)}",
+            "type": str(type(e)),
+            "input_type": str(type(input_data)) if 'input_data' in locals() else "unknown"
+        }
 
-# Example data for the interface
+# Create interface with improved examples
 examples = [
-    json.dumps({"projecttemplates": [{"projecttemplatedetails": [{"bqcodelibrary": {"bqcode": "BQ001"}}]}]}),
-    {"projecttemplates": [{"projecttemplatedetails": [{"bqcodelibrary": {"bqcode": "BQ002"}}]}]}
+    json.dumps({
+        "projecttemplates": [
+            {
+                "projecttemplatedetails": [
+                    {
+                        "bqcodelibrary": {
+                            "bqcode": "F10.01.01.01.00_block"
+                        }
+                    }
+                ]
+            }
+        ]
+    }),
+    {
+        "projecttemplates": [
+            {
+                "projecttemplatedetails": [
+                    {
+                        "bqcodelibrary": {
+                            "bqcode": "L20.01.00.01.00_doors"
+                        }
+                    }
+                ]
+            }
+        ]
+    }
 ]
 
 iface = gr.Interface(
-    fn=extract_bq_codes_from_json,
-    inputs=gr.Textbox(lines=10, label="JSON Input", placeholder='Paste JSON here or use examples below...'),
+    fn=extract_bq_codes,
+    inputs=gr.Textbox(
+        lines=15,
+        label="JSON Input",
+        placeholder='Paste your complex JSON here...',
+        max_lines=25
+    ),
     outputs=gr.JSON(label="Extraction Results"),
     examples=examples,
-    title="BQ Code Extractor (Robust Version)",
-    description="""Extracts BQ codes from JSON structures. Accepts:
+    title="BQ Code Extractor (Enterprise Version)",
+    description="""Safely extracts BQ codes from complex construction project JSON structures.
+    Accepts:
     - Raw JSON strings
     - JSON objects
     - Gradio API format""",
-    allow_flagging="never"
+    allow_flagging="never",
+    theme="default"
 )
 
+# Launch with production-ready settings
 if __name__ == "__main__":
-    iface.launch(debug=True, show_error=True)
+    iface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        debug=True,
+        show_error=True,
+        enable_queue=True
+    )