Update app.py

app.py

@@ -4,131 +4,79 @@ import numpy as np
 
 from cear_model import CEARModel
 
-# Instantiate the core model once
 cear_analyzer = CEARModel()
 
-# 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:
+def build_dataframe_from_inputs(values):
     """
-    Normalize free-text platform names to the canonical set:
-    tiktok, instagram, youtube, twitter, reddit, facebook, other.
-    Unknown entries are mapped to 'other'.
+    values: list of tuples [(platform_name, minutes, variety), ...]
+    Returns: DataFrame with platform_name, minutes_per_week, variety_score
     """
-    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.
+    rows = []
+    for name, minutes, variety in values:
+        minutes = 0.0 if minutes is None else float(minutes)
+        variety = None if variety is None else float(variety)
+        # Keep row if there is any meaningful input
+        if minutes > 0 or (variety is not None and not np.isnan(variety)):
+            rows.append(
+                {
+                    "platform_name": name,
+                    "minutes_per_week": minutes,
+                    "variety_score": variety,
+                }
+            )
+    if not rows:
+        return pd.DataFrame(columns=["platform_name", "minutes_per_week", "variety_score"])
+    return pd.DataFrame(rows)
+
+
+def analyze_user_data(
+    tiktok_minutes,
+    tiktok_variety,
+    insta_minutes,
+    insta_variety,
+    youtube_minutes,
+    youtube_variety,
+    twitter_minutes,
+    twitter_variety,
+    reddit_minutes,
+    reddit_variety,
+    facebook_minutes,
+    facebook_variety,
+    other_minutes,
+    other_variety,
+    feed_satisfaction,
+    fomo_level,
+):
+    df = build_dataframe_from_inputs(
         [
-          ["tiktok", 240, 5],
-          ["instagram", 180, 6],
-          ...
+            ("tiktok", tiktok_minutes, tiktok_variety),
+            ("instagram", insta_minutes, insta_variety),
+            ("youtube", youtube_minutes, youtube_variety),
+            ("twitter", twitter_minutes, twitter_variety),
+            ("reddit", reddit_minutes, reddit_variety),
+            ("facebook", facebook_minutes, facebook_variety),
+            ("other", other_minutes, other_variety),
         ]
+    )
 
