Update app.py

app.py

@@ -1,141 +1,187 @@
 import gradio as gr
-from cear_model import CEARModel
 import pandas as pd
-import numpy as np # Used for consistency, though cear_model uses it
+from cear_model import CEARModel
 
-# Initialize Model
+# Instantiate the core model once
 cear_analyzer = CEARModel()
 
-# --- Configuration: Default Values ---
-DEFAULT_DATA = [
-    ["TikTok", 0],
-    ["Instagram", 0],
-    ["YouTube", 0],
-    ["X/Twitter", 0],
-    ["Reddit", 0],
-    ["Facebook", 0],
-    ["LinkedIn", 0]
-]
-
-def interpret_scores(c_score, a_risk, d_index):
+# Supported canonical platform names (must match what CEARModel expects)
+SUPPORTED_PLATFORMS = {
+    "tiktok",
+    "instagram",
+    "youtube",
+    "twitter",
+    "reddit",
+    "facebook",
+    "other",
+}
+
+# Simple alias map for common variations typed by users
+PLATFORM_ALIASES = {
+    "tik tok": "tiktok",
+    "tt": "tiktok",
+
+    "ig": "instagram",
+    "insta": "instagram",
+
+    "yt": "youtube",
+    "you tube": "youtube",
+
+    "x": "twitter",
+
+    "fb": "facebook",
+    "face book": "facebook",
+}
+
+
+def normalize_platform_name(name: str) -> str:
     """
-    Converts raw numbers into human-readable context with thresholds.
+    Normalize free-text platform names to the canonical set:
+    tiktok, instagram, youtube, twitter, reddit, facebook, other.
+    Unknown entries are mapped to 'other'.
     """
-    # --- 1. Interpret Algorithmic Risk (A-Risk) ---
-    # Thresholds: <150 (Low), 150-500 (Medium), >500 (High)
-    if a_risk < 150:
-        a_status = "🟢 Low Risk"
-        a_desc = "Your usage is within a safe range, likely minimizing algorithmic manipulation."
-    elif a_risk < 500:
-        a_status = "🟡 Moderate Risk"
-        a_desc = "You have significant exposure to algorithmic feeds. Be mindful of 'rabbit holes'."
-    else:
-        a_status = "🔴 High Risk"
-        a_desc = "Your attention is heavily concentrated in high-risk algorithmic environments."
-
-    # --- 2. Interpret Cultural Connectedness (C-Score) ---
-    # Thresholds: <2.0 (Disconnected), 2.0-5.0 (Connected), >5.0 (Very High)
-    if c_score < 2.0:
-        c_status = "⚪ Low Exposure"
-        c_desc = "You likely miss many viral trends, which protects focus but reduces cultural sync."
-    elif c_score < 5.0:
-        c_status = "🔵 Balanced Exposure"
-        c_desc = "You are plugged into main trends without being overwhelmed."
-    else:
-        c_status = "🟣 High Saturation"
-        c_desc = "You are extremely plugged in. Ensure this doesn't lead to information overload."
-
-    # --- 3. Interpret Diversity (D-Index) ---
-    # Thresholds: 1.0 (Monoculture) to >3.0 (Diverse)
-    if d_index < 1.5:
-        d_status = "⚠️ Concentrated"
-        d_desc = "Your time is spent almost entirely on one platform (Echo Chamber risk)."
-    elif d_index < 3.0:
-        d_status = "⚖️ Moderate Spread"
-        d_desc = "You split time across a few apps, offering some variety."
+    if not isinstance(name, str):
+        return "other"
+
+    cleaned = name.strip().lower()
+    if cleaned == "":
+        return ""
+
+    # Apply alias map
+    cleaned = PLATFORM_ALIASES.get(cleaned, cleaned)
+
+    # If not in supported set, bucket into 'other'
+    if cleaned not in SUPPORTED_PLATFORMS:
+        return "other"
+
+    return cleaned
+
+
+def analyze_user_data(input_table):
+    """
+    Gradio callback for CEAR.
+
+    input_table: list of lists from gr.Dataframe, e.g.
+        [
+          ["tiktok", 240],
+          ["instagram", 180],
+          ...
+        ]
+    Returns:
+        summary_markdown (str), efficiency_dataframe (pd.DataFrame)
+    """
+
+    # 1. Basic validation: something must be entered
+    if not input_table:
+        return "Please enter at least one platform and its weekly minutes.", pd.DataFrame()
+
+    # Convert raw table to DataFrame with fixed columns
+    df = pd.DataFrame(input_table, columns=["platform_name", "minutes_per_week"])
+
+    # Handle types and trim garbage rows
+    df["platform_name"] = df["platform_name"].astype(str)
+    df["minutes_per_week"] = pd.to_numeric(df["minutes_per_week"], errors="coerce")
+
+    # Drop rows where both are missing/empty
+    df = df.dropna(how="all")
+    if df.empty:
+        return "Please provide at least one platform with some minutes.", pd.DataFrame()
+
+    # Normalize names and minutes
+    df["platform_name"] = df["platform_name"].apply(normalize_platform_name)
+    df["minutes_per_week"] = df["minutes_per_week"].fillna(0).clip(lower=0)
+
+    # Drop rows with blank platform names
+    df = df[df["platform_name"] != ""]
+    if df.empty:
+        return "Please provide at least one platform with some minutes.", pd.DataFrame()
+
+    # 2. Call the core CEAR model
+    raw_scores = cear_analyzer.calculate_scores(df)
+
+    c = float(raw_scores.get("C_Score", 0.0))
+    a = float(raw_scores.get("A_Risk", 0.0))
+    d = float(raw_scores.get("D_Index", 0.0))
+    per_eff = raw_scores.get("Per_Platform_Efficiency", {})
+
+    # 3. Build a human-readable profile based on score bands
+    if c >= 70 and a >= 70:
+        profile = (
+            "You are highly plugged into online culture, but that comes with high "
+            "algorithmic risk and a heavy concentration of attention."
+        )
+    elif c >= 70 and a < 70:
+        profile = (
+            "You are well-connected to online culture without extreme algorithmic concentration. "
+            "Your usage is relatively efficient for staying up to date."
+        )
+    elif c < 40 and a >= 70:
+        profile = (
+            "You give a lot of attention to a narrow set of feeds without gaining much cultural exposure. "
+            "This is a classic high-risk, low-benefit pattern."
+        )
     else:
