Update app.py

app.py

@@ -7,9 +7,7 @@ import gradio as gr
 from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
 from sentence_transformers import SentenceTransformer, util
 
-# --------------------------
-# light setup
-# --------------------------
+# ---------- lightweight setup ----------
 def ensure_spacy():
     try:
         return spacy.load("en_core_web_sm")
@@ -27,24 +25,19 @@ def ensure_nltk():
 ensure_nltk()
 nlp = ensure_spacy()
 
-# --------------------------
-# models (cached)
-# --------------------------
+# ---------- models ----------
 sbert_model = SentenceTransformer("all-MiniLM-L6-v2")
 bert_sentiment = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
-
 emotion_model_name = "j-hartmann/emotion-english-distilroberta-base"
 emotion_tokenizer = AutoTokenizer.from_pretrained(emotion_model_name)
 emotion_model = AutoModelForSequenceClassification.from_pretrained(emotion_model_name)
 
-# --------------------------
-# constants
-# --------------------------
-CSV_PATH_PLUS = "la matrice plus.csv"  # pathways + colors
-CSV_PATH_COLOR = "la matrice.csv"      # color lexicon
+# ---------- constants ----------
+CSV_PATH_PLUS  = "la matrice plus.csv"   # pathways + colors + narrative pieces
+CSV_PATH_COLOR = "la matrice.csv"        # color lexicon
 
