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