-        d_status = "🌐 High Diversity"
-        d_desc = "Your usage is well-distributed, reducing reliance on any single algorithm."
-
-    return {
-        "A_Status": a_status, "A_Desc": a_desc,
-        "C_Status": c_status, "C_Desc": c_desc,
-        "D_Status": d_status, "D_Desc": d_desc
-    }
-
-def analyze_user_data(input_table, variety_rating, fomo_rating):
-    # 1. Process Input
-    user_data_df = pd.DataFrame(input_table, columns=['platform_name', 'minutes_per_week'])
-    user_data_df['minutes_per_week'] = pd.to_numeric(user_data_df['minutes_per_week'], errors='coerce').fillna(0)
-
-    # 2. Run Model
-    raw_scores = cear_analyzer.calculate_scores(user_data_df)
-    
-    # 3. Get Interpretation
-    context = interpret_scores(raw_scores['C_Score'], raw_scores['A_Risk'], raw_scores['D_Index'])
-
-    # 4. Generate Rich Markdown Output
+        profile = (
+            "You currently have relatively low exposure to viral trends and also keep algorithmic risk low. "
+            "You are either deliberately detached or under-invested in highly trend-dense platforms."
+        )
+
     summary = f"""
-    ## 📊 Analysis Results
-
-    ### 1. Algorithmic Risk: {context['A_Status']} 
-    *Score: {raw_scores['A_Risk']:.0f}*
-    > {context['A_Desc']}
-
-    ### 2. Cultural Connectedness: {context['C_Status']}
-    *Score: {raw_scores['C_Score']:.2f}*
-    > {context['C_Desc']}
-
-    ### 3. Platform Diversity: {context['D_Status']}
-    *Index: {raw_scores['D_Index']:.2f}*
-    > {context['D_Desc']}
-    
-    ---
-    ### 🗣️ Self-Reported Context
-    * **Perceived Variety:** {variety_rating}/5
-    * **FOMO Intensity:** {fomo_rating}/5
-    """
+## 📊 CEAR Analysis Summary
+
+- **Cultural Connectedness Score (C-Score):** **{c:.2f}**
+- **Algorithmic Risk Score (A-Risk):** **{a:.2f}**
+- **Platform Diversity Index (D-Index):** **{d:.2f}**
+
+### 📝 Interpretation
 
