| |
| """ |
| Verbatify — Analyse sémantique NPS (Paste-only, NPS inféré) |
| Interface simplifiée : toutes les options sont appliquées automatiquement. |
| """ |
|
|
| import os, re, json, collections, tempfile, zipfile |
| from typing import List, Dict, Optional |
| import pandas as pd |
| import gradio as gr |
| import plotly.express as px |
| import plotly.graph_objects as go |
| import plotly.io as pio |
|
|
| |
|
|
| BASE_DIR = os.path.dirname(os.path.abspath(__file__)) |
| CSS_FILE = os.path.join(BASE_DIR, "verbatim.css") |
|
|
| VB_CSS_FALLBACK = r""" |
| @import url('https://fonts.googleapis.com/css2?family=Manrope:wght@400;500;700;800&display=swap'); |
| :root{--vb-bg:#F8FAFC;--vb-text:#0F172A;--vb-primary:#7C3AED;--vb-primary-2:#06B6D4;--vb-border:#E2E8F0;} |
| *{color-scheme:light !important} |
| html,body,.gradio-container{background:var(--vb-bg)!important;color:var(--vb-text)!important; |
| font-family:Manrope,system-ui,-apple-system,'Segoe UI',Roboto,Arial,sans-serif!important} |
| .gradio-container{max-width:1120px!important;margin:0 auto!important} |
| .vb-hero{display:flex;align-items:center;gap:16px;padding:20px 22px;margin:10px 0 20px; |
| background:linear-gradient(90deg,rgba(124,58,237,.18),rgba(6,182,212,.18));border:1px solid var(--vb-border); |
| border-radius:14px;box-shadow:0 10px 26px rgba(2,6,23,.08)} |
| .vb-hero .vb-title{font-size:22px;color:#0F172A;font-weight:500} |
| .vb-hero .vb-sub{font-size:13px;color:#0F172A} |
| .gradio-container .vb-cta{background:linear-gradient(90deg,var(--vb-primary),var(--vb-primary-2))!important;color:#fff!important; |
| border:0!important;font-weight:700!important;font-size:16px!important;padding:14px 18px!important;border-radius:14px!important; |
| box-shadow:0 10px 24px rgba(124,58,237,.28)} |
| .gradio-container .vb-cta:hover{transform:translateY(-2px);filter:brightness(1.05)} |
| /* Patch encarts vides & texte noir partout */ |
| .gradio-container .empty, |
| .gradio-container [class*="unpadded_box"], |
| .gradio-container [class*="unpadded-box"], |
| .gradio-container .empty[class*="box"]{background:#FFFFFF!important;background-image:none!important;border:1px solid transparent!important;box-shadow:none!important} |
| .gradio-container .empty *, .gradio-container [class*="unpadded_box"] *{color:#0F172A!important;fill:#0F172A!important} |
| """ |
|
|
| VB_CSS = None |
| try: |
| if os.path.exists(CSS_FILE): |
| with open(CSS_FILE, "r", encoding="utf-8") as f: |
| VB_CSS = f.read() |
| except Exception: |
| VB_CSS = None |
| if not VB_CSS: |
| VB_CSS = VB_CSS_FALLBACK |
|
|
| |
|
|
| def apply_plotly_theme(): |
| pio.templates["verbatify"] = go.layout.Template( |
| layout=go.Layout( |
| font=dict(family="Manrope, system-ui, -apple-system, Segoe UI, Roboto, Arial, sans-serif", |
| size=13, color="#0F172A"), |
| paper_bgcolor="white", plot_bgcolor="white", |
| colorway=["#7C3AED","#06B6D4","#2563EB","#10B981","#A855F7","#22D3EE","#1D4ED8","#0EA5E9"], |
| xaxis=dict(gridcolor="#E2E8F0", zerolinecolor="#E2E8F0"), |
| yaxis=dict(gridcolor="#E2E8F0", zerolinecolor="#E2E8F0"), |
| legend=dict(borderwidth=0, bgcolor="rgba(255,255,255,0)") |
| ) |
| ) |
| pio.templates.default = "verbatify" |
|
|
| LOGO_SVG = """<svg xmlns='http://www.w3.org/2000/svg' width='224' height='38' viewBox='0 0 224 38'> |
| <defs><linearGradient id='g' x1='0%' y1='0%' x2='100%'><stop offset='0%' stop-color='#7C3AED'/><stop offset='100%' stop-color='#06B6D4'/></linearGradient></defs> |
| <g fill='none' fill-rule='evenodd'> |
| <rect x='0' y='7' width='38' height='24' rx='12' fill='url(#g)'/> |
| <circle cx='13' cy='19' r='5' fill='#fff' opacity='0.95'/><circle cx='25' cy='19' r='5' fill='#fff' opacity='0.72'/> |
| <text x='46' y='25' font-family='Manrope, system-ui, -apple-system, Segoe UI, Roboto, Arial, sans-serif' font-size='20' font-weight='800' fill='#0F172A' letter-spacing='0.2'>Verbatify</text> |
| </g> |
| </svg>""" |
|
|
| |
|
|
| try: |
| from unidecode import unidecode |
| except Exception: |
| import unicodedata |
| def unidecode(x): |
| try: |
| return unicodedata.normalize('NFKD', str(x)).encode('ascii','ignore').decode('ascii') |
| except Exception: |
| return str(x) |
|
|
| |
|
|
| THEMES = { |
| "Remboursements santé":[r"\bremboursement[s]?\b", r"\bt[eé]l[eé]transmission\b", r"\bno[eé]mie\b", |
| r"\bprise\s*en\s*charge[s]?\b", r"\btaux\s+de\s+remboursement[s]?\b", r"\b(ameli|cpam)\b", |
| r"\bcompl[eé]mentaire\s+sant[eé]\b", r"\bmutuelle\b", r"\battestation[s]?\b", r"\bcarte\s+(mutuelle|tiers\s*payant)\b"], |
| "Tiers payant / Réseau de soins":[r"\btiers\s*payant\b", r"\br[ée]seau[x]?\s+de\s+soins\b", |
| r"\b(optique|dentaire|hospitalisation|pharmacie)\b", r"\bitelis\b", r"\bsant[eé]clair\b", r"\bkalixia\b"], |
| "Sinistres / Indemnisation":[r"\bsinistre[s]?\b", r"\bindemni(sation|ser)\b", r"\bexpertis[ea]\b", |
| r"\bd[eé]claration\s+de\s+sinistre\b", r"\bconstat\b", r"\bbris\s+de\s+glace\b", r"\bassistance\b", r"\bd[ée]pannage\b"], |
| "Adhésion / Contrat":[r"\badh[eé]sion[s]?\b", r"\bsouscription[s]?\b", r"\baffiliation[s]?\b", r"\bcontrat[s]?\b", |
| r"\bavenant[s]?\b", r"\bcarence[s]?\b", r"\brenouvellement[s]?\b", r"\br[eé]siliation[s]?\b"], |
| "Garanties / Exclusions / Franchise":[r"\bgarantie[s]?\b", r"\bexclusion[s]?\b", r"\bplafond[s]?\b", |
| r"\bfranchise[s]?\b", r"\bconditions\s+g[eé]n[eé]rales\b", r"\bnotice\b"], |
| "Cotisations / Facturation":[r"\bcotisation[s]?\b", r"\bpr[eé]l[eè]vement[s]?\b", r"\bech[eé]ancier[s]?\b", |
| r"\bfacture[s]?\b", r"\berreur[s]?\s+de\s+facturation\b", r"\bremboursement[s]?\b", r"\bRIB\b", r"\bIBAN\b"], |
| "Délais & Suivi dossier":[r"\bd[eé]lai[s]?\b", r"\btraitement[s]?\b", r"\bsuivi[s]?\b", r"\brelance[s]?\b", r"\bretard[s]?\b"], |
| "Espace client / App / Connexion":[r"\bespace\s+client\b", r"\bapplication\b", r"\bapp\b", r"\bsite\b", |
| r"\bconnexion\b", r"\bidentifiant[s]?\b", r"\bmot\s+de\s+passe\b", r"\bpaiement\s+en\s+ligne\b", |
| r"\bbogue[s]?\b", r"\bbug[s]?\b", r"\bnavigation\b", r"\binterface\b", r"\bUX\b"], |
| "Support / Conseiller":[r"\bSAV\b", r"\bservice[s]?\s+client[s]?\b", r"\bconseiller[s]?\b", |
| r"\b[rR][eé]ponse[s]?\b", r"\bjoignable[s]?\b", r"\brapp?el\b"], |
| "Communication / Transparence":[r"\binformation[s]?\b", r"\bcommunication\b", r"\btransparence\b", |
| r"\bclart[eé]\b", r"\bcourrier[s]?\b", r"\bmail[s]?\b", r"\bnotification[s]?\b"], |
| "Prix":[r"\bprix\b", r"\bcher[s]?\b", r"\bco[uû]t[s]?\b", r"\btarif[s]?\b", |
| r"\bcomp[eé]titif[s]?\b", r"\babusif[s]?\b", r"\bbon\s+rapport\s+qualit[eé]\s*prix\b"], |
| "Offre / Gamme":[r"\boffre[s]?\b", r"\bgamme[s]?\b", r"\bdisponibilit[eé][s]?\b", r"\bdevis\b", r"\bchoix\b", r"\bcatalogue[s]?\b"], |
| "Produit/Qualité":[r"\bqualit[eé]s?\b", r"\bfiable[s]?\b", r"\bconforme[s]?\b", r"\bnon\s+conforme[s]?\b", |
| r"\bd[eé]fectueux?[es]?\b", r"\bperformant[e]?[s]?\b"], |
| "Agence / Accueil":[r"\bagence[s]?\b", r"\bboutique[s]?\b", r"\baccueil\b", r"\bconseil[s]?\b", r"\battente\b", r"\bcaisse[s]?\b"], |
| } |
|
|
| |
|
|
| POS_WORDS = { |
| "bien":1.0,"super":1.2,"parfait":1.4,"excellent":1.5,"ravi":1.2,"satisfait":1.0, |
| "rapide":0.8,"efficace":1.0,"fiable":1.0,"simple":0.8,"facile":0.8,"clair":0.8,"conforme":0.8, |
| "sympa":0.8,"professionnel":1.0,"réactif":1.0,"reactif":1.0,"compétent":1.0,"competent":1.0, |
| "top":1.2,"recommande":1.2,"recommandé":1.2,"bon":0.8 |
| } |
| NEG_WORDS = { |
| "mauvais":-1.2,"horrible":-1.5,"nul":-1.2,"lent":-0.8,"cher":-0.9,"arnaque":-1.5, |
| "déçu":-1.2,"decu":-1.2,"incompétent":-1.3,"bug":-0.9,"bogue":-0.9,"problème":-1.0, |
| "probleme":-1.0,"attente":-0.6,"retard":-0.9,"erreur":-1.0,"compliqué":-0.8,"complique":-0.8, |
| "défectueux":-1.3,"defectueux":-1.3,"non conforme":-1.2,"impossible":-1.0,"difficile":-0.7 |
| } |
| NEGATIONS = [r"\bpas\b", r"\bjamais\b", r"\bplus\b", r"\baucun[e]?\b", r"\brien\b", r"\bni\b", r"\bgu[eè]re\b"] |
| INTENSIFIERS = [r"\btr[eè]s\b", r"\bvraiment\b", r"\bextr[eê]mement\b", r"\bhyper\b"] |
| DIMINISHERS = [r"\bun[e]?\s+peu\b", r"\bassez\b", r"\bplut[oô]t\b", r"\bl[eé]g[eè]rement\b"] |
| INTENSIFIER_W, DIMINISHER_W = 1.5, 0.7 |
|
|
| |
|
|
| OPENAI_AVAILABLE = False |
| try: |
| from openai import OpenAI |
| if os.getenv("OPENAI_API_KEY"): |
| _client = OpenAI() |
| OPENAI_AVAILABLE = True |
| except Exception: |
| OPENAI_AVAILABLE = False |
|
|
| OA_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini") |
| OA_TEMP = float(os.getenv("OPENAI_TEMP", "0.1")) |
| TOP_K = int(os.getenv("VERBATIFY_TOPK", "10")) |
|
|
| |
|
|
| def normalize(t:str)->str: |
| if not isinstance(t,str): return "" |
| return re.sub(r"\s+"," ",t.strip()) |
|
|
| def to_analyzable(t:str)->str: |
| return unidecode(normalize(t.lower())) |
|
|
| def window_has(patterns:List[str], toks:List[str], i:int, w:int=3)->bool: |
| s=max(0,i-w); e=min(len(toks),i+w+1); win=" ".join(toks[s:e]) |
| return any(re.search(p,win) for p in patterns) |
|
|
| def lexical_sentiment_score(text:str)->float: |
| toks = to_analyzable(text).split(); score=0.0 |
| for i,t in enumerate(toks): |
| base = POS_WORDS.get(t,0.0) or NEG_WORDS.get(t,0.0) |
| if not base and i<len(toks)-1: |
| bi=f"{t} {toks[i+1]}"; base = NEG_WORDS.get(bi,0.0) |
| if base: |
| w=1.0 |
| if window_has(INTENSIFIERS,toks,i): w*=INTENSIFIER_W |
| if window_has(DIMINISHERS,toks,i): w*=DIMINISHER_W |
| if window_has(NEGATIONS,toks,i): base*=-1 |
| score+=base*w |
| return max(min(score,4.0),-4.0) |
|
|
| def lexical_sentiment_label(s:float)->str: |
| return "positive" if s>=0.3 else ("negatif" if s<=-0.3 else "neutre") |
|
|
| def detect_themes_regex(text:str): |
| t=to_analyzable(text); counts={} |
| for th,pats in THEMES.items(): |
| c=sum(len(re.findall(p,t)) for p in pats) |
| if c>0: counts[th]=c |
| return list(counts.keys()), counts |
|
|
| def nps_bucket(s): |
| try: |
| v=int(s) |
| except: |
| return "inconnu" |
| return "promoter" if v>=9 else ("passive" if v>=7 else ("detractor" if v>=0 else "inconnu")) |
|
|
| def compute_nps(series): |
| vals=[] |
| for x in series.dropna().tolist(): |
| try: |
| v=int(x) |
| if 0<=v<=10: vals.append(v) |
| except: pass |
| if not vals: return None |
| tot=len(vals); pro=sum(1 for v in vals if v>=9); det=sum(1 for v in vals if v<=6) |
| return 100.0*(pro/tot - det/tot) |
|
|
| def anonymize(t:str)->str: |
| if not isinstance(t,str): return "" |
| t=re.sub(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}","[email]",t) |
| t=re.sub(r"\b(?:\+?\d[\s.-]?){7,}\b","[tel]",t) |
| return t |
|
|
| |
| def df_from_pasted_auto(text:str) -> pd.DataFrame: |
| lines = [l.strip() for l in (text or "").splitlines() if l.strip()] |
| rows = [] |
| pat = re.compile(r"\|\s*(-?\d{1,2})\s*$") |
| for i, line in enumerate(lines, 1): |
| m = pat.search(line) |
| if m: |
| verb = line[:m.start()].strip() |
| score = m.group(1) |
| rows.append({"id": i, "comment": verb, "nps_score": pd.to_numeric(score, errors="coerce")}) |
| else: |
| rows.append({"id": i, "comment": line, "nps_score": None}) |
| return pd.DataFrame(rows) |
|
|
| |
| def openai_json(model:str, system:str, user:str, temperature:float=0.0) -> Optional[dict]: |
| if not OPENAI_AVAILABLE: return None |
| try: |
| resp = _client.chat.completions.create( |
| model=model, temperature=temperature, |
| messages=[{"role":"system","content":system},{"role":"user","content":user}], |
| ) |
| txt = resp.choices[0].message.content.strip() |
| m = re.search(r"\{.*\}", txt, re.S) |
| return json.loads(m.group(0) if m else txt) |
| except Exception: |
| return None |
|
|
| def oa_sentiment(comment:str) -> Optional[dict]: |
| system = "Tu es un classifieur FR. Réponds strictement en JSON." |
| user = f'Texte: {comment}\nDonne "label" parmi ["positive","neutre","negatif"] et "score" entre -4 et 4. JSON.' |
| return openai_json(OA_MODEL, system, user, OA_TEMP) |
|
|
| def oa_themes(comment:str) -> Optional[dict]: |
| system = "Tu maps le texte client vers un thésaurus assurance. Réponds strictement en JSON." |
| user = f"Texte: {comment}\nThésaurus: {json.dumps(list(THEMES.keys()), ensure_ascii=False)}\nRetourne {{'themes': [...], 'counts': {{...}}}}" |
| return openai_json(OA_MODEL, system, user, OA_TEMP) |
|
|
| def oa_summary(nps:Optional[float], dist:Dict[str,int], themes_df:pd.DataFrame) -> Optional[str]: |
| system = "Tu es un analyste CX FR. Donne une synthèse courte et actionnable en Markdown." |
| top = [] if themes_df is None else themes_df.head(6).to_dict(orient="records") |
| user = f"Données: NPS={None if nps is None else round(nps,1)}, Répartition={dist}, Thèmes={json.dumps(top, ensure_ascii=False)}" |
| j = openai_json(OA_MODEL, system, user, 0.2) |
| if isinstance(j, dict) and "text" in j: return j["text"] |
| if isinstance(j, dict): return ' '.join(str(v) for v in j.values()) |
| return None |
|
|
| |
| def make_hf_pipe(): |
| try: |
| from transformers import pipeline |
| return pipeline("text-classification", |
| model="cmarkea/distilcamembert-base-sentiment", |
| tokenizer="cmarkea/distilcamembert-base-sentiment") |
| except Exception: |
| return None |
|
|
| |
| def infer_nps_from_sentiment(label: str, score: float) -> int: |
| scaled = int(round((float(score) + 4.0) * 1.25)) |
| scaled = max(0, min(10, scaled)) |
| if label == "positive": |
| return max(9, scaled) |
| if label == "negatif": |
| return min(6, scaled) |
| return 8 if score >= 0 else 7 |
|
|
| |
|
|
| def fig_nps_gauge(nps: Optional[float]) -> go.Figure: |
| v = 0.0 if nps is None else float(nps) |
| return go.Figure(go.Indicator(mode="gauge+number", value=v, |
| gauge={"axis":{"range":[-100,100]}, "bar":{"thickness":0.3}}, |
| title={"text":"NPS (−100 à +100)"})) |
|
|
| def fig_sentiment_bar(dist: Dict[str,int]) -> go.Figure: |
| order = ["negatif","neutre","positive"] |
| x = [o for o in order if o in dist]; y = [dist.get(o,0) for o in x] |
| return px.bar(x=x, y=y, labels={"x":"Sentiment","y":"Nombre"}, title="Répartition des émotions") |
|
|
| def fig_top_themes(themes_df: pd.DataFrame, k: int) -> go.Figure: |
| if themes_df is None or themes_df.empty: return go.Figure() |
| d = themes_df.head(k); fig = px.bar(d, x="theme", y="total_mentions", title=f"Top {k} thèmes — occurrences") |
| fig.update_layout(xaxis_tickangle=-30); return fig |
|
|
| def fig_theme_balance(themes_df: pd.DataFrame, k: int) -> go.Figure: |
| if themes_df is None or themes_df.empty: return go.Figure() |
| d = themes_df.head(k) |
| d2 = d.melt(id_vars=["theme"], value_vars=["verbatims_pos","verbatims_neg"], var_name="type", value_name="count") |
| d2["type"] = d2["type"].map({"verbatims_pos":"Positifs","verbatims_neg":"Négatifs"}) |
| fig = px.bar(d2, x="theme", y="count", color="type", barmode="stack", title=f"Top {k} thèmes — balance Pos/Neg") |
| fig.update_layout(xaxis_tickangle=-30); return fig |
|
|
| |
|
|
| def analyze_text(pasted_txt: str): |
| |
| df = df_from_pasted_auto(pasted_txt or "") |
| if df.empty: |
| raise gr.Error("Colle au moins un verbatim (une ligne).") |
| df["comment"] = df["comment"].apply(anonymize) |
|
|
| |
| use_oa_sent = use_oa_themes = use_oa_summary = True |
| if not OPENAI_AVAILABLE: |
| use_oa_sent = use_oa_themes = use_oa_summary = False |
| hf_pipe = make_hf_pipe() |
|
|
| |
| rows=[]; theme_agg=collections.defaultdict(lambda:{"mentions":0,"pos":0,"neg":0}) |
| used_hf=False; used_oa=False; any_inferred=False |
|
|
| for idx, r in df.iterrows(): |
| cid=r.get("id", idx+1); comment=normalize(str(r["comment"])) |
|
|
| |
| sent=None |
| if use_oa_sent: |
| sent=oa_sentiment(comment); used_oa = used_oa or bool(sent) |
| if not sent and hf_pipe is not None and comment.strip(): |
| try: |
| res=hf_pipe(comment); lab=str(res[0]["label"]).lower(); p=float(res[0].get("score",0.5)) |
| if "1" in lab or "2" in lab: sent = {"label":"negatif","score":-4*p} |
| elif "3" in lab: sent = {"label":"neutre","score":0.0} |
| else: sent = {"label":"positive","score":4*p} |
| used_hf=True |
| except Exception: |
| sent=None |
| if not sent: |
| s=float(lexical_sentiment_score(comment)) |
| sent={"label":lexical_sentiment_label(s),"score":s} |
|
|
| |
| themes, counts = detect_themes_regex(comment) |
| if use_oa_themes: |
| tjson=oa_themes(comment) |
| if isinstance(tjson, dict): |
| used_oa=True |
| for th, c in (tjson.get("counts",{}) or {}).items(): |
| if th in THEMES and int(c) > 0: |
| counts[th] = max(counts.get(th, 0), int(c)) |
| themes = [th for th, c in counts.items() if c > 0] |
|
|
| |
| given = r.get("nps_score", None) |
| try: |
| given = int(given) if given is not None and str(given).strip() != "" else None |
| except Exception: |
| given = None |
|
|
| if given is None: |
| inferred = infer_nps_from_sentiment(sent["label"], float(sent["score"])) |
| nps_final, nps_source, any_inferred = inferred, "inferred", True |
| else: |
| nps_final, nps_source = given, "given" |
|
|
| bucket = nps_bucket(nps_final) |
|
|
| for th, c in counts.items(): |
| theme_agg[th]["mentions"] += c |
| if sent["label"] == "positive": theme_agg[th]["pos"] += 1 |
| elif sent["label"] == "negatif": theme_agg[th]["neg"] += 1 |
|
|
| rows.append({ |
| "id": cid, "comment": comment, |
| "nps_score_given": given, "nps_score_inferred": nps_final if given is None else None, |
| "nps_score_final": nps_final, "nps_source": nps_source, "nps_bucket": bucket, |
| "sentiment_score": round(float(sent["score"]), 3), "sentiment_label": sent["label"], |
| "sentiment_source": "openai" if (use_oa_sent and used_oa) else ("huggingface" if used_hf else "rules"), |
| "themes": ", ".join(themes) if themes else "", "theme_counts_json": json.dumps(counts, ensure_ascii=False) |
| }) |
|
|
| out_df=pd.DataFrame(rows) |
| nps=compute_nps(out_df["nps_score_final"]) |
| dist=out_df["sentiment_label"].value_counts().to_dict() |
|
|
| |
| trs=[] |
| for th, d in theme_agg.items(): |
| trs.append({"theme":th,"total_mentions":int(d["mentions"]), |
| "verbatims_pos":int(d["pos"]),"verbatims_neg":int(d["neg"]), |
| "net_sentiment":int(d["pos"]-d["neg"])}) |
| themes_df=pd.DataFrame(trs).sort_values(["total_mentions","net_sentiment"],ascending=[False,False]) |
|
|
| |
| method = "OpenAI + HF + règles" if (OPENAI_AVAILABLE and used_hf) else ("OpenAI + règles" if OPENAI_AVAILABLE else ("HF + règles" if used_hf else "Règles")) |
| nps_label = "NPS global (inféré)" if any_inferred else "NPS global" |
| lines=[ "# Synthèse NPS & ressentis clients", |
| f"- **Méthode** : {method}", |
| f"- **{nps_label}** : {nps:.1f}" if nps is not None else f"- **{nps_label}** : n/a" ] |
| if dist: |
| tot=sum(dist.values()); pos=dist.get("positive",0); neg=dist.get("negatif",0); neu=dist.get("neutre",0) |
| lines.append(f"- **Répartition émotions** : positive {pos}/{tot}, neutre {neu}/{tot}, négative {neg}/{tot}") |
| if not themes_df.empty: |
| lines.append("\n## Thèmes les plus cités") |
| for th,m in themes_df.head(5)[["theme","total_mentions"]].values.tolist(): |
| lines.append(f"- **{th}** : {m} occurrence(s)") |
| summary_md="\n".join(lines) |
|
|
| if OPENAI_AVAILABLE: |
| md = oa_summary(nps, dist, themes_df) |
| if md: summary_md = md + "\n\n---\n" + summary_md |
|
|
| |
| tmpdir=tempfile.mkdtemp(prefix="nps_gradio_") |
| enriched=os.path.join(tmpdir,"enriched_comments.csv") |
| themes=os.path.join(tmpdir,"themes_stats.csv") |
| summ=os.path.join(tmpdir,"summary.md") |
| out_df.to_csv(enriched,index=False,encoding="utf-8-sig") |
| themes_df.to_csv(themes,index=False,encoding="utf-8-sig") |
| with open(summ,"w",encoding="utf-8") as f: f.write(summary_md) |
| zip_path=os.path.join(tmpdir,"nps_outputs.zip") |
| with zipfile.ZipFile(zip_path,"w",zipfile.ZIP_DEFLATED) as z: |
| z.write(enriched,arcname="enriched_comments.csv") |
| z.write(themes,arcname="themes_stats.csv") |
| z.write(summ,arcname="summary.md") |
|
|
| |
| def make_panels(dfT: pd.DataFrame): |
| if dfT is None or dfT.empty: return "—","—","—" |
| pos_top = dfT.sort_values(["verbatims_pos","total_mentions"], ascending=[False,False]).head(4) |
| neg_top = dfT.sort_values(["verbatims_neg","total_mentions"], ascending=[False,False]).head(4) |
| def bullets(df, col, label): |
| lines=[f"**{label}**"] |
| for _, r in df.iterrows(): lines.append(f"- **{r['theme']}** — {int(r[col])} verbatims") |
| return "\n".join(lines) |
| ench_md = bullets(pos_top, "verbatims_pos", "Points d’enchantement") |
| irr_md = bullets(neg_top, "verbatims_neg", "Irritants") |
| RECO_RULES = { |
| "Délais & Suivi dossier": "Réduire les délais (SLA), suivi proactif.", |
| "Cotisations / Facturation": "Clarifier factures, alerter anomalies.", |
| "Espace client / App / Connexion": "Corriger login/MDP, QA navigateurs.", |
| "Support / Conseiller": "Améliorer joignabilité, scripts, rappel auto.", |
| "Communication / Transparence": "Notifications étapes clés, messages clairs.", |
| "Sinistres / Indemnisation": "Transparence délais + suivi dossier.", |
| } |
| rec_lines=["**Recommandations**"] |
| for _, r in neg_top.iterrows(): |
| rec_lines.append(f"- **{r['theme']}** — {RECO_RULES.get(r['theme'],'Plan d’action dédié')}") |
| return ench_md, irr_md, "\n".join(rec_lines) |
|
|
| ench_md, irr_md, reco_md = make_panels(themes_df) |
| fig_gauge = fig_nps_gauge(nps) |
| fig_emots = fig_sentiment_bar(dist) |
| k = max(1, int(TOP_K)) |
| fig_top = fig_top_themes(themes_df, k) |
| fig_bal = fig_theme_balance(themes_df, k) |
|
|
| return (summary_md, themes_df.head(100), out_df.head(200), [enriched, themes, summ, zip_path], |
| ench_md, irr_md, reco_md, fig_gauge, fig_emots, fig_top, fig_bal) |
|
|
| |
|
|
| apply_plotly_theme() |
|
|
| with gr.Blocks(title="Verbatify, révélez la voix de vos assurés, simplement...", css=VB_CSS) as demo: |
| |
| gr.HTML( |
| "<div class='vb-hero'>" |
| f"{LOGO_SVG}" |
| "<div><div class='vb-title'>Verbatify, révélez la voix de vos assurés, simplement...</div>" |
| "<div class='vb-sub'>Émotions • Thématiques • Occurrences • Synthèse • NPS</div></div>" |
| "</div>" |
| ) |
|
|
| |
| with gr.Row(): |
| pasted = gr.Textbox( |
| label="Verbatims (un par ligne)", lines=10, |
| placeholder="Exemple :\nRemboursement rapide, télétransmission OK | 10\nImpossible de joindre un conseiller | 3\nEspace client : bug à la connexion | 4", |
| scale=4 |
| ) |
| |
| with gr.Column(elem_id="vb-cta-cell", scale=1): |
| run = gr.Button("Lancer l'analyse", elem_classes=["vb-cta"]) |
|
|
| |
| with gr.Row(): |
| ench_panel=gr.Markdown() |
| irr_panel=gr.Markdown() |
| reco_panel=gr.Markdown() |
|
|
| |
| summary=gr.Markdown(label="Synthèse NPS & ressentis clients") |
| themes_table=gr.Dataframe(label="Thèmes — statistiques") |
| enriched_table=gr.Dataframe(label="Verbatims enrichis (aperçu)") |
| files_out=gr.Files(label="Téléchargements (CSV & ZIP)") |
|
|
| |
| with gr.Row(): |
| plot_nps = gr.Plot(label="NPS — Jauge") |
| plot_sent= gr.Plot(label="Répartition des émotions") |
| with gr.Row(): |
| plot_top = gr.Plot(label="Top thèmes — occurrences") |
| plot_bal = gr.Plot(label="Top thèmes — balance Pos/Neg") |
|
|
| |
| run.click( |
| analyze_text, |
| inputs=[pasted], |
| outputs=[summary, themes_table, enriched_table, files_out, |
| ench_panel, irr_panel, reco_panel, |
| plot_nps, plot_sent, plot_top, plot_bal] |
| ) |
|
|
| gr.HTML( |
| '<div class="vb-footer">© Verbatify.com — Construit par ' |
| '<a href="https://jeremy-lagache.fr/" target="_blank" rel="dofollow">Jérémy Lagache</a></div>' |
| ) |
|
|
| if __name__ == "__main__": |
| demo.launch(share=False, show_api=False) |
|
|