+# only explicit pathways (no Auto here)
 SEQUENCE_ALIASES = {
-    "Auto (recommend)": "auto",
     "Direct": "direct",
     "Fem": "feminine",
     "Knot": "knot",
@@ -58,6 +51,7 @@ SEQUENCE_ALIASES = {
     "Sad": "sad",
 }
 
+
 SEQUENCE_IMAGE_FILES = {
     "direct": "direct pathway.png",
     "feminine": "fem pathway.png",
@@ -72,6 +66,7 @@ SEQUENCE_IMAGE_FILES = {
     "sad": "sad pathway.png"
 }
 
+# GNH dictionaries
 GNH_DOMAINS: Dict[str, str] = {
     "Mental Wellness": "mental health, emotional clarity, peace of mind",
     "Social Wellness": "relationships, community, friendship, social harmony",
@@ -104,24 +99,22 @@ GNH_COLORS: Dict[str, str] = {
     "Cultural Diversity": "#9370db",
 }
 
-# --------------------------
-# load pathway → colors & phrase (from la matrice plus.csv)
-# --------------------------
+# ---------- load pathway → colors & phrase (plus) ----------
 def load_pathway_info(csv_path_plus: str):
     df = pd.read_csv(csv_path_plus)
-    keys = set(SEQUENCE_ALIASES.values()) - {"auto"}
+    keys = set(SEQUENCE_ALIASES.values())
     rows = df[df["color"].astype(str).str.lower().isin(keys)].copy()
 
     seq_to_colors: Dict[str, List[str]] = {}
     seq_phrase: Dict[str, str] = {}
 
-    # use 'r' for color list; phrase = join other non-null columns
     cols_for_phrase = [c for c in df.columns if c not in ("color", "r", "g", "b")]
     for _, row in rows.iterrows():
         key = str(row["color"]).strip().lower()
+        # colors list is in column 'r' (comma/space separated), supports 2–8
         colors_field = str(row.get("r", "") or "")
         colors = [c.strip().lower() for c in re.split(r"[,\s]+", colors_field) if c.strip()]
-        seq_to_colors[key] = list(dict.fromkeys(colors))  # de-dupe
+        seq_to_colors[key] = list(dict.fromkeys(colors))  # dedupe, keep order
 
         vals = []
         for c in cols_for_phrase:
@@ -137,15 +130,12 @@ def load_pathway_info(csv_path_plus: str):
 
 SEQ_TO_COLORS, SEQ_PHRASE = load_pathway_info(CSV_PATH_PLUS)
 
-# --------------------------
-# load color lexicon (from la matrice.csv)
-# --------------------------
+# ---------- load color lexicon (color CSV) ----------
 def _find_col(df: pd.DataFrame, candidates: List[str]) -> str | None:
     names = {c.lower(): c for c in df.columns}
     for c in candidates:
         if c.lower() in names:
             return names[c.lower()]
-    # fuzzy contains
     for want in candidates:
         for lc, orig in names.items():
             if want.replace(" ", "").replace("-", "") in lc.replace(" ", "").replace("-", ""):
@@ -181,9 +171,10 @@ def sequence_to_image_path(seq_key: str) -> str | None:
     fname = SEQUENCE_IMAGE_FILES.get(seq_key)
     return fname if (fname and os.path.exists(fname)) else None
 
-# --------------------------
-# core scoring
-# --------------------------
+# ---------- core scoring ----------
+def encode_text(t: str):
+    return sbert_model.encode(t, convert_to_tensor=True)
+
 def classify_emotion(text: str) -> Tuple[str, float]:
     inputs = emotion_tokenizer(text, return_tensors="pt", truncation=True)
     with torch.no_grad():
@@ -200,50 +191,21 @@ def score_sentiment(text: str) -> float:
     return round(min(10, max(1, scaled)), 2)
 
 def score_accomplishment(text: str) -> float:
-    doc = nlp(text)
-    score = 5.0
+    doc = nlp(text); score = 5.0
     key_phrases = {"finally","told","decided","quit","refused","stood","walked","walked away","returned","return"}
     for token in doc:
         if token.text.lower() in key_phrases: score += 1.5
         if token.tag_ in {"VBD","VBN"}:       score += 0.5
     return round(min(10, max(1, score)), 2)
 
-# --------------------------
-# pathway-aware vector math
-# --------------------------
-def encode_text(t: str):
-    return sbert_model.encode(t, convert_to_tensor=True)
-
-def composite_vector(base_text: str, extras: List[Tuple[str,float]], limits: List[Tuple[str,float]]):
-    """
-    v = base + Σ(w_i * encode(extra_i)) - Σ(w_j * encode(limit_j))
-    `extras` and `limits` are (text, weight) pairs
-    """
-    v = encode_text(base_text)
-    for s, w in extras:
-        if s and w:
-            v = v + float(w) * encode_text(s)
-    for s, w in limits:
-        if s and w:
-            v = v - float(w) * encode_text(s)
-    return v
-
-def best_sequence_for_vector(vec) -> Tuple[str, float]:
-    best_key, best_sim = None, -1.0
-    for key, phrase in SEQ_PHRASE.items():
-        if not phrase: continue
-        sim = float(util.cos_sim(vec, encode_text(phrase)).item())
-        if sim > best_sim:
-            best_key, best_sim = key, sim
-    return best_key or "direct", best_sim
-
-def semantic_indicator_mapping_from_vec(vec, sentiment_score: float, sentiment_weight: float = 0.3) -> Dict[str, float]:
+def semantic_indicator_mapping(text: str, sentiment_score: float, sentiment_weight: float = 0.3) -> Dict[str, float]:
+    v = encode_text(text)
     out: Dict[str, float] = {}
-    for label, desc in GNH_DOMAINS.items():
-        sim = float(util.cos_sim(vec, encode_text(desc)).item())
+    for dom, desc in GNH_DOMAINS.items():
+        sim = float(util.cos_sim(v, encode_text(desc)).item())
         sim = max(0.0, min(1.0, sim))
         blended = (1 - sentiment_weight) * sim + sentiment_weight * (sentiment_score / 10.0)
-        out[label] = round(blended, 3)
+        out[dom] = round(blended, 3)
     return dict(sorted(out.items(), key=lambda kv: -kv[1]))
 
 def indicators_plot(indicators: Dict[str, float]):
@@ -252,161 +214,154 @@ def indicators_plot(indicators: Dict[str, float]):
     fig = plt.figure(figsize=(8,5))
     plt.barh(labels, values, color=colors)
     plt.gca().invert_yaxis()
-    plt.title("GNH Indicator Similarity (Pathway-weighted)")
+    plt.title("GNH Indicator Similarity")
     plt.xlabel("Score")
     plt.tight_layout()
     return fig
 
-# --------------------------
-# helpers for UI chips
-# --------------------------
-def lex_chip_html(color: str, mode: str, max_words: int = 4) -> str:
-    words = COLOR_LEX.get(color.lower(), {}).get(mode, [])[:max_words]
-    if not words: return ""
+# ---------- chips / prompts ----------
+WORD_MODES = ["Matrice1", "Matrice", "English", "GNH Indicators"]
+
+def join_lex_words(color: str) -> str:
+    d = COLOR_LEX.get(color.lower(), {})
+    words = d.get("matrice1", []) + d.get("matrice", []) + d.get("english", [])
+    return " ".join(dict.fromkeys(words))
+
+def nearest_gnh_domain_for_color(color: str) -> Tuple[str, float]:
+    text = join_lex_words(color)
+    if not text:
+        return "Mental Wellness", 0.0
+    v = encode_text(text)
+    best, best_sim = None, -1.0
+    for dom, desc in GNH_DOMAINS.items():
+        sim = float(util.cos_sim(v, encode_text(desc)).item())
+        if sim > best_sim:
+            best, best_sim = dom, sim
+    return best or "Mental Wellness", best_sim
+
+def chip_html_for(color: str, mode: str, max_words: int = 4) -> str:
+    if not color: return ""
+    if mode.lower().startswith("gnh"):
+        domain, sim = nearest_gnh_domain_for_color(color)
+        hex_color = GNH_COLORS.get(domain, "#cccccc")
+        dot = f"<span style='display:inline-block;width:12px;height:12px;border-radius:50%;background:{hex_color};margin-right:6px;border:1px solid #999;vertical-align:middle'></span>"
+        pill = f"<span style='display:inline-block;margin:2px 6px;padding:2px 8px;border-radius:12px;background:#eee;font-size:12px'>{domain} · {sim:.2f}</span>"
+        return f"<div style='margin-bottom:6px'>{dot}<b>{color.capitalize()}</b>{pill}</div>"
+    # word modes
+    key = "english" if mode.lower() == "english" else ("matrice1" if mode.lower()=="matrice1" else "matrice")
+    words = COLOR_LEX.get(color.lower(), {}).get(key, [])[:max_words]
     pills = "".join(
         f"<span style='display:inline-block;margin:2px 6px;padding:2px 8px;border-radius:12px;background:#eee;font-size:12px'>{w}</span>"
         for w in words
     )
-    title = color.capitalize()
-    color_dot = f"<span style='display:inline-block;width:12px;height:12px;border-radius:50%;background:{color};margin-right:6px;border:1px solid #999;vertical-align:middle'></span>"
-    return f"<div style='margin-bottom:6px'>{color_dot}<b>{title}</b>{pills}</div>"
-
-def two_color_prompts_for_sequence(seq_key: str) -> List[str]:
-    colors = SEQ_TO_COLORS.get(seq_key, [])
-    # ensure we always return up to two, pad with empty if fewer
-    colors = colors[:2] + [""] * max(0, 2 - len(colors))
-    return colors
-
-# --------------------------
-# gradio app
-# --------------------------
-SEQ_CHOICES = list(SEQUENCE_ALIASES.keys())
-WORD_MODES = ["Matrice1", "Matrice", "English"]  # toggle chips source
-
-def update_color_prompt_ui(seq_choice: str, word_mode: str):
-    """Update color chips + textbox labels when pathway or word mode changes."""
-    key = SEQUENCE_ALIASES.get(seq_choice, "auto")
-    if key == "auto":
-        # no fixed colors yet
-        return (
-            gr.update(value="Select a pathway to see color prompts."),  # chips block
-            gr.update(label="Color A", placeholder="—", value=""),
-            gr.update(label="Color B", placeholder="—", value="")
-        )
-
-    mode = word_mode.lower()
-    if mode == "matrice1": mode_key = "matrice1"
-    elif mode == "matrice": mode_key = "matrice"
-    else: mode_key = "english"
-
-    c1, c2 = two_color_prompts_for_sequence(key)
-    chips_html = ""
-    if c1: chips_html += lex_chip_html(c1, mode_key)
-    if c2: chips_html += lex_chip_html(c2, mode_key)
-    if not chips_html:
-        chips_html = "No color lexicon found for this pathway."
-
-    tb1 = gr.update(label=f"{c1.capitalize() if c1 else 'Color A'} meaning", placeholder=f"Describe {c1} meaning..." if c1 else "—", value="")
-    tb2 = gr.update(label=f"{c2.capitalize() if c2 else 'Color B'} meaning", placeholder=f"Describe {c2} meaning..." if c2 else "—", value="")
-
-    return chips_html, tb1, tb2
-
-def analyze(
-    text: str,
-    seq_choice: str,
-    word_mode: str,
-    color_a_text: str,
-    color_b_text: str,
-    limit_seqs_labels: List[str],
-    color_prompt_weight: float,
-    limit_weight: float,
-):
-    if not text or not text.strip():
-        return (5.0, "neutral (0.0)", 5.0, "—", "—", "{}", None, None, "—")
-
-    sentiment = score_sentiment(text)
-    emotion, emo_conf = classify_emotion(text)
-    accomplishment = score_accomplishment(text)
-
-    chosen_key = SEQUENCE_ALIASES.get(seq_choice, "auto")
-
-    # build extras/limits from pathway + color texts
-    extras: List[Tuple[str,float]] = []
-    limits: List[Tuple[str,float]] = []
-
-    # include the pathway phrase itself as a small bias, if not auto
-    if chosen_key != "auto":
-        phrase = SEQ_PHRASE.get(chosen_key, "")
-        if phrase: extras.append((phrase, 0.5))
-
-    # include color interpretation texts (user inputs)
-    if color_a_text.strip(): extras.append((color_a_text.strip(), color_prompt_weight))
-    if color_b_text.strip(): extras.append((color_b_text.strip(), color_prompt_weight))
-
-    # limits: other sequences user selected to suppress
-    limit_keys = [SEQUENCE_ALIASES.get(lbl, lbl).lower() for lbl in limit_seqs_labels]
-    for k in limit_keys:
-        p = SEQ_PHRASE.get(k, "")
-        if p: limits.append((p, limit_weight))
-
-    # composite vector & choose pathway (or evaluate chosen)
-    context_vec = composite_vector(text, extras, limits)
-
-    if chosen_key == "auto":
-        final_key, final_sim = best_sequence_for_vector(context_vec)
-    else:
-        final_key = chosen_key
-        phrase = SEQ_PHRASE.get(final_key, "")
-        final_sim = float(util.cos_sim(context_vec, encode_text(phrase)).item()) if phrase else 0.0
-
-    # outputs
-    final_phrase = SEQ_PHRASE.get(final_key, "—")
-    img_path = sequence_to_image_path(final_key)
-
-    indicators = semantic_indicator_mapping_from_vec(context_vec, sentiment_score=sentiment)
+    dot = f"<span style='display:inline-block;width:12px;height:12px;border-radius:50%;background:{color};margin-right:6px;border:1px solid #999;vertical-align:middle'></span>"
+    return f"<div style='margin-bottom:6px'>{dot}<b>{color.capitalize()}</b>{pills}</div>"
+
+def colors_for_sequence(seq_key: str) -> List[str]:
+    return SEQ_TO_COLORS.get(seq_key, [])  # 2–8 colors
+
+def labels_for_mode(colors: List[str], mode: str) -> List[str]:
+    if mode.lower().startswith("gnh"):
+        labs = []
+        for c in colors:
+            d, _ = nearest_gnh_domain_for_color(c)
+            labs.append(d)
+        return labs
+    return [c.capitalize() for c in colors]
+
+# ---------- dynamic prompt UI (2–8 inputs) ----------
+MAX_COLORS = 8  # upper bound for inputs we render
+
+def update_prompt_ui(seq_choice: str, word_mode: str):
+    key = SEQUENCE_ALIASES.get(seq_choice)
+    colors = colors_for_sequence(key)
+    labels = labels_for_mode(colors, word_mode)
+
+    # chips HTML for all colors
+    chips = "".join(chip_html_for(c, word_mode) for c in colors) or "No prompts available for this pathway."
+
+    # build visibility/labels/placeholders for up to MAX_COLORS textboxes
+    inputs_updates = []
+    for i in range(MAX_COLORS):
+        if i < len(colors):
+            lab = f"{labels[i]} meaning" if labels[i] else f"Input {i+1} meaning"
+            ph  = f"Describe {labels[i]} meaning..." if labels[i] else "—"
+            inputs_updates.append(gr.update(visible=True, label=lab, placeholder=ph, value=""))
+        else:
+            inputs_updates.append(gr.update(visible=False, value="", label=f"Input {i+1}", placeholder="—"))
+    return (chips, *inputs_updates)
+
+# ---------- MAIN ANALYSIS ----------
+def analyze(text: str, seq_choice: str, word_mode: str, *color_inputs):
+    """
+    - user chooses pathway
+    - we show N color prompts (2–8)
+    - compose updated pathway phrase that embeds all non-empty inputs
+    - analyze sentiment/emotion + GNH on (text + updated phrase)
+    """
+    key = SEQUENCE_ALIASES.get(seq_choice)
+    if key not in SEQ_PHRASE:
+        return (5.0, "neutral (0.0)", 5.0, "Please choose a valid pathway.", "{}", None, None,
+                f"{seq_choice} (unavailable)")
+
+    sentiment = score_sentiment(text or "")
+    emotion, emo_conf = classify_emotion(text or "")
+    accomplishment = score_accomplishment(text or "")
+
+    colors = colors_for_sequence(key)
+    labels = labels_for_mode(colors, word_mode)
+
+    # updated phrase = base phrase + each "{Label}: {input}"
+    base_phrase = SEQ_PHRASE.get(key, "")
+    pieces = [base_phrase]
+    for lab, user_text in zip(labels, list(color_inputs)[:len(colors)]):
+        if isinstance(user_text, str) and user_text.strip():
+            pieces.append(f"{lab}: {user_text.strip()}")
+    updated_phrase = " // ".join([p for p in pieces if p])
+
+    augmented_text = " ".join([t for t in [text, updated_phrase] if t and t.strip()])
+    indicators = semantic_indicator_mapping(augmented_text, sentiment_score=sentiment)
     fig = indicators_plot(indicators)
     top5 = list(indicators.items())[:5]
     top5_str = "\n".join(f"{k}: {v}" for k, v in top5)
 
+    cols = SEQ_TO_COLORS.get(key, [])
     emo_str = f"{emotion} ({emo_conf:.3f})"
-    meta = f"{final_key} (relevance={final_sim:.3f})"
-    # show the two pathway colors for transparency
-    cols = SEQ_TO_COLORS.get(final_key, [])
-    meta += f" | colors: {', '.join(cols) if cols else '—'}"
+    meta = f"{key} | colors: {', '.join(cols) if cols else '—'}"
+    img_path = sequence_to_image_path(key)
 
-    # also return updated chips/labels if we were in Auto and just decided a pathway
-    chips, tb1, tb2 = update_color_prompt_ui(seq_choice if chosen_key!="auto" else next(k for k,v in SEQUENCE_ALIASES.items() if v==final_key), word_mode)
+    # refresh prompt area to keep labels/visibility consistent after run
+    chips_and_inputs = update_prompt_ui(seq_choice, word_mode)
 
     return (
         sentiment, emo_str, accomplishment,
-        final_phrase, top5_str, fig, img_path, meta,
-        chips, tb1, tb2
+        updated_phrase, top5_str, fig, img_path, meta,
+        *chips_and_inputs
     )
 
+# ---------- Gradio UI ----------
+SEQ_CHOICES = list(SEQUENCE_ALIASES.keys())
+DEFAULT_SEQ = "Direct" if "Direct" in SEQ_CHOICES else SEQ_CHOICES[0]
+
 with gr.Blocks(title="RGB Root Matriz Color Plotter") as demo:
     gr.Markdown("## RGB Root Matriz Color Plotter\n"
                 "Type a phrase. Choose a **Sequence** or keep **Auto** to recommend a pathway. "
                 "You’ll get sentiment, emotion, accomplishment, GNH bars, and the pathway phrase + image from the dataset.")
 
     with gr.Row():
-        inp = gr.Textbox(lines=4, label="Input obstacle / situation", placeholder="Describe the situation...")
+        inp = gr.Textbox(lines=4, label="Your situation / obstacle", placeholder="Describe the situation...")
 
     with gr.Row():
-        seq = gr.Dropdown(choices=list(SEQUENCE_ALIASES.keys()), value="Auto (recommend)", label="Primary Pathway")
-        word_mode = gr.Radio(choices=["Matrice1","Matrice","English"], value="Matrice1", label="Word Mode")
+        seq = gr.Dropdown(choices=SEQ_CHOICES, value=DEFAULT_SEQ, label="Pathway")
+        word_mode = gr.Radio(choices=["Matrice1", "Matrice", "English", "GNH Indicators"], value="Matrice1", label="Word Mode")
 
-    # Color Interpretations section (chips + two inputs)
-    chips_block = gr.HTML("Select a pathway to see color prompts.")
-    color_a = gr.Textbox(label="Color A meaning", placeholder="—")
-    color_b = gr.Textbox(label="Color B meaning", placeholder="—")
+    chips_block = gr.HTML()  # chips for all colors
 
-    # knobs
-    with gr.Row():
-        limit_seqs = gr.CheckboxGroup(choices=[c for c in SEQUENCE_ALIASES.keys() if c != "Auto (recommend)"],
-                                      label="Limit pathways (optional)")
-    with gr.Row():
-        color_w = gr.Slider(0.0, 1.5, value=0.8, step=0.05, label="Color prompt weight")
-        limit_w = gr.Slider(0.0, 1.5, value=0.6, step=0.05, label="Limit weight")
+    # up to MAX_COLORS inputs (shown/hidden dynamically)
+    color_inputs = []
+    for i in range(MAX_COLORS):
+        tb = gr.Textbox(visible=False, label=f"Input {i+1}", placeholder="—")
+        color_inputs.append(tb)
 
     run = gr.Button("Generate Pathway Analysis", variant="primary")
 
@@ -417,23 +372,33 @@ with gr.Blocks(title="RGB Root Matriz Color Plotter") as demo:
         acc  = gr.Number(label="Accomplishment (1–10)")
 
     with gr.Row():
-        phrase_out = gr.Text(label="Pathway phrase")
+        phrase_out = gr.Text(label="Updated Pathway Phrase (with your meanings)")
         gnh_top    = gr.Text(label="Top GNH Indicators (Top 5)")
 
-    gnh_plot = gr.Plot(label="GNH Similarity (Pathway-weighted)")
+    gnh_plot = gr.Plot(label="GNH Similarity")
     img_out  = gr.Image(label="Pathway image", type="filepath")
-    meta_out = gr.Text(label="Chosen pathway / colors / relevance")
+    meta_out = gr.Text(label="Chosen pathway / colors")
 
-    # wire interactions
-    seq.change(fn=update_color_prompt_ui, inputs=[seq, word_mode], outputs=[chips_block, color_a, color_b])
-    word_mode.change(fn=update_color_prompt_ui, inputs=[seq, word_mode], outputs=[chips_block, color_a, color_b])
+    # initialize prompt area for default selection
+    init_updates = update_prompt_ui(DEFAULT_SEQ, "Matrice1")
+    chips_block.value = init_updates[0]
+    for tb, up in zip(color_inputs, init_updates[1:1+MAX_COLORS]):
+        tb.update(**up)
+
+    # re-render prompts on changes
+    def _update_ui(seq_choice, mode):
+        return update_prompt_ui(seq_choice, mode)
+
+    seq.change(fn=_update_ui, inputs=[seq, word_mode], outputs=[chips_block, *color_inputs])
+    word_mode.change(fn=_update_ui, inputs=[seq, word_mode], outputs=[chips_block, *color_inputs])
 
     run.click(
         fn=analyze,
-        inputs=[inp, seq, word_mode, color_a, color_b, limit_seqs, color_w, limit_w],
-        outputs=[sent, emo, acc, phrase_out, gnh_top, gnh_plot, img_out, meta_out, chips_block, color_a, color_b],
+        inputs=[inp, seq, word_mode, *color_inputs],
+        outputs=[sent, emo, acc, phrase_out, gnh_top, gnh_plot, img_out, meta_out, chips_block, *color_inputs],
     )
 
 if __name__ == "__main__":
     demo.launch()
 
+