CV-Matching / app /interface.py
Myz0's picture
Avis calibré sur des notes humaines : Profil adapté / à étudier / peu adapté
a462430 verified
Raw History Blame Contribute Delete
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