Spaces:
Running on Zero
Running on Zero
Download app/interface.py from Myz0/CV-Matching: direct link, hf CLI and curl.
- Browser
- Download file 15.9 kB
-
https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/app/interface.py
- Command line
-
hf download hf://spaces/Myz0/CV-Matching/app/interface.py
-
curl -L -o interface.py https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/app/interface.py
15.9 kB
| """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 | |