Update app.py

app.py

@@ -7,7 +7,7 @@ import gradio as gr
 from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
 from sentence_transformers import SentenceTransformer, util
 
-# ---------- lightweight setup ----------
+# -------------------- setup --------------------
 def ensure_spacy():
     try:
         return spacy.load("en_core_web_sm")
@@ -25,22 +25,22 @@ def ensure_nltk():
 ensure_nltk()
 nlp = ensure_spacy()
 
-# ---------- 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 + phrase parts
+# -------------------- constants --------------------
+CSV_PATH_PLUS  = "la matrice plus.csv"   # pathways + colors + template words
 CSV_PATH_COLOR = "la matrice.csv"        # color lexicon
 
 SEQUENCE_ALIASES = {
     "Direct": "direct",
-    "Fem": "feminine",
+    "Feminine": "feminine",
     "Knot": "knot",
-    "Masc": "masc",
+    "Masculine": "masculine",
     "Pain": "pain",
     "Prayer": "prayer",
     "Precise": "precise",
@@ -50,12 +50,11 @@ SEQUENCE_ALIASES = {
     "Sad": "sad",
 }
 
-
 SEQUENCE_IMAGE_FILES = {
     "direct": "direct pathway.png",
     "feminine": "fem pathway.png",
     "knot": "knot pathway.png",
-    "masc": "masc pathway.png",
+    "masculine": "masc pathway.png",
     "pain": "pain pathway.png",
     "prayer": "prayer pathway.png",
     "precise": "precise pathway.png",
@@ -65,7 +64,6 @@ 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",
@@ -98,7 +96,21 @@ GNH_COLORS: Dict[str, str] = {
     "Cultural Diversity": "#9370db",
 }
 
-# ---------- load pathway → colors & phrase ----------
+WORD_MODES = ["Matrice1", "Matrice", "English", "GNH Indicators"]
+MAX_COLORS = 8
+
+# -------------------- loaders --------------------
+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()]
+    for want in candidates:
+        ww = want.replace(" ", "").replace("-", "")
+        for lc, orig in names.items():
+            if ww in lc.replace(" ", "").replace("-", ""):
+                return orig
+    return None
+
 def load_pathway_info(csv_path_plus: str):
     df = pd.read_csv(csv_path_plus)
     keys = set(SEQUENCE_ALIASES.values())
@@ -107,40 +119,26 @@ def load_pathway_info(csv_path_plus: str):
     seq_to_colors: Dict[str, List[str]] = {}
     seq_phrase: Dict[str, str] = {}
 
+    # colors live in 'r' (list), template = concat of the other fields
     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 in 'r' as comma/space separated list (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))  # dedupe
+        color_list = str(row.get("r", "") or "")
+        colors = [c.strip().lower() for c in re.split(r"[,\s]+", color_list) if c.strip()]
+        seq_to_colors[key] = list(dict.fromkeys(colors))
 
         vals = []
         for c in cols_for_phrase:
             v = row.get(c)
             if pd.notna(v):
-                vs = str(v).strip()
-                if vs and vs.lower() != "nan":
-                    vals.append(vs)
-        phrase = " ".join(" ".join(vals).split())
+                s = str(v).strip()
+                if s and s.lower() != "nan":
+                    vals.append(s)
+        phrase = " ".join(" ".join(vals).split())  # base template
         seq_phrase[key] = phrase
 
     return seq_to_colors, seq_phrase
 
-SEQ_TO_COLORS, SEQ_PHRASE = load_pathway_info(CSV_PATH_PLUS)
-
-# ---------- load color lexicon ----------
-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()]
-    for want in candidates:
-        for lc, orig in names.items():
-            if want.replace(" ", "").replace("-", "") in lc.replace(" ", "").replace("-", ""):
-                return orig
-    return None
-
 def _split_words(s: str) -> List[str]:
     if not isinstance(s, str): return []
     parts = re.split(r"[,\;/\|\s]+", s.strip())
@@ -164,13 +162,14 @@ def load_color_lexicon(csv_path_color: str):
         }
     return lex
 
