"""Interface web Gradio, montée sur l'API FastAPI (une seule application, un seul port). Deux onglets, les deux sens du matching : - Candidat : un CV -> les AVP qui lui correspondent le mieux - Recruteur : un AVP -> le vivier de CV classé du plus au moins adapté Les deux fonctions principales sont aussi exposées en MCP (outils pour un agent conversationnel) quand l'application est montée avec mcp_server=True. Comme les routes REST, elles exigent une clé API (en-tête X-API-Key) dès qu'une clé est configurée ; la page web, elle, reste ouverte à tous (elle passe par son propre canal, app/front.py). Aucun CV n'est enregistré : pas de "flagging", pas de journalisation du contenu. """ from __future__ import annotations import json from pathlib import Path import gradio as gr from app import config, front, scoring from app.classement import classer_candidats from app.matching import matcher from app.routes_api import cle_valide DOSSIER_EXEMPLES = Path(__file__).resolve().parent.parent / "exemples" def _pct(valeur: float) -> int: """Pourcentage 0..100 de l'API -> entier, arrondi comme la page web (le libellé y correspond).""" return scoring.pourcentage_entier(valeur / 100) # ---------- Apparence ---------- # Même style que le front de la promotion (zako.nc/avp) : fond gris clair, encre bleu nuit, # Plus Jakarta Sans, bouton principal bleu marine, onglets en pilule. Le nom et le logo de # leur produit ne sont pas repris. Passés au lancement (Gradio 6) : THEME et CSS. THEME = gr.themes.Base( font=[gr.themes.GoogleFont("Plus Jakarta Sans", weights=(400, 500, 600, 700, 800)), "system-ui", "Segoe UI", "sans-serif"], font_mono=[gr.themes.GoogleFont("IBM Plex Mono"), "ui-monospace", "Consolas", "monospace"], radius_size=gr.themes.sizes.radius_md, ).set( body_background_fill="#f4f6f8", body_background_fill_dark="#0e141d", body_text_color="#0f1a2b", body_text_color_dark="#e9eef5", body_text_color_subdued="#46536a", body_text_color_subdued_dark="#a9b4c5", background_fill_primary="#ffffff", background_fill_primary_dark="#161e2b", background_fill_secondary="#ebeef2", background_fill_secondary_dark="#1d2737", border_color_primary="#dee3ea", border_color_primary_dark="#2a3546", block_background_fill="#ffffff", block_background_fill_dark="#161e2b", block_border_color="#dee3ea", block_border_color_dark="#2a3546", block_radius="12px", block_shadow="none", block_label_text_color="#46536a", block_label_text_color_dark="#a9b4c5", block_title_text_color="#46536a", block_title_text_color_dark="#a9b4c5", input_background_fill="#ffffff", input_background_fill_dark="#111925", input_border_color="#dee3ea", input_border_color_dark="#2a3546", input_border_color_focus="#17356b", input_border_color_focus_dark="#6f93d6", input_radius="8px", button_large_radius="14px", button_medium_radius="14px", button_small_radius="10px", button_large_text_weight="700", button_medium_text_weight="700", button_primary_background_fill="#17356b", button_primary_background_fill_dark="#3c66b9", button_primary_background_fill_hover="#21478d", button_primary_background_fill_hover_dark="#4b76c9", button_primary_border_color="#17356b", button_primary_border_color_dark="#3c66b9", button_primary_text_color="#ffffff", button_primary_text_color_dark="#ffffff", button_secondary_background_fill="#ffffff", button_secondary_background_fill_dark="#161e2b", button_secondary_border_color="#dee3ea", button_secondary_border_color_dark="#2a3546", button_secondary_text_color="#46536a", button_secondary_text_color_dark="#c3cbd8", color_accent="#17356b", color_accent_soft="#e3eaf6", color_accent_soft_dark="#1c2a44", checkbox_background_color_selected="#17356b", checkbox_background_color_selected_dark="#3c66b9", checkbox_border_color_selected="#17356b", checkbox_border_color_selected_dark="#3c66b9", link_text_color="#17356b", link_text_color_dark="#8fb0ea", loader_color="#17356b", loader_color_dark="#8fb0ea", table_border_color="#dee3ea", table_border_color_dark="#2a3546", table_even_background_fill="#ffffff", table_even_background_fill_dark="#161e2b", table_odd_background_fill="#f7f9fb", table_odd_background_fill_dark="#1a2331", ) # La page est le front (app/front/) ; il est en mode clair, comme celui de la promotion. CSS = front.CSS + "\nfooter { background: #f4f6f8; opacity: .8; }\n" # ---------- CV d'exemple (tous fictifs, règle du HackAVP) ---------- def _exemples() -> dict[str, dict]: """{libellé: cv}. Le champ _profil (réponse attendue) est retiré du CV. cv_list.json : CV fictifs du jeu d'évaluation (scripts/evaluer_classement.py). cv_demo.json : CV de démonstration (ex. profil parfait), montrés mais jamais évalués.""" cvs = [] for nom in ("cv_list.json", "cv_demo.json"): chemin = DOSSIER_EXEMPLES / nom if chemin.exists(): cvs += json.loads(chemin.read_text(encoding="utf-8")) sortie = {} for i, cv in enumerate(cvs): cv = dict(cv) cv.pop("_profil", None) label = (cv.get("basics") or {}).get("label") or f"CV {i}" sortie[f"{i:02d} · {label}"] = cv return sortie EXEMPLES = _exemples() def _vivier_exemple() -> str: cvs = [dict(cv, ref=nom) for nom, cv in EXEMPLES.items()] return json.dumps(cvs, ensure_ascii=False, indent=1) def _md(texte: str | None, n: int = 140) -> str: """Texte sûr dans un tableau Markdown : pas de |, pas de retour à la ligne, tronqué.""" t = " ".join(str(texte or "").split()).replace("|", "/") return t if len(t) <= n else t[: n - 1] + "…" _obtenir_etat = None # fixé par construire() : () -> (store, encodeur) # ---------- Côté candidat ---------- def matcher_cv(cv_json: str, inclure_clos: bool = False) -> str: """Trouve les AVP de l'OPT-NC qui correspondent le mieux à un CV, avec explications. Args: cv_json: le CV au format JSON Resume (texte JSON). inclure_clos: inclure les AVP dont la date limite de candidature est dépassée. Returns: Un rapport Markdown : pour chaque AVP, le score sur 100, les points forts (attendu de l'AVP et ligne du CV qui y répond) et les écarts principaux. """ store, encodeur = _obtenir_etat() try: cv = json.loads(cv_json) except json.JSONDecodeError as e: return f"**CV illisible** : le texte n'est pas du JSON valide ({e.msg}, ligne {e.lineno})." if not isinstance(cv, dict): return "**CV illisible** : un CV JSON Resume est un objet `{...}`." try: rep = matcher(cv, store, encodeur, config.SEUIL_COUVERTURE, top=5, inclure_fermes=inclure_clos) except ValueError as e: return f"**{e}**" if not rep.resultats: return ("**Aucun AVP ouvert en ce moment.** Toutes les dates limites du dataset " "sont dépassées : cochez « Inclure les AVP clos » pour voir le matching " "sur les offres récentes.") lignes = [f"*{rep.nb_avps_analyses} AVP analysés · modèle `{rep.modele}`*\n"] for k, r in enumerate(rep.resultats, start=1): statut = "ouvert" if r.ouvert else "**clos**" date = f" jusqu'au {r.date_limite}" if r.date_limite else "" lien = f" · [fiche métier {r.code_metier}]({r.fiche_metier_url})" if r.fiche_metier_url else "" lignes.append(f"### {k}. {r.titre} — {r.libelle} · {_pct(r.pourcentage_competences)} % " "des compétences du poste") lignes.append(f"`{r.id_avp}` · {statut}{date} · **{r.nb_savoir_faire_couverts} / " f"{r.nb_savoir_faire} compétences** · score de classement " f"{round(100 * r.score_qualite)}/100{lien}") if r.avertissement: lignes.append(f"\n> ⚠ {r.avertissement}") if r.competences_couvertes: lignes.append("\n| Point fort (attendu de l'AVP) | Ce qui y répond dans le CV |\n|---|---|") lignes += [f"| {_md(c.attendu)} | {_md(c.trouve_dans_cv)} *({c.source_cv})* |" for c in r.competences_couvertes[:3]] if r.ecarts: lignes.append("\n**Écarts principaux** (attendus que le CV ne couvre pas) :") lignes += [f"- {_md(e.attendu, 200)}" for e in r.ecarts[:3]] if r.savoir_etre: lignes.append("\n**Savoir-être attendus** (à montrer en entretien) : " + " ; ".join( _md(s.attendu, 60) + (" ✓" if s.statut == "mention_probable" else "") for s in r.savoir_etre)) lignes.append("") lignes.append("*✓ = le CV semble déjà l'évoquer. Les savoir-être comptent dans le score.*") return "\n".join(lignes) # ---------- Côté recruteur ---------- def classer_vivier(id_avp: str, cvs_json: str) -> str: """Classe un vivier de CV pour un AVP de l'OPT-NC, du plus au moins adapté. Args: id_avp: identifiant de l'AVP, par exemple "3134-26-1264/SR". cvs_json: liste de CV au format JSON Resume (texte JSON). Un champ "ref" optionnel par CV permet de retrouver le candidat. Returns: Un rapport Markdown : classement avec score sur 100, puis forces, écarts et prérequis à vérifier pour les premiers candidats. """ store, encodeur = _obtenir_etat() try: cvs = json.loads(cvs_json) except json.JSONDecodeError as e: return f"**Vivier illisible** : JSON invalide ({e.msg}, ligne {e.lineno})." if not isinstance(cvs, list) or not cvs: return "**Vivier illisible** : il faut une liste `[ {...}, {...} ]` d'au moins un CV." try: r = classer_candidats(id_avp, cvs, store, encodeur, seuil=config.SEUIL_COUVERTURE, top=len(cvs)) except KeyError: return f"**AVP inconnu** : `{id_avp}`." except ValueError as e: # vivier trop grand return f"**Vivier refusé** : {e}" lignes = [f"## {r.titre}", f"`{r.id_avp}` · {'ouvert' if r.avp_ouvert else '**clos**'} · " f"{r.nb_attendus} attendus notés", "\n**Attendus les plus discriminants** (rares parmi les AVP, donc décisifs) : " + " ; ".join(_md(a, 80) for a in r.attendus_les_plus_discriminants), "\n| Rang | Candidat | Avis | % du poste | Compétences | Score /100 | " "Spécificité | Cet AVP est son n° | Remarque |", "|---|---|---|---|---|---|---|---|---|"] for c in r.candidats: remarques = [] if c.ex_aequo_avec_precedent: remarques.append("ex aequo") if not c.fiable: remarques.append("peu fiable") if c.specificite < 0: remarques.append("correspond mieux à d'autres AVP") elif c.specificite < 5: remarques.append("profil peu ciblé") lignes.append(f"| {c.rang} | {_md(c.ref or f'CV {c.index}', 50)} | {c.libelle} | " f"**{_pct(c.pourcentage_competences)} %** | {c.nb_savoir_faire_couverts} / " f"{c.nb_savoir_faire} | {c.score:.0f} | {c.specificite:+.0f} | " f"{c.rang_de_cet_avp_pour_le_candidat} | {', '.join(remarques)} |") if r.ecartes: lignes.append("\n**Écartés** : " + " ; ".join( f"{_md(e.ref or f'CV {e.index}', 50)} ({e.raison})" for e in r.ecartes)) for c in r.candidats[:3]: lignes.append(f"\n### {c.rang}. {_md(c.ref or f'CV {c.index}', 80)} — {c.libelle} · " f"{_pct(c.pourcentage_competences)} % des compétences du poste " f"({c.nb_savoir_faire_couverts} / {c.nb_savoir_faire}, score de classement " f"{c.score:.0f}/100)") if c.avertissement: lignes.append(f"> ⚠ {c.avertissement}") # "\n" avant chaque titre : sinon Markdown le rattache au dernier point de la liste if c.forces: lignes.append("\n**Forces**") lignes += [f"- {_md(f.attendu)} ← « {_md(f.phrase_cv)} » *({f.source_cv})*" for f in c.forces] if c.ecarts: lignes.append("\n**Écarts**") lignes += [f"- {_md(e.attendu)}" for e in c.ecarts] if c.savoir_etre: lignes.append("\n**Savoir-être à vérifier en entretien** : " + " ; ".join( _md(s.attendu, 60) + (" (évoqué dans le CV)" if s.statut == "mention_probable" else "") for s in c.savoir_etre)) if c.prerequis: etats = {"rempli": "✓", "non_rempli": "✗", "mention_probable": "✓ ?", "a_verifier": "?"} lignes.append("\n**Prérequis** (jamais notés ni éliminatoires, le recruteur décide) : " + " ; ".join( f"{etats.get(p.statut, '?')} {_md(p.prerequis, 60)}" + (f" ({_md(p.motif, 70)})" if p.motif else "") + ("" if p.obligatoire else " — apprécié") for p in c.prerequis)) lignes.append("\n*Spécificité = score sur cet AVP moins le score habituel du candidat sur " "les autres AVP. Proche de 0 : le CV obtient le même score partout.*") return "\n".join(lignes) def construire(obtenir_etat, gpu=None, encodeur_cpu=None): """obtenir_etat() -> (store, encodeur), disponibles une fois le service démarré. gpu : décorateur spaces.GPU sur Hugging Face ZeroGPU (app_zerogpu.py) ; None en local, où le GPU, s'il existe, est toujours disponible. encodeur_cpu() -> Encodeur sur le processeur : mode de secours du front si ZeroGPU refuse. La page est le front (app/front.py). matcher_cv et classer_candidats restent exposés pour les programmes (API Gradio) et les agents (MCP), avec leur réponse Markdown habituelle.""" global _obtenir_etat _obtenir_etat = obtenir_etat # Durées maximales demandées à ZeroGPU : classer 23 CV relit ~37 000 paires fn_matcher = gpu(duration=60)(matcher_cv) if gpu else matcher_cv fn_classer = gpu(duration=75)(classer_vivier) if gpu else classer_vivier # Clé vérifiée AVANT de demander la carte graphique : un appel refusé ne coûte rien. # gr.Header : Gradio lit l'en-tête X-API-Key de la requête (API Gradio et MCP) ; l'outil MCP # le déclare comme en-tête requis, sans l'ajouter aux paramètres visibles par l'agent. def matcher_cv_api(cv_json: str, inclure_clos: bool = False, x_api_key: gr.Header = None) -> str: if not cle_valide(x_api_key): raise gr.Error("Clé API manquante ou invalide (en-tête X-API-Key).") return fn_matcher(cv_json, inclure_clos) def classer_vivier_api(id_avp: str, cvs_json: str, x_api_key: gr.Header = None) -> str: if not cle_valide(x_api_key): raise gr.Error("Clé API manquante ou invalide (en-tête X-API-Key).") return fn_classer(id_avp, cvs_json) # Le nom et la description des outils MCP viennent de __name__ et __doc__ matcher_cv_api.__doc__, classer_vivier_api.__doc__ = matcher_cv.__doc__, classer_vivier.__doc__ matcher_cv_api.__name__, classer_vivier_api.__name__ = "matcher_cv", "classer_candidats" with gr.Blocks(title="HackAVP · Matching CV ↔ AVP", analytics_enabled=False) as demo: front.composant(obtenir_etat, EXEMPLES, gpu=gpu, encodeur_cpu=encodeur_cpu) gr.api(matcher_cv_api, api_name="matcher_cv") gr.api(classer_vivier_api, api_name="classer_candidats") return demo