Spaces:
Running on Zero
Running on Zero
File size: 16,508 Bytes
e01a936 6044352 a462430 6044352 e01a936 28b9c03 e01a936 6044352 e01a936 | 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 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 | """Tests du moteur de score, sans télécharger bge-m3 ni le dataset.
On remplace bge-m3 par un encodeur factice (trigrammes de caractères) : les scores
absolus ne ressemblent pas à ceux de bge-m3, mais la logique (extraction, poids,
tri, explications, routes) est vérifiée. Lancer : python -m tests.test_scoring
"""
import numpy as np
from app import config, scoring
from tests.factices import AVPS, CVS, SOFT, Encodeur
# Rampe adaptée à l'encodeur factice (ses similarités sont plus basses que celles de bge-m3)
scoring.SIM_BAS, scoring.SIM_HAUT = 0.15, 0.55
import copy
from datetime import date
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.avp_store import (AVPStore, CHAMPS_ATTENDUS, est_ouvert, est_savoir_etre, extraire,
texte_embedding)
from app.classement import classer_candidats
from app.matching import matcher
from app.routes_api import ajouter_routes
enc = Encodeur(); store = AVPStore(enc); store.installer(AVPS)
# 1. Extraction : contexte exclu des attendus, prérequis séparés, doublon normalisé
a = extraire({"experienceRequirements": "Expérience X.", "educationRequirements": {"competencyRequired": ["Expérience X"]}}, CHAMPS_ATTENDUS)
assert len(a) == 1, a
p = store.prepares["3134-26-1269/SR"]
assert all(c not in ("title", "description", "qualifications") for _, c in p.attendus)
assert [t for t, _ in p.prerequis] == ["Permis B", "Bac+3"], p.prerequis
assert [t for t, _ in store.prepares["3134-26-1270/SR"].prerequis][:2] == ["Permis B", "A2"]
assert "Permis B" in texte_embedding(AVPS[0])
# 2. Spécificité : les soft skills communs aux 4 AVP pèsent moins que les compétences métier
idx = {t: k for k, (t, _) in enumerate(p.attendus)}
w_soft = p.poids[idx["Maîtrise de soi"]]; w_metier = p.poids[idx["Droit du travail et fonction publique"]]
print(f"poids 'Maîtrise de soi' = {w_soft:.3f} vs 'Droit du travail...' = {w_metier:.3f}")
assert w_soft < 0.2 and w_metier > 0.9 # n=4 AVP : log(5/4)/log(5)=0.14
# 3. validThrough
assert not store.prepares["3134-26-1267/SR"].ouvert
assert est_ouvert({"validThrough": "2026-10-07T00:00:00"}, date(2026, 10, 7))
# 4. Classement côté recruteur
for id_avp, bon in [("3134-26-1269/SR", 0), ("3134-26-1268/SR", 1), ("3134-26-1270/SR", 2)]:
r = classer_candidats(id_avp, CVS, store, enc, seuil=0.35)
ordre = [(c.index, c.score, c.specificite, c.rang_de_cet_avp_pour_le_candidat) for c in r.candidats]
print(r.titre, "->", ordre, "| écartés:", [e.index for e in r.ecartes])
assert r.candidats[0].index == bon
cuisinier = next(c for c in r.candidats if c.index == 3)
assert cuisinier.score < r.candidats[0].score - 15, "le hors-domaine doit être loin derrière"
assert r.ecartes[0].index == 4
r = classer_candidats("3134-26-1270/SR", CVS, store, enc, seuil=0.35)
top = r.candidats[0]
print("forces facteur:", [(f.attendu, f.phrase_cv, f.source_cv) for f in top.forces])
print("prérequis facteur:", [(x.prerequis, x.statut) for x in top.prerequis])
print("plus discriminants:", r.attendus_les_plus_discriminants)
# 5. Identité jamais utilisée : changer le nom ne change rien
cv2 = copy.deepcopy(CVS[0]); cv2["basics"]["name"] = "Quelqu'un d'autre"
s1 = classer_candidats("3134-26-1269/SR", [CVS[0]], store, enc, 0.35).candidats[0].score
s2 = classer_candidats("3134-26-1269/SR", [cv2], store, enc, 0.35).candidats[0].score
assert s1 == s2
# 6. Côté candidat : schémas existants, AVP fermé exclu par défaut
rm = matcher(CVS[0], store, enc, seuil=0.35, top=10)
print("matching juriste:", [(x.titre, x.score_qualite, x.score_global) for x in rm.resultats])
assert rm.resultats[0].id_avp == "3134-26-1269/SR"
assert all(x.id_avp != "3134-26-1267/SR" for x in rm.resultats) and rm.nb_avps_analyses == 3
assert len(matcher(CVS[0], store, enc, 0.35, 10, inclure_fermes=True).resultats) == 4
# 7. Route HTTP (id avec "/")
app = FastAPI(); ajouter_routes(app, lambda: (store, enc))
c = TestClient(app)
resp = c.post("/avps/3134-26-1268/SR/candidats?top=3", json={"cvs": CVS})
assert resp.status_code == 200, resp.text
print("HTTP:", [(x["index"], x["score"], x["ex_aequo_avec_precedent"]) for x in resp.json()["candidats"]])
assert c.post("/avps/inconnu/candidats", json={"cvs": CVS}).status_code == 404
assert c.post("/avps/3134-26-1268/SR/candidats", json={"cvs": []}).status_code == 422
# 7 bis. /score : un CV face à UN AVP (cas d'une candidature), même score que le classement
resp = c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]})
assert resp.status_code == 200, resp.text
r = resp.json()
assert r["score"] == classer_candidats("3134-26-1269/SR", [CVS[0]], store, enc, 0.35).candidats[0].score
assert r["libelle"] and r["niveau"] and 0 <= r["pourcentage"] <= 100 and r["nb_competences"] > 0
print("score:", r["titre"], r["score"], r["pourcentage"], r["libelle"], f'{r["competences_couvertes"]}/{r["nb_competences"]}')
assert c.post("/score", json={"reference": "inconnu", "cv": CVS[0]}).status_code == 404
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": {}}).status_code == 422
# 7 ter. Clé API : exigée sur les routes de calcul quand elle est configurée, pas sur /avps
config.API_KEY = "cle-de-test"
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]}).status_code == 401
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]},
headers={"X-API-Key": "mauvaise"}).status_code == 401
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]},
headers={"X-API-Key": "cle-de-test"}).status_code == 200
assert c.post("/avps/3134-26-1268/SR/candidats", json={"cvs": CVS}).status_code == 401
assert c.get("/avps").status_code == 200
config.API_KEY = None
# 8. Refresh atomique : un AVP qui disparaît sort du cache
store.installer(AVPS[:3]); assert "3134-26-1267/SR" not in store.prepares and len(store._cache) == 3
# 9. Savoir-être : repérés pour l'affichage, mais toujours comptés dans le score
assert est_savoir_etre("Être rigoureux", "skills") and est_savoir_etre("Autonomie", "skills")
assert est_savoir_etre("Faire preuve de discrétion", "skills")
assert not est_savoir_etre("Savoir rédiger", "skills")
assert not est_savoir_etre("Construire un diagnostic", "skills")
assert not est_savoir_etre("Autonomie", "responsibilities") # seul le champ skills
p = store.prepares["3134-26-1270/SR"]
assert int(p.savoir_etre.sum()) == len(SOFT), [t for (t, _), se in zip(p.attendus, p.savoir_etre) if se]
rm = matcher(CVS[2], store, enc, seuil=0.35, top=1)
r0 = rm.resultats[0]
assert r0.nb_savoir_faire == r0.nb_competences - len(SOFT) and len(r0.savoir_etre) == len(SOFT)
assert all(c.attendu not in SOFT for c in r0.competences_couvertes + r0.ecarts)
print("facteur :", r0.libelle, f"{r0.nb_savoir_faire_couverts}/{r0.nb_savoir_faire}",
[(s.attendu, s.statut) for s in r0.savoir_etre])
# 10. Reranker : la couverture d'un attendu est la meilleure des deux notes (rampe, reranker)
class RerankerFactice:
nom = "factice"
def probas(self, paires):
return np.array([1.0 if "scooter" in a.lower() and "scooter" in b.lower() else 0.0
for a, b in paires], dtype=np.float32)
phrases = [("Facteur", "work[0]"), ("Tournée en deux-roues (scooter)", "work[0].highlights[0]"),
("Ponctualité", "skills[0]")] * 2
vecs = enc.encoder([t for t, _ in phrases])
sans = scoring.scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs, 0.5)
assert scoring.probas_reranker_avps({"x": p}, [t for t, _ in phrases], vecs) == {} # pas de reranker
scoring.RERANKER = RerankerFactice()
try:
rr = scoring.probas_reranker_avps(store.prepares, [t for t, _ in phrases], vecs)
assert set(rr) == set(store.prepares) # un seul appel, tous les AVP
avec = scoring.scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs, 0.5,
rr=rr["3134-26-1270/SR"])
finally:
scoring.RERANKER = None
d = next(x for x in avec.details if x.attendu == "Conduire un scooter en sécurité")
assert d.degre == 1.0 and "scooter" in d.phrase_cv, d
assert avec.adequation > sans.adequation
assert all(a.degre >= s.degre for a, s in zip(avec.details, sans.details)) # jamais pire
print(f"reranker factice : {100 * sans.adequation:.1f} -> {100 * avec.adequation:.1f}")
# 11. Explications du front : points obtenus = score, obtenus + perdus = 100
from app.explications import expliquer_cv, expliquer_vivier
r = expliquer_cv(store, enc, CVS[2])
p0 = r["postes"][0]
d = p0["decomposition"]
assert p0["avp"]["id"] == "3134-26-1270/SR" and p0["rang_pour_cv"] == 1
assert abs(d["obtenus"] - p0["score"]) < 0.2, (d, p0["score"])
assert abs(sum(d.values()) - 100) < 0.3, d
assert all(f["attendu"] not in SOFT for f in p0["forces"] + p0["ecarts"])
# Pourcentage affiché = points obtenus sur les compétences / points possibles sur les compétences
sf = p0["forces"] + p0["ecarts"]
attendu_pct = 100 * sum(x["points"] for x in sf) / sum(x["points"] + x["perte"] for x in sf)
assert abs(p0["pourcentage"] - attendu_pct) < 0.5 and p0["pourcentage"] >= p0["score"] - 0.1, (p0["pourcentage"], attendu_pct)
assert rm.resultats[0].pourcentage_competences >= 0
v = expliquer_vivier(store, enc, "3134-26-1270/SR", CVS)
assert v["candidats"][0]["cv"]["index"] == 2 and v["ecartes"][0]["cv"]["index"] == 4
print("explications :", p0["score"], d)
# 12. Niveaux lus sur le pourcentage AFFICHÉ (arrondi comme la page) : le mot suit le chiffre
assert scoring.niveau(0.40) == "adapte" and scoring.libelle(0.40) == "Profil adapté"
assert scoring.niveau(0.2150) == "adapte" # API 21,5 -> page « 22 % » -> adapté, comme affiché
assert scoring.niveau(0.2144) == "a_etudier" and scoring.libelle(0.18) == "Profil à étudier"
assert scoring.niveau(0.1644) == "peu_adapte" and scoring.libelle(0.05) == "Profil peu adapté"
assert scoring.pourcentage_entier(0.3246) == 33 and scoring.pourcentage_entier(0.3244) == 32
assert p0["niveau"] == scoring.niveau(p0["pourcentage"] / 100), p0["niveau"]
rc = classer_candidats("3134-26-1270/SR", CVS, store, enc, 0.35)
assert all(c.niveau == scoring.niveau(c.pourcentage_competences / 100) for c in rc.candidats)
# 13. Outils (ROME) : une phrase qui cite un outil est complétée pour le calcul, les autres non
from app.outils import completer_outils, textes_pour_calcul
c = completer_outils("Excel, Word, PowerPoint")
assert c.startswith("Excel, Word, PowerPoint (") and "bureautiques" in c, c
assert "SAP" in completer_outils("Gestion des stocks sur SAP")[len("Gestion des stocks sur SAP"):]
for t in ("Gestion des stocks et inventaires", "Cuisine traditionnelle et pâtisserie", "Analyse des risques"):
assert completer_outils(t) == t, t # pas d'outil : phrase intacte
assert completer_outils("Maîtrise du Pack Office") != "Maîtrise du Pack Office"
assert textes_pour_calcul([("Word et Excel", "skills[0]")])[0] != "Word et Excel"
config.OUTILS_ROME = False
assert completer_outils("Excel, Word") == "Excel, Word" # désactivable
config.OUTILS_ROME = True
print("outils :", c[:90], "…")
# 14. Prérequis par règles : niveaux de diplôme, permis et équivalences, années ; jamais notés
from app.avp_store import _decouper_prerequis
from app.prerequis import verifier_par_regles as regle
assert _decouper_prerequis("Permis B obligatoire. Permis A2 et aptitude au scooter appréciés.") == \
["Permis B obligatoire", "Permis A2 et aptitude au scooter appréciés"]
master = [("Master Informatique Université", "education[0]")]
bts = [("BTS Services informatiques", "education[0]")]
assert regle("Bac+3", None, master)["statut"] == "rempli"
r = regle("Bac+3", None, bts)
assert r["statut"] == "non_rempli" and r["motif"] == "Bac+2 pour Bac+3 demandé", r
assert regle("Bac", None, bts)["statut"] == "rempli"
assert regle("Bac+3", None, [("Développement Java", "work[0].highlights[0]")])["statut"] == "a_verifier"
assert regle("Bac+3", None, [("Licence", "formation")])["statut"] == "rempli" # CV du hub (structure libre)
assert regle("Bac+3", None, [("BTS SIO", "formations[0].diplome")])["statut"] == "non_rempli"
assert regle("Bac+3", None, [("Licence de mathématiques", "experiences[0].poste")])["statut"] == "a_verifier"
permis = [("Permis : permis B, permis poids lourd", "skills[0]"), ("Logistique : CACES 1, 3 et 5", "skills[1]"),
("Distribution en scooter du courrier", "work[0].highlights[0]")]
for condition in ("Permis VL", "PL et cariste", "Permis de conduire B", "aptitude à la conduite d'un deux roues (scooter)",
"obligation d'utiliser un véhicule de service"):
assert regle(condition, None, permis)["statut"] == "rempli", condition
assert regle("A2", None, permis)["statut"] == "a_verifier" # absent du CV : à vérifier, jamais « non rempli »
assert regle("A2", None, [("Permis : permis B, permis A2", "skills[0]")])["statut"] == "rempli"
assert regle("Permis B souhaité", None, permis)["obligatoire"] is False
annees = [("6 ans en administration d'applications SI", "basics.summary")]
r = regle("2 ans d'expérience dans une activité similaire", None, annees)
assert r["statut"] == "rempli" and "activité similaire à vérifier" in r["motif"], r
assert regle("3 ans d'expérience", None, [("1 an en développement web", "basics.summary")])["statut"] == "non_rempli"
cv_dates = {"work": [{"startDate": "2018-01-01", "endDate": "2023-01-01"}]}
assert regle("3 ans d'expérience", cv_dates, [("Développeur", "work[0]")])["statut"] == "rempli"
assert regle("Habilitation électrique", None, permis) is None # aucune règle : rapprochement bge-m3
pf = [(x.prerequis, x.statut) for x in top.prerequis]
assert ("Permis B", "a_verifier") in pf or ("Permis B", "rempli") in pf, pf
print("prérequis :", r["motif"], "|", pf)
# 15. Conditions du poste (affichées, jamais notées) : horaires pas répétés, valeurs vides ignorées
from app.explications import conditions_du_poste
avp_c = {"workHours": "Du lundi au vendredi, 7h30-16h30",
"eligibilityToWorkRequirement": "10 ans de résidence en Nouvelle-Calédonie",
"specialCommitments": "Du lundi au vendredi, 7h30-16h30", # = horaires : pas répété
"physicalRequirement": "Néant", # vide : ignoré
"additionalType": {"informationsLibres": [{"name": "Conditions de travail", "value": "Travail en extérieur"},
{"name": "Durée de résidence exigée", "value": "5 ans"}]}}
assert conditions_du_poste(avp_c) == [["Durée de résidence", "10 ans de résidence en Nouvelle-Calédonie"],
["Conditions de travail", "Travail en extérieur"]], conditions_du_poste(avp_c)
assert conditions_du_poste({"additionalType": {"informationsLibres": [{"name": "Durée de résidence exigée",
"value": "5 ans"}]}}) == [["Durée de résidence", "5 ans"]]
assert conditions_du_poste({}) == []
# 16. Limites des demandes : CV trop long refusé (ou écarté d'un vivier), vivier trop grand refusé
from app.cv_texte import phrases_du_cv, verifier_taille_vivier
cv_long = {"basics": {"label": "Juriste", "summary": "droit " * (config.MAX_CARACTERES_CV // 6 + 1)}}
try:
phrases_du_cv(cv_long); raise AssertionError("CV trop long accepté")
except ValueError as e:
assert "trop long" in str(e)
assert phrases_du_cv(cv_long, limite=False) # fiche du CV : pas de limite
try:
verifier_taille_vivier([{}] * (config.MAX_CV_VIVIER + 1)); raise AssertionError("vivier trop grand accepté")
except ValueError as e:
assert "Vivier trop grand" in str(e)
rv = classer_candidats("3134-26-1270/SR", [CVS[2], cv_long], store, enc, 0.35)
assert len(rv.candidats) == 1 and "trop long" in rv.ecartes[0].raison, rv.ecartes
v2 = expliquer_vivier(store, enc, "3134-26-1270/SR", [CVS[2], cv_long])
assert len(v2["candidats"]) == 1 and "trop long" in v2["ecartes"][0]["raison"]
print("limites : CV de", sum(len(t) for t, _ in phrases_du_cv(cv_long, limite=False)), "caractères écarté")
print("\nTOUS LES TESTS PASSENT")
|