+SEQ_TO_COLORS, SEQ_PHRASE = load_pathway_info(CSV_PATH_PLUS)
 COLOR_LEX = load_color_lexicon(CSV_PATH_COLOR)
 
 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 ----------
+# -------------------- NLP helpers --------------------
 def encode_text(t: str):
     return sbert_model.encode(t, convert_to_tensor=True)
 
@@ -218,19 +217,16 @@ def indicators_plot(indicators: Dict[str, float]):
     plt.tight_layout()
     return fig
 
-# ---------- chips / prompts ----------
-WORD_MODES = ["Matrice1", "Matrice", "English", "GNH Indicators"]
-
-def join_lex_words(color: str) -> str:
+# -------------------- prompt building (legible placeholders) --------------------
+def join_all_words(color: str) -> List[str]:
     d = COLOR_LEX.get(color.lower(), {})
-    words = d.get("matrice1", []) + d.get("matrice", []) + d.get("english", [])
-    return " ".join(dict.fromkeys(words))
+    return list(dict.fromkeys(d.get("matrice1", []) + d.get("matrice", []) + d.get("english", [])))
 
 def nearest_gnh_domain_for_color(color: str) -> Tuple[str, float]:
-    text = join_lex_words(color)
-    if not text:
+    words = " ".join(join_all_words(color))
+    if not words:
         return "Mental Wellness", 0.0
-    v = encode_text(text)
+    v = encode_text(words)
     best, best_sim = None, -1.0
     for dom, desc in GNH_DOMAINS.items():
         sim = float(util.cos_sim(v, encode_text(desc)).item())
@@ -238,108 +234,148 @@ def nearest_gnh_domain_for_color(color: str) -> Tuple[str, float]:
             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>"
-    # lexicon 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
-    )
-    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 [nearest_gnh_domain_for_color(c)[0] for c in colors]
     return [c.capitalize() for c in colors]
 
-# ---------- dynamic prompt UI (2–8 inputs) ----------
-MAX_COLORS = 8  # upper bound; raise if some pathways exceed this
+def placeholder_for(color: str, mode: str) -> str:
+    """
+    Always show a meaningful placeholder driven by the chosen mode.
+    """
+    color_lc = color.lower()
+    if mode.lower().startswith("gnh"):
+        dom, _ = nearest_gnh_domain_for_color(color_lc)
+        return f"{dom}: {GNH_DOMAINS.get(dom, '')}"
+
+    # map mode -> CSV column key
+    mode_key = {
+        "matrice1": "matrice1",
+        "matrice":  "matrice",
+        "english":  "english",
+    }.get(mode.lower(), "matrice")
+
+    lex = COLOR_LEX.get(color_lc, {})
+    primary = lex.get(mode_key, [])
+
+    # If the chosen column has entries, use them.
+    if primary:
+        return ", ".join(primary[:12])
+
+    # Otherwise, try the other two lexicon columns (ordered).
+    fallback_order = [k for k in ("matrice1", "matrice", "english") if k != mode_key]
+    for fb in fallback_order:
+        words = lex.get(fb, [])
+        if words:
+            label = "Matrice1" if fb == "matrice1" else ("Matrice" if fb == "matrice" else "English")
+            return f"(from {label}) " + ", ".join(words[:12])
+
+    # Final fallback: mapped GNH domain description (still a “meaning”, just not from lexicon).
+    dom, _ = nearest_gnh_domain_for_color(color_lc)
+    return f"(mapped GNH) {dom}: {GNH_DOMAINS.get(dom, '')}"
+
+
+def simple_color_legend(colors: List[str]) -> str:
+    if not colors:
+        return "No prompts available for this pathway."
+    parts = []
+    for c in colors:
+        dot = f"<span style='display:inline-block;width:10px;height:10px;border-radius:50%;background:{c};margin-right:8px;border:1px solid #999;vertical-align:middle'></span>"
+        parts.append(f"<div style='margin:4px 0'>{dot}<b>{c.capitalize()}</b></div>")
+    return "<div>" + "".join(parts) + "</div>"
+
+def colors_for_sequence(seq_key: str) -> List[str]:
+    return SEQ_TO_COLORS.get(seq_key, [])
 
 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)
