CV-Matching / app /explications.py
Myz0's picture
Libellé lu sur le pourcentage, limites de taille, clé API sur Gradio et MCP, API /v1, versions figées, journal
6044352 verified
Raw History Blame Contribute Delete
9.54 kB
"""Fiches d'explication en JSON, pour le front (app/front.py) et la maquette (scripts/).
Pour chaque paire CV x AVP : le score, son libellé, et pour chaque attendu de l'AVP les deux
notes (similarité bge-m3 passée dans la rampe, probabilité du reranker), le degré retenu, les
points apportés au score et les points perdus. La somme des points obtenus est le score ;
obtenus + perdus = 100.
"""
from __future__ import annotations
from datetime import date, datetime
import numpy as np
from app import config, scoring
from app.avp_store import est_ouvert
from app.cv_texte import phrases_du_cv, verifier_taille_vivier
from app.outils import textes_pour_calcul
CONTRATS = {"FULL_TIME": "CDI", "PART_TIME": "Temps partiel", "CONTRACTOR": "Contrat",
"TEMPORARY": "CDD", "INTERN": "Stage"}
def _date(x) -> str | None:
try:
return datetime.fromisoformat(str(x)).date().isoformat() if x else None
except ValueError:
return None
def _capitale(x) -> str | None:
return (x or "").strip().capitalize() or None
VIDES = {"", "/", "-", "néant", "neant", "none", "aucun", "aucune"}
def conditions_du_poste(a: dict) -> list[list[str]]:
"""Conditions qu'un CV ne peut pas prouver mais que le candidat doit connaître ou accepter :
durée de résidence, contraintes horaires, conditions physiques et de travail. Affichées, jamais notées."""
libres = {}
for x in (a.get("additionalType") or {}).get("informationsLibres") or []:
libres.setdefault(x.get("name") or "", str(x.get("value") or "").strip())
vus = [(a.get("workHours") or "").strip().lower()] # déjà affiché dans « Horaires »
sortie = []
for libelle, valeur in [("Durée de résidence", a.get("eligibilityToWorkRequirement") or libres.get("Durée de résidence exigée")),
("Contraintes", a.get("specialCommitments")),
("Conditions physiques", a.get("physicalRequirement")),
("Conditions de travail", libres.get("Conditions de travail"))]:
v = str(valeur or "").strip()
if v.lower().rstrip(".") in VIDES or any(v.lower() in u or u in v.lower() for u in vus if u):
continue
vus.append(v.lower())
sortie.append([libelle, v])
return sortie
def fiche_avp(id_avp: str, p) -> dict:
"""Ce qu'un candidat ou un recruteur veut savoir du poste (panneau « En bref »)."""
a = p.avp
lieu = (a.get("jobLocation") or {}).get("address") or {}
metier = a.get("relevantOccupation") or {}
return {
"id": id_avp, "titre": p.titre,
"lieu": lieu.get("addressLocality"),
"province": lieu.get("province") or lieu.get("addressRegion"),
"contrat": CONTRATS.get(a.get("employmentType"), a.get("employmentType")),
"publie": _date(a.get("datePosted")), "cloture": _date(a.get("validThrough")),
"prise_de_poste": _date(a.get("jobStartDate")), "ouvert": est_ouvert(a),
"direction": _capitale((a.get("additionalType") or {}).get("direction")),
"unite": _capitale((a.get("employmentUnit") or {}).get("name")),
"famille": ", ".join(a.get("occupationalCategory") or []) or None,
"metier_code": metier.get("code_metier"), "metier_nom": _capitale(metier.get("name")),
"metier_url": metier.get("fiche_metier_url"), "horaires": a.get("workHours"),
"conditions": conditions_du_poste(a),
"nb_attendus": len(p.attendus), "nb_savoir_faire": int((~p.savoir_etre).sum()),
}
def fiche_cv(index: int | None, cv: dict) -> dict:
"""Ce qu'on affiche du candidat. L'identité (nom, e-mail, téléphone) n'est jamais lue."""
b = cv.get("basics") or {}
poste = (cv.get("work") or [{}])[0] or {}
return {"index": index, "ref": str(cv["ref"]) if cv.get("ref") is not None else None,
"titre": b.get("label") or poste.get("position") or (f"CV {index}" if index is not None else "Mon CV"),
"resume": b.get("summary"), "nb_phrases": len(phrases_du_cv(cv, limite=False))}
def explication(p, phrases, vecs, rr, cv: dict | None = None) -> dict:
"""Le score d'un CV pour un AVP, attendu par attendu (cv : pour les dates des postes des prérequis)."""
s = scoring.scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs,
config.SEUIL_COUVERTURE, savoir_etre=p.savoir_etre, rr=rr)
total = float(np.sum(p.poids)) or 1.0
forces, ecarts, se = [], [], []
obtenus = perdus_sf = perdus_se = 0.0
for d in s.details:
ligne = {"attendu": d.attendu, "phrase": d.phrase_cv, "source": d.source_cv,
"similarite": round(d.similarite_max, 3), "rampe": round(d.degre_rampe, 3),
"reranker": None if d.proba_reranker is None else round(d.proba_reranker, 3),
"degre": round(d.degre, 3),
"points": round(d.poids * d.degre / total * 100, 1),
"perte": round(d.poids * (1 - d.degre) / total * 100, 1),
"couverte": d.couverte}
obtenus += d.poids * d.degre
if d.savoir_etre:
perdus_se += d.poids * (1 - d.degre)
se.append(ligne)
else:
perdus_sf += d.poids * (1 - d.degre)
(forces if d.couverte else ecarts).append(ligne)
forces.sort(key=lambda x: -x["points"])
ecarts.sort(key=lambda x: -x["perte"])
prerequis = scoring.verifier_prerequis(p.prerequis, p.vecs_prerequis, phrases, vecs, cv)
return {
"score": round(100 * s.adequation, 1), # score de classement (tri)
"libelle": scoring.libelle(s.pourcentage_competences), # le libellé suit le pourcentage
"niveau": scoring.niveau(s.pourcentage_competences),
"pourcentage": round(100 * s.pourcentage_competences, 1),
"x": s.nb_savoir_faire_couverts, "n": s.nb_savoir_faire,
"decomposition": {"obtenus": round(obtenus / total * 100, 1),
"perdus_competences": round(perdus_sf / total * 100, 1),
"perdus_savoir_etre": round(perdus_se / total * 100, 1)},
"forces": forces, "ecarts": ecarts, "savoir_etre": se,
"prerequis": [{"prerequis": x["prerequis"], "statut": x["statut"], "motif": x["motif"],
"obligatoire": x["obligatoire"], "phrase": x["indice_cv"],
"mentionne": x["statut"] in ("rempli", "mention_probable")} for x in prerequis],
"fiable": s.fiable, "avertissement": s.avertissement,
}
def _encoder(cv, encodeur, prepares, avec_reranker=True):
"""avec_reranker=False : mode de secours sans carte graphique (bge-m3 et la rampe seuls)."""
phrases = phrases_du_cv(cv)
if not phrases:
return phrases, None, {}
calcul = textes_pour_calcul(phrases) # outils complétés (app/outils.py) ; affichage inchangé
vecs = encodeur.encoder(calcul)
rr = scoring.probas_reranker_avps(prepares, calcul, vecs) if avec_reranker else {}
return phrases, vecs, rr
def expliquer_cv(store, encodeur, cv: dict, inclure_clos: bool = True, avec_reranker: bool = True) -> dict:
"""Côté candidat : un CV face à tous les AVP, classés, chacun avec sa fiche d'explication."""
avps = {i: p for i, p in store.prepares.items() if inclure_clos or p.ouvert}
phrases, vecs, rr = _encoder(cv, encodeur, avps, avec_reranker)
if vecs is None:
raise ValueError("Le CV ne contient aucun texte exploitable.")
postes = [{"avp": fiche_avp(i, p), **explication(p, phrases, vecs, rr.get(i), cv)}
for i, p in avps.items() if len(p.attendus)]
postes.sort(key=lambda x: -x["score"])
for rang, x in enumerate(postes, start=1):
x["rang_pour_cv"] = rang
return {"cv": fiche_cv(None, cv), "nb_avps": len(postes), "postes": postes}
def expliquer_vivier(store, encodeur, id_avp: str, cvs: list[dict], avec_reranker: bool = True) -> dict:
"""Côté recruteur : un AVP face à un vivier de CV, classés, chacun avec sa fiche.
Pour chaque candidat, on situe aussi cet AVP parmi tous les AVP (son poste n° combien)."""
if id_avp not in store.prepares:
raise KeyError(id_avp)
verifier_taille_vivier(cvs)
p = store.prepares[id_avp]
candidats, ecartes = [], []
for k, cv in enumerate(cvs):
try:
phrases, vecs, rr = _encoder(cv, encodeur, store.prepares, avec_reranker)
except ValueError as e: # CV trop long : écarté, le reste du vivier est classé
ecartes.append({"cv": fiche_cv(k, cv), "raison": str(e)})
continue
if vecs is None:
ecartes.append({"cv": fiche_cv(k, cv), "raison": "Aucun texte exploitable dans le CV."})
continue
e = explication(p, phrases, vecs, rr.get(id_avp), cv)
tous = scoring.adequations_tous_avps(store.prepares, vecs, rr)
e["rang_pour_cv"] = 1 + sum(1 for i, v in tous.items() if i != id_avp and v > tous[id_avp])
candidats.append({"cv": fiche_cv(k, cv), **e})
candidats.sort(key=lambda x: -x["score"])
for rang, x in enumerate(candidats, start=1):
x["rang_pour_avp"] = rang
return {"avp": fiche_avp(id_avp, p), "candidats": candidats, "ecartes": ecartes,
"calcule_le": date.today().isoformat()}