-    Returns:
-        summary_markdown (str), efficiency_dataframe (pd.DataFrame)
-    """
-    if not input_table:
-        return "Please enter at least one platform and its weekly minutes.", pd.DataFrame()
-
-    # Convert raw table to DataFrame. Support both 2- and 3-column input
-    df = pd.DataFrame(input_table)
-
-    if df.shape[1] == 2:
-        df.columns = ["platform_name", "minutes_per_week"]
-        df["variety_score"] = np.nan
-    else:
-        # Assume 3 columns: platform, minutes, variety
-        df = df.iloc[:, :3]  # ignore any extra accidental columns
-        df.columns = ["platform_name", "minutes_per_week", "variety_score"]
-
-    # Basic cleaning
-    df["platform_name"] = df["platform_name"].astype(str)
-    df["minutes_per_week"] = pd.to_numeric(df["minutes_per_week"], errors="coerce")
-    df["variety_score"] = pd.to_numeric(df["variety_score"], errors="coerce")
-
-    # Drop fully empty rows
-    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)
-    df["variety_score"] = df["variety_score"].clip(lower=0, upper=10)
-
-    # Drop rows with blank names
-    df = df[df["platform_name"] != ""]
     if df.empty:
-        return "Please provide at least one platform with some minutes.", pd.DataFrame()
-
-    # Compute minutes-weighted average variety (if any variety data present)
-    total_minutes = df["minutes_per_week"].sum()
-    if total_minutes > 0 and df["variety_score"].notna().any():
-        avg_variety = float(
-            np.average(
-                df["variety_score"].fillna(0),
-                weights=df["minutes_per_week"]
-            )
-        )
-    else:
-        avg_variety = None
+        return "Please enter at least one platform with some weekly minutes.", pd.DataFrame()
 
-    # Call the core CEAR model using only the columns it expects
-    df_for_model = df[["platform_name", "minutes_per_week"]].copy()
-    raw_scores = cear_analyzer.calculate_scores(df_for_model)
+    # Call core model
+    scores = cear_analyzer.calculate_scores(
+        df, satisfaction=feed_satisfaction, fomo=fomo_level
+    )
 
-    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", [])
+    c = float(scores.get("C_Score", 0.0))
+    a = float(scores.get("A_Risk", 0.0))
+    d = float(scores.get("D_Index", 0.0))
+    avg_variety = scores.get("Avg_Variety", None)
+    satisfaction = scores.get("Satisfaction", None)
+    fomo = scores.get("FOMO", None)
+    per_eff = scores.get("Per_Platform_Efficiency", [])
 
-    # Profile based on C and A
+    # Profile from C and A
     if c >= 70 and a >= 70:
         profile = (
             "You are highly plugged into online culture, but that comes with high "
@@ -150,7 +98,7 @@ def analyze_user_data(input_table):
             "You are either deliberately detached or under-invested in highly trend-dense platforms."
         )
 
-    # Variety interpretation snippet
+    # Variety interpretation
     if avg_variety is None:
         variety_text = (
             "You did not provide variety ratings, so this analysis focuses only on time and platform mix."
@@ -158,19 +106,49 @@ def analyze_user_data(input_table):
     elif avg_variety < 4:
         variety_text = (
             f"Your average variety rating is **{avg_variety:.1f} / 10**, which suggests that your feeds feel "
-            "quite repetitive. You may be seeing similar content types despite the time you invest."
+            "quite repetitive and may reinforce a narrow slice of content."
         )
     elif avg_variety > 7:
         variety_text = (
             f"Your average variety rating is **{avg_variety:.1f} / 10**, which suggests that you see a wide range "
-            "of topics and styles. This can broaden your cultural exposure and reduce some perceived stagnation."
+            "of topics and styles. This broadens your exposure and slightly offsets some algorithmic risk."
         )
     else:
         variety_text = (
-            f"Your average variety rating is **{avg_variety:.1f} / 10**, indicating a moderate mix of content types "
-            "without being extremely narrow or extremely diverse."
+            f"Your average variety rating is **{avg_variety:.1f} / 10**, indicating a moderate mix of content types."
         )
 
+    # Satisfaction/FOMO interpretation
+    satisfaction_text = ""
+    if satisfaction is not None:
+        if satisfaction <= 3:
+            satisfaction_text = (
+                "You report low satisfaction with your feed, which suggests your current pattern might not "
+                "match what you actually want from social media."
+            )
+        elif satisfaction >= 8:
+            satisfaction_text = (
+                "You report high satisfaction with your feed, indicating your current pattern largely feels aligned "
+                "with your preferences."
+            )
+        else:
+            satisfaction_text = (
+                "Your satisfaction is in the middle range, which suggests room for improvement without a complete overhaul."
+            )
+
+    fomo_text = ""
+    if fomo is not None:
+        if fomo >= 7 and c < 50:
+            fomo_text = (
+                "You feel out of the loop and your relatively low C-Score supports that feeling. "
+                "A bit more time on trend-dense platforms could help if staying current matters to you."
+            )
+        elif fomo <= 3 and c < 40:
+            fomo_text = (
+                "You have limited exposure to trends but do not feel much FOMO, which suggests a comfortable "
+                "distance from viral culture."
+            )
+
     summary_lines = [
         "## 📊 CEAR Analysis Summary",
         "",
@@ -178,9 +156,18 @@ def analyze_user_data(input_table):
         f"- **Algorithmic Risk Score (A-Risk):** **{a:.2f}**",
         f"- **Platform Diversity Index (D-Index):** **{d:.2f}**",
     ]
-
     if avg_variety is not None:
-        summary_lines.append(f"- **Average Variety Rating (0–10):** **{avg_variety:.2f}**")
+        summary_lines.append(
+            f"- **Average Variety Rating (0–10):** **{avg_variety:.2f}**"
+        )
+    if satisfaction is not None:
+        summary_lines.append(
+            f"- **Feed Satisfaction (0–10):** **{satisfaction:.1f}**"
+        )
+    if fomo is not None:
+        summary_lines.append(
+            f"- **FOMO / Out-of-the-loop feeling (0–10):** **{fomo:.1f}**"
+        )
 
     summary_lines.extend(
         [
@@ -190,20 +177,26 @@ def analyze_user_data(input_table):
             profile,
             "",
             variety_text,
-            "",
-            "The C-Score is based on a logarithmic transform of your weekly minutes, encoding 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 many platforms you use in a meaningful way "
-            "(higher values mean your time is spread across more platforms).",
         ]
     )
+    if satisfaction_text:
+        summary_lines.append("")
+        summary_lines.append(satisfaction_text)
+    if fomo_text:
+        summary_lines.append("")
+        summary_lines.append(fomo_text)
+
+    summary_lines.append(
+        "\nThe C-Score uses a logarithmic transform of your weekly minutes, encoding 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 many platforms you use in a meaningful way (higher values mean your time is spread across more platforms)."
+    )
 
     summary = "\n".join(summary_lines).strip()
 
-    # Turn per-platform efficiency into a tidy table
+    # Per-platform efficiency table
     if isinstance(per_eff, list) and per_eff:
         eff_df = pd.DataFrame(per_eff)
-        # Expect columns ['platform_name', 'Cultural_Efficiency']
         if "platform_name" in eff_df.columns:
             eff_df = eff_df.rename(
                 columns={"platform_name": "platform", "Cultural_Efficiency": "efficiency_score"}
@@ -215,33 +208,85 @@ def analyze_user_data(input_table):
     return summary, eff_df
 
 
-# ---------- Gradio app definition ----------
-
-demo = gr.Interface(
-    fn=analyze_user_data,
-    inputs=gr.Dataframe(
-        headers=["platform_name", "minutes_per_week", "variety_score (0–10, optional)"],
-        row_count=5,
-        col_count=(3, "fixed"),
-        label="Weekly screen time (by platform)",
-        value=[
-            ["tiktok", 240, 4],
-            ["instagram", 180, 5],
-            ["youtube", 120, 7],
-            ["twitter", 60, 6],
-            ["reddit", 90, 8],
+# ---------------- Gradio UI ----------------
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        "# CEAR – Cultural Exposure & Algorithmic Risk Analyzer\n"
+        "Enter your weekly screen time per platform, rate the variety of each feed, and optionally report how satisfied "
+        "you are with your feed and how much FOMO you feel."
+    )
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Weekly minutes & per-platform variety (0–10)")
+
+            tiktok_minutes = gr.Number(label="TikTok minutes/week", value=240, precision=0)
+            tiktok_variety = gr.Slider(label="TikTok variety (0–10)", minimum=0, maximum=10, step=1, value=4)
+
+            insta_minutes = gr.Number(label="Instagram minutes/week", value=180, precision=0)
+            insta_variety = gr.Slider(label="Instagram variety (0–10)", minimum=0, maximum=10, step=1, value=5)
+
+            youtube_minutes = gr.Number(label="YouTube minutes/week", value=120, precision=0)
+            youtube_variety = gr.Slider(label="YouTube variety (0–10)", minimum=0, maximum=10, step=1, value=7)
+
+            twitter_minutes = gr.Number(label="Twitter/X minutes/week", value=60, precision=0)
+            twitter_variety = gr.Slider(label="Twitter/X variety (0–10)", minimum=0, maximum=10, step=1, value=6)
+
+            reddit_minutes = gr.Number(label="Reddit minutes/week", value=90, precision=0)
+            reddit_variety = gr.Slider(label="Reddit variety (0–10)", minimum=0, maximum=10, step=1, value=8)
+
+            facebook_minutes = gr.Number(label="Facebook minutes/week", value=45, precision=0)
+            facebook_variety = gr.Slider(label="Facebook variety (0–10)", minimum=0, maximum=10, step=1, value=3)
+
+            other_minutes = gr.Number(label="Other platforms minutes/week", value=30, precision=0)
+            other_variety = gr.Slider(label="Other platforms variety (0–10)", minimum=0, maximum=10, step=1, value=5)
+
+        with gr.Column():
+            gr.Markdown("### Self-report (global)")
+
+            feed_satisfaction = gr.Slider(
+                label="Feed satisfaction (0 = miserable, 10 = very happy)",
+                minimum=0,
+                maximum=10,
+                step=1,
+                value=6,
+            )
+            fomo_level = gr.Slider(
+                label="FOMO / out-of-the-loop feeling (0 = none, 10 = extreme)",
+                minimum=0,
+                maximum=10,
+                step=1,
+                value=4,
+            )
+
+            run_btn = gr.Button("Analyze")
+
+            summary_out = gr.Markdown(label="Score Results")
+            eff_out = gr.Dataframe(label="Per-platform Cultural Efficiency")
+
+    run_btn.click(
+        fn=analyze_user_data,
+        inputs=[
+            tiktok_minutes,
+            tiktok_variety,
+            insta_minutes,
+            insta_variety,
+            youtube_minutes,
+            youtube_variety,
+            twitter_minutes,
+            twitter_variety,
+            reddit_minutes,
+            reddit_variety,
+            facebook_minutes,
+            facebook_variety,
+            other_minutes,
+            other_variety,
+            feed_satisfaction,
+            fomo_level,
         ],
-    ),
-    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 (and optional variety ratings) to estimate your "
-        "cultural connectedness, algorithmic risk, and per-platform efficiency."
-    ),
-)
+        outputs=[summary_out, eff_out],
+    )
 
 
 if __name__ == "__main__":