-    return summary, pd.DataFrame(raw_scores['Per_Platform_Efficiency'])
-
-# --- Interface Definition (FIXED: theme removed) ---
-# Removed: theme=gr.themes.Soft()
-with gr.Blocks(title="CEAR Model") as demo: 
-    gr.Markdown("# 🧭 Cultural Exposure & Algorithmic Risk (CEAR) Model")
-    gr.Markdown("""
-    **Instructions:**
-    1. Enter your estimated **minutes per week** for each app (e.g., check your phone's Screen Time).
-    2. Adjust the sliders for your personal experience.
-    3. Click **Analyze** to see if your habits align with your goals.
-    """)
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            input_table = gr.Dataframe(
-                headers=['platform_name', 'minutes_per_week'],
-                value=DEFAULT_DATA,
-                datatype=["str", "number"],
-                row_count=7,
-                col_count=(2, 'fixed'),
-                label="Weekly Screen Time Inputs"
-            )
-        
-        with gr.Column(scale=1):
-            gr.Markdown("### 🧠 Self-Reflection")
-            variety_slider = gr.Slider(1, 5, step=1, value=3, label="Perceived Variety (1=Samey, 5=Diverse)")
-            fomo_slider = gr.Slider(1, 5, step=1, value=3, label="FOMO Intensity (1=None, 5=High)")
-            
-            analyze_btn = gr.Button("🔍 Analyze Risks", variant="primary")
-
-    with gr.Row():
-        output_text = gr.Markdown(label="Detailed Report")
-        output_table = gr.Dataframe(label="Cultural Efficiency (Score per Minute)")
-
-    analyze_btn.click(
-        fn=analyze_user_data,
-        inputs=[input_table, variety_slider, fomo_slider],
-        outputs=[output_text, output_table]
-    )
-
-    if __name__ == "__main__":
-        demo.launch(server_name="0.0.0.0", server_port=7860)
+{profile}
+
+The C-Score is based on a logarithmic transform of your weekly minutes, which bakes in diminishing returns as time increases.  
+A-Risk reflects your raw time investment and how concentrated it is on a small set of high-weight platforms.  
+D-Index captures how spread out your usage is across different platforms.
+""".strip()
+
+    # 4. Turn per-platform efficiency into a tidy table
+    if isinstance(per_eff, dict) and per_eff:
+        eff_df = pd.DataFrame(
+            sorted(per_eff.items(), key=lambda kv: kv[1], reverse=True),
+            columns=["platform", "efficiency_score"],
+        )
+    else:
+        eff_df = pd.DataFrame(columns=["platform", "efficiency_score"])
+
+    return summary, eff_df
+
+
+# ---------- Gradio app definition ----------
+
+demo = gr.Interface(
+    fn=analyze_user_data,
+    inputs=gr.Dataframe(
+        headers=["platform_name", "minutes_per_week"],
+        row_count=5,
+        col_count=(2, "fixed"),
+        label="Weekly screen time (by platform)",
+        value=[
+            ["tiktok", 240],
+            ["instagram", 180],
+            ["youtube", 120],
+            ["twitter", 60],
+            ["reddit", 90],
+        ],
+    ),
+    outputs=[
+        gr.Markdown(label="Score Results"),
+        gr.Dataframe(label="Per-platform Cultural Efficiency"),
+    ],
+    title="CEAR – Cultural Exposure & Algorithmic Risk Analyzer",
+    description=(
+        "Enter your weekly screen time per platform to estimate your cultural connectedness, "
+        "algorithmic risk, and per-platform efficiency."
+    ),
+)
+
+
+if __name__ == "__main__":
+    demo.launch()