Update app.py

app.py

@@ -1,123 +1,32 @@
 import gradio as gr
-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}
+from ai_text_detector_valid_final import detect_text
 
+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 the configured detectors  
-        and return a final average probability plus detailed model outputs.
+        Paste any text below and our system will analyze it using **3 different models**  
+        and generate a final average probability.  
         """
     )
 
-    with gr.Row():
-        with gr.Column(scale=2):
-            user_input = gr.Textbox(
-                label="✍️ Enter Text",
-                placeholder="Paste text here...",
-                lines=10
-            )
-            analyze_btn = gr.Button("🚀 Run Detection", variant="primary")
-
-        with gr.Column(scale=1):
             final_output = gr.JSON(label="📊 Final Results")
 
     with gr.Accordion("🔬 Detailed Model Results", open=False):
-        model_output = gr.JSON(label="All Model Scores / Raw Output")
+        model_output = gr.JSON(label="All Model Scores")
 
-    def wrapped_run(user_text):
-        # returns (final_result, detailed_result)
-        return run_analysis(user_text)
+    def run_analysis(user_text):
+        results = analyze_text(user_text)
+        return results, results  # send to both JSON outputs
 
     analyze_btn.click(
-        fn=wrapped_run,
+        fn=run_analysis,
         inputs=user_input,
         outputs=[final_output, model_output]
     )
 
-# Launch the demo (keeps consistent with Hugging Face Spaces / local run)
+
 demo.launch()