Spaces:
Running on Zero
Running on Zero
File size: 9,540 Bytes
61e090a 6044352 8324111 61e090a e01a936 61e090a e01a936 61e090a 6044352 61e090a e01a936 61e090a e01a936 61e090a 6044352 61e090a e01a936 61e090a 8324111 61e090a e01a936 61e090a 6044352 61e090a 6044352 61e090a e01a936 61e090a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 | """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()}
|