Update app.py

app.py

@@ -1,156 +1,28 @@
 import gradio as gr
 import json
-from typing import Union, List, Dict, Any
 
-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
-    }
-    """
+def extract_bq_codes_from_json(json_str):
     try:
-        # Debugging: Log raw input
-        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 {"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):
-            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 {
-                "success": False,
-                "error": f"Unsupported input type: {type(input_data)}",
-                "input_type": str(type(input_data))
-            }
-        
-        # Phase 2: Validate data structure
-        if not isinstance(data, dict):
-            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
-                
-            for detail in project.get("projecttemplatedetails", []):
-                if not isinstance(detail, dict):
-                    continue
-                    
-                # 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)),
-            "count": len(codes)
-        }
-        
-    except Exception as 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"
-        }
+        data = json.loads(json_str)
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON"}
 
-# Create interface with improved examples
-examples = [
-    json.dumps({
-        "projecttemplates": [
-            {
-                "projecttemplatedetails": [
-                    {
-                        "bqcodelibrary": {
-                            "bqcode": "F10.01.01.01.00_block"
-                        }
-                    }
-                ]
-            }
-        ]
-    }),
-    {
-        "projecttemplates": [
-            {
-                "projecttemplatedetails": [
-                    {
-                        "bqcodelibrary": {
-                            "bqcode": "L20.01.00.01.00_doors"
-                        }
-                    }
-                ]
-            }
-        ]
-    }
-]
+    projecttemplates = data.get("projecttemplates", [])
+    codes = set()
+    for project in projecttemplates:
+        details = project.get("projecttemplatedetails", [])
+        for detail in details:
+            bqcode = detail.get("bqcodelibrary", {}).get("bqcode")
+            if bqcode:
+                codes.add(bqcode)
+    return list(codes)
 
 iface = gr.Interface(
-    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 (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",
-    theme="default"
+    fn=extract_bq_codes_from_json,
+    inputs=gr.Textbox(lines=10, label="JSON Input"),
+    outputs=gr.JSON(label="Extracted BQ Codes"),
+    title="BQ Code Extractor"
 )
 
-# Launch with production-ready settings
 if __name__ == "__main__":
-    iface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        debug=True,
-        show_error=True,
-        enable_queue=True
-    )
+    iface.launch()