Update app.py

app.py

@@ -1,15 +1,96 @@
 import gradio as gr
-from ai_text_detector_valid_final import detect_text
+from ai_text_detector_valid_final import detect_text  # your detection function
+
+def analyze_text(user_text: str):
+    """
+    Wrapper around your detection function.
+    We assume detect_text returns one of:
+      - a dict of {model_name: score, ...}
+      - a dict with mixed info
+      - a single label/string
+    """
+    # Protect against empty input
+    if not user_text or not user_text.strip():
+        return {"error": "No text provided."}
+
+    try:
+        return detect_text(user_text)
+    except Exception as e:
+        # Graceful fallback if your detection code raises
+        return {"error": f"Detection failed: {e}"}
+
+def run_analysis(user_text: str):
+    raw = analyze_text(user_text)
+
+    # Normalize outputs into:
+    # final_result: dict for the "Final Results" JSON
+    # detailed: dict for the "All Model Scores" JSON
+    final_result = {}
+    detailed = {}
+
+    # If detect_text returned an error or string, pass it through
+    if isinstance(raw, str):
+        final_result = {"Final Prediction": raw}
+        detailed = {"result": raw}
+        return final_result, detailed
+
+    if isinstance(raw, dict):
+        # If there's an explicit 'final' key, use it
+        if "final" in raw or "final_prediction" in raw or "prediction" in raw:
+            # Normalize keys to a friendly output
+            final_key = raw.get("final") or raw.get("final_prediction") or raw.get("prediction")
+            final_result = {"Final Prediction": final_key}
+            detailed = raw
+            return final_result, detailed
+
+        # Extract numeric model scores if present (floats/ints in [0,1] or 0-100)
+        numeric_scores = {}
+        non_numeric = {}
+        for k, v in raw.items():
+            if isinstance(v, (int, float)):
+                numeric_scores[k] = float(v)
+            else:
+                non_numeric[k] = v
+
+        if numeric_scores:
+            # normalize if scores look like 0-100 -> convert to 0-1
+            vals = list(numeric_scores.values())
+            max_val = max(vals)
+            if max_val > 1.01:  # probably 0-100 scale
+                numeric_scores = {k: v / 100.0 for k, v in numeric_scores.items()}
+
+            avg_prob = sum(numeric_scores.values()) / len(numeric_scores)
+            label = "Likely AI" if avg_prob >= 0.5 else "Likely Human"
+
+            final_result = {
+                "Final Prediction": label,
+                "Average Probability (0-1)": round(avg_prob, 4),
+                "Model Count": len(numeric_scores)
+            }
+
+            detailed = {
+                "model_scores": {k: round(v, 4) for k, v in numeric_scores.items()}
+            }
+            if non_numeric:
+                detailed["other_info"] = non_numeric
+
+            return final_result, detailed
+
+        # If no numeric scores, but we got a structured dict, just show it
+        final_result = {"Final Prediction (raw)": "See detailed results"}
+        detailed = raw
+        return final_result, detailed
+
+    # Fallback: unknown return type
+    return {"Final Prediction": str(raw)}, {"raw": raw}
 
-def analyze_text(user_text):
-    return detect_text(user_text)
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         """
         # 🔍 AI vs Human Text Detector  
-        Paste any text below and our system will analyze it using **3 different models**  
-        and generate a final average probability.  
+        Paste any text below and our system will analyze it using the configured detectors  
+        and return a final average probability plus detailed model outputs.
         """
     )
 
@@ -26,16 +107,17 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             final_output = gr.JSON(label="📊 Final Results")
 
     with gr.Accordion("🔬 Detailed Model Results", open=False):
-        model_output = gr.JSON(label="All Model Scores")
+        model_output = gr.JSON(label="All Model Scores / Raw Output")
 
-    def run_analysis(user_text):
-        results = analyze_text(user_text)
-        return results, results  # send to both JSON outputs
+    def wrapped_run(user_text):
+        # returns (final_result, detailed_result)
+        return run_analysis(user_text)
 
     analyze_btn.click(
-        fn=run_analysis,
+        fn=wrapped_run,
         inputs=user_input,
         outputs=[final_output, model_output]
     )
 
+# Launch the demo (keeps consistent with Hugging Face Spaces / local run)
 demo.launch()