+    legend_html = simple_color_legend(colors)
 
-    chips = "".join(chip_html_for(c, word_mode) for c in colors) or "No prompts available for this pathway."
-
-    # Return updates for chips + each color input (visibility, label, placeholder)
-    inputs_updates = []
+    updates = []
     for i in range(MAX_COLORS):
         if i < len(colors):
             lab = labels[i] if i < len(labels) else f"Input {i+1}"
-            ph  = f"Describe {lab} meaning..." if lab else "—"
-            inputs_updates.append(gr.update(visible=True, label=f"{lab} meaning", placeholder=ph, value=""))
+            ph  = placeholder_for(colors[i], word_mode)
+            updates.append(gr.update(visible=True, label=f"{lab} meaning", placeholder=ph, value=""))
         else:
-            inputs_updates.append(gr.update(visible=False, value="", label=f"Input {i+1}", placeholder="—"))
-    return (chips, *inputs_updates)
+            updates.append(gr.update(visible=False, value="", label=f"Input {i+1}", placeholder="—"))
+    return (legend_html, *updates)
 
-# ---------- MAIN ANALYSIS ----------
-def analyze(text: str, seq_choice: str, word_mode: str, *color_inputs):
+# -------------------- template replacement --------------------
+def render_phrase_template(base_phrase: str, colors: List[str], labels: List[str], inputs: List[str]) -> str:
     """
-    - user chooses pathway
-    - show N color prompts (2–8)
-    - compose updated pathway phrase embedding all inputs
-    - analyze sentiment/emotion + GNH on (text + updated phrase)
+    Replace occurrences of '<color>-pathway' (any spacing/hyphen variants) with the user's phrase for that color.
+    If user left it empty, keep the label (color name or mapped GNH indicator).
+    Finally, append a compact legend ' // Label: input'.
     """
+    text = base_phrase or ""
+    # build replacement map color -> replacement text
+    rep: Dict[str, str] = {}
+    for color, label, user in zip(colors, labels, inputs):
+        use = user.strip() if isinstance(user, str) and user.strip() else label
+        rep[color.lower()] = use
+
+    # replace each token case-insensitively
+    for color, replacement in rep.items():
+        # match 'brown-pathway', 'brown pathway', 'Brown- Pathway', etc.
+        pattern = re.compile(rf"\b{re.escape(color)}\s*-\s*pathway\b", re.IGNORECASE)
+        text = pattern.sub(replacement, text)
+
+    # if the template had no tokens, fall back to readable construction:
+    # "use A to B the C of D as a new E" is preserved, but we still append meanings
+    suffix_parts = []
+    for color, label, user in zip(colors, labels, inputs):
+        if isinstance(user, str) and user.strip():
+            suffix_parts.append(f"{label}: {user.strip()}")
+    if suffix_parts:
+        text = (text + " // " + " // ".join(suffix_parts)).strip()
+
+    return text
+
+# -------------------- main analysis --------------------
+def analyze(text: str, seq_choice: str, word_mode: str, *color_inputs):
     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)", *update_prompt_ui(seq_choice, word_mode))
-
-    sentiment = score_sentiment(text or "")
-    emotion, emo_conf = classify_emotion(text or "")
-    accomplishment = score_accomplishment(text or "")
+        return (5.0, "neutral (0.0)", 5.0, "Choose a valid pathway.", "{}", None, None, f"{seq_choice} (unavailable)",
+                *update_prompt_ui(seq_choice, word_mode))
 
     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)
