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