"""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()}