+
+    # updated phrase with template replacement
+    user_inputs = list(color_inputs)[:len(colors)]
+    updated_phrase = render_phrase_template(base_phrase, colors, labels, user_inputs)
+
+    # analysis on original + updated
+    combined_text = " ".join([t for t in [text, updated_phrase] if t and t.strip()])
+    sentiment = score_sentiment(combined_text)
+    emotion, emo_conf = classify_emotion(combined_text)
+    accomplishment = score_accomplishment(combined_text)
+
+    indicators = semantic_indicator_mapping(combined_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"{key} | colors: {', '.join(cols) if cols else '—'}"
     img_path = sequence_to_image_path(key)
+    meta = f"{key} | colors: {', '.join(colors) if colors else '—'}"
+    emo_str = f"{emotion} ({emo_conf:.3f})"
 
-    # keep UI prompts in sync after run
-    chips_and_inputs = update_prompt_ui(seq_choice, word_mode)
+    # keep prompt area synced
+    prompt_updates = update_prompt_ui(seq_choice, word_mode)
 
     return (
         sentiment, emo_str, accomplishment,
         updated_phrase, top5_str, fig, img_path, meta,
-        *chips_and_inputs
+        *prompt_updates
     )
 
-# ---------- Gradio UI ----------
+# -------------------- UI --------------------
 SEQ_CHOICES = list(SEQUENCE_ALIASES.keys())
-DEFAULT_SEQ = "Direct" if "Direct" in SEQ_CHOICES else SEQ_CHOICES[0]
+DEFAULT_SEQ = "Knot" if "Knot" 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"
@@ -351,51 +387,42 @@ with gr.Blocks(title="RGB Root Matriz Color Plotter") as demo:
 
     with gr.Row():
         seq = gr.Dropdown(choices=SEQ_CHOICES, value=DEFAULT_SEQ, label="Pathway")
-        word_mode = gr.Radio(choices=WORD_MODES, value="Matrice1", label="Word Mode")
+        word_mode = gr.Radio(choices=WORD_MODES, value="Matrice", label="Word Mode")
 
-    chips_block = gr.HTML()  # chips for all colors
+    legend = gr.HTML()
 
-    # up to MAX_COLORS inputs (shown/hidden dynamically)
-    color_inputs = []
+    color_boxes: List[gr.Textbox] = []
     for i in range(MAX_COLORS):
-        tb = gr.Textbox(visible=False, label=f"Input {i+1}", placeholder="—")
-        color_inputs.append(tb)
+        color_boxes.append(gr.Textbox(visible=False, label=f"Input {i+1}", placeholder="—"))
 
     run = gr.Button("Generate Pathway Analysis", variant="primary")
 
-    # outputs
     with gr.Row():
         sent = gr.Number(label="Sentiment (1–10)")
         emo  = gr.Text(label="Emotion")
         acc  = gr.Number(label="Accomplishment (1–10)")
 
     with gr.Row():
-        phrase_out = gr.Text(label="Updated Pathway Phrase (with your meanings)")
+        phrase_out = gr.Text(label="Updated Pathway Phrase (template with your meanings)")
         gnh_top    = gr.Text(label="Top GNH Indicators (Top 5)")
 
     gnh_plot = gr.Plot(label="GNH Similarity")
     img_out  = gr.Image(label="Pathway image", type="filepath")
     meta_out = gr.Text(label="Chosen pathway / colors")
 
-    # events
     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])
+    seq.change(fn=_update_ui, inputs=[seq, word_mode], outputs=[legend, *color_boxes])
+    word_mode.change(fn=_update_ui, inputs=[seq, word_mode], outputs=[legend, *color_boxes])
 
     run.click(
         fn=analyze,
-        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],
+        inputs=[inp, seq, word_mode, *color_boxes],
+        outputs=[sent, emo, acc, phrase_out, gnh_top, gnh_plot, img_out, meta_out, legend, *color_boxes],
     )
 
-    # ✅ initialize prompts on load (instead of tb.update(...))
-    demo.load(
-        fn=_update_ui,
-        inputs=[seq, word_mode],
-        outputs=[chips_block, *color_inputs]
-    )
+    demo.load(fn=_update_ui, inputs=[seq, word_mode], outputs=[legend, *color_boxes])
 
 if __name__ == "__main__":
     demo.launch()