File size: 15,883 Bytes
61e090a
 
 
 
 
 
 
6044352
41ef379
6044352
61e090a
 
 
 
 
 
 
 
 
6044352
61e090a
 
6044352
61e090a
 
 
 
6044352
 
 
 
 
61e090a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6044352
61e090a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6044352
 
61e090a
 
 
 
 
 
a462430
61e090a
 
 
 
 
 
 
 
 
 
 
 
 
6044352
61e090a
 
 
 
 
 
 
 
6044352
61e090a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
e01a936
 
 
 
61e090a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6044352
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
61e090a
 
6044352
 
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
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
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
"""Interface web Gradio, montée sur l'API FastAPI (une seule application, un seul port).



Deux onglets, les deux sens du matching :

  - Candidat  : un CV -> les AVP qui lui correspondent le mieux

  - Recruteur : un AVP -> le vivier de CV classé du plus au moins adapté



Les deux fonctions principales sont aussi exposées en MCP (outils pour un agent

conversationnel) quand l'application est montée avec mcp_server=True. Comme les routes REST,

elles exigent une clé API (en-tête X-API-Key) dès qu'une clé est configurée ; la page web, elle,

reste ouverte à tous (elle passe par son propre canal, app/front.py).

Aucun CV n'est enregistré : pas de "flagging", pas de journalisation du contenu.

"""
from __future__ import annotations

import json
from pathlib import Path

import gradio as gr

from app import config, front, scoring
from app.classement import classer_candidats
from app.matching import matcher
from app.routes_api import cle_valide

DOSSIER_EXEMPLES = Path(__file__).resolve().parent.parent / "exemples"


def _pct(valeur: float) -> int:
    """Pourcentage 0..100 de l'API -> entier, arrondi comme la page web (le libellé y correspond)."""
    return scoring.pourcentage_entier(valeur / 100)


# ---------- Apparence ----------
# Même style que le front de la promotion (zako.nc/avp) : fond gris clair, encre bleu nuit,
# Plus Jakarta Sans, bouton principal bleu marine, onglets en pilule. Le nom et le logo de
# leur produit ne sont pas repris. Passés au lancement (Gradio 6) : THEME et CSS.

THEME = gr.themes.Base(
    font=[gr.themes.GoogleFont("Plus Jakarta Sans", weights=(400, 500, 600, 700, 800)),
          "system-ui", "Segoe UI", "sans-serif"],
    font_mono=[gr.themes.GoogleFont("IBM Plex Mono"), "ui-monospace", "Consolas", "monospace"],
    radius_size=gr.themes.sizes.radius_md,
).set(
    body_background_fill="#f4f6f8", body_background_fill_dark="#0e141d",
    body_text_color="#0f1a2b", body_text_color_dark="#e9eef5",
    body_text_color_subdued="#46536a", body_text_color_subdued_dark="#a9b4c5",
    background_fill_primary="#ffffff", background_fill_primary_dark="#161e2b",
    background_fill_secondary="#ebeef2", background_fill_secondary_dark="#1d2737",
    border_color_primary="#dee3ea", border_color_primary_dark="#2a3546",
    block_background_fill="#ffffff", block_background_fill_dark="#161e2b",
    block_border_color="#dee3ea", block_border_color_dark="#2a3546",
    block_radius="12px", block_shadow="none",
    block_label_text_color="#46536a", block_label_text_color_dark="#a9b4c5",
    block_title_text_color="#46536a", block_title_text_color_dark="#a9b4c5",
    input_background_fill="#ffffff", input_background_fill_dark="#111925",
    input_border_color="#dee3ea", input_border_color_dark="#2a3546",
    input_border_color_focus="#17356b", input_border_color_focus_dark="#6f93d6",
    input_radius="8px",
    button_large_radius="14px", button_medium_radius="14px", button_small_radius="10px",
    button_large_text_weight="700", button_medium_text_weight="700",
    button_primary_background_fill="#17356b", button_primary_background_fill_dark="#3c66b9",
    button_primary_background_fill_hover="#21478d", button_primary_background_fill_hover_dark="#4b76c9",
    button_primary_border_color="#17356b", button_primary_border_color_dark="#3c66b9",
    button_primary_text_color="#ffffff", button_primary_text_color_dark="#ffffff",
    button_secondary_background_fill="#ffffff", button_secondary_background_fill_dark="#161e2b",
    button_secondary_border_color="#dee3ea", button_secondary_border_color_dark="#2a3546",
    button_secondary_text_color="#46536a", button_secondary_text_color_dark="#c3cbd8",
    color_accent="#17356b", color_accent_soft="#e3eaf6", color_accent_soft_dark="#1c2a44",
    checkbox_background_color_selected="#17356b", checkbox_background_color_selected_dark="#3c66b9",
    checkbox_border_color_selected="#17356b", checkbox_border_color_selected_dark="#3c66b9",
    link_text_color="#17356b", link_text_color_dark="#8fb0ea",
    loader_color="#17356b", loader_color_dark="#8fb0ea",
    table_border_color="#dee3ea", table_border_color_dark="#2a3546",
    table_even_background_fill="#ffffff", table_even_background_fill_dark="#161e2b",
    table_odd_background_fill="#f7f9fb", table_odd_background_fill_dark="#1a2331",
)

# La page est le front (app/front/) ; il est en mode clair, comme celui de la promotion.
CSS = front.CSS + "\nfooter { background: #f4f6f8; opacity: .8; }\n"


# ---------- CV d'exemple (tous fictifs, règle du HackAVP) ----------

def _exemples() -> dict[str, dict]:
    """{libellé: cv}. Le champ _profil (réponse attendue) est retiré du CV.

    cv_list.json : CV fictifs du jeu d'évaluation (scripts/evaluer_classement.py).

    cv_demo.json : CV de démonstration (ex. profil parfait), montrés mais jamais évalués."""
    cvs = []
    for nom in ("cv_list.json", "cv_demo.json"):
        chemin = DOSSIER_EXEMPLES / nom
        if chemin.exists():
            cvs += json.loads(chemin.read_text(encoding="utf-8"))
    sortie = {}
    for i, cv in enumerate(cvs):
        cv = dict(cv)
        cv.pop("_profil", None)
        label = (cv.get("basics") or {}).get("label") or f"CV {i}"
        sortie[f"{i:02d} · {label}"] = cv
    return sortie


EXEMPLES = _exemples()


def _vivier_exemple() -> str:
    cvs = [dict(cv, ref=nom) for nom, cv in EXEMPLES.items()]
    return json.dumps(cvs, ensure_ascii=False, indent=1)


def _md(texte: str | None, n: int = 140) -> str:
    """Texte sûr dans un tableau Markdown : pas de |, pas de retour à la ligne, tronqué."""
    t = " ".join(str(texte or "").split()).replace("|", "/")
    return t if len(t) <= n else t[: n - 1] + "…"


_obtenir_etat = None   # fixé par construire() : () -> (store, encodeur)


# ---------- Côté candidat ----------


def matcher_cv(cv_json: str, inclure_clos: bool = False) -> str:
    """Trouve les AVP de l'OPT-NC qui correspondent le mieux à un CV, avec explications.



    Args:

        cv_json: le CV au format JSON Resume (texte JSON).

        inclure_clos: inclure les AVP dont la date limite de candidature est dépassée.



    Returns:

        Un rapport Markdown : pour chaque AVP, le score sur 100, les points forts

        (attendu de l'AVP et ligne du CV qui y répond) et les écarts principaux.

    """
    store, encodeur = _obtenir_etat()
    try:
        cv = json.loads(cv_json)
    except json.JSONDecodeError as e:
        return f"**CV illisible** : le texte n'est pas du JSON valide ({e.msg}, ligne {e.lineno})."
    if not isinstance(cv, dict):
        return "**CV illisible** : un CV JSON Resume est un objet `{...}`."
    try:
        rep = matcher(cv, store, encodeur, config.SEUIL_COUVERTURE, top=5,
                      inclure_fermes=inclure_clos)
    except ValueError as e:
        return f"**{e}**"

    if not rep.resultats:
        return ("**Aucun AVP ouvert en ce moment.** Toutes les dates limites du dataset "
                "sont dépassées : cochez « Inclure les AVP clos » pour voir le matching "
                "sur les offres récentes.")

    lignes = [f"*{rep.nb_avps_analyses} AVP analysés · modèle `{rep.modele}`*\n"]
    for k, r in enumerate(rep.resultats, start=1):
        statut = "ouvert" if r.ouvert else "**clos**"
        date = f" jusqu'au {r.date_limite}" if r.date_limite else ""
        lien = f" · [fiche métier {r.code_metier}]({r.fiche_metier_url})" if r.fiche_metier_url else ""
        lignes.append(f"### {k}. {r.titre} — {r.libelle} · {_pct(r.pourcentage_competences)} % "
                      "des compétences du poste")
        lignes.append(f"`{r.id_avp}` · {statut}{date} · **{r.nb_savoir_faire_couverts} / "
                      f"{r.nb_savoir_faire} compétences** · score de classement "
                      f"{round(100 * r.score_qualite)}/100{lien}")
        if r.avertissement:
            lignes.append(f"\n> ⚠ {r.avertissement}")
        if r.competences_couvertes:
            lignes.append("\n| Point fort (attendu de l'AVP) | Ce qui y répond dans le CV |\n|---|---|")
            lignes += [f"| {_md(c.attendu)} | {_md(c.trouve_dans_cv)} *({c.source_cv})* |"
                       for c in r.competences_couvertes[:3]]
        if r.ecarts:
            lignes.append("\n**Écarts principaux** (attendus que le CV ne couvre pas) :")
            lignes += [f"- {_md(e.attendu, 200)}" for e in r.ecarts[:3]]
        if r.savoir_etre:
            lignes.append("\n**Savoir-être attendus** (à montrer en entretien) : " + " ; ".join(
                _md(s.attendu, 60) + (" ✓" if s.statut == "mention_probable" else "")
                for s in r.savoir_etre))
        lignes.append("")
    lignes.append("*✓ = le CV semble déjà l'évoquer. Les savoir-être comptent dans le score.*")
    return "\n".join(lignes)

# ---------- Côté recruteur ----------

def classer_vivier(id_avp: str, cvs_json: str) -> str:
    """Classe un vivier de CV pour un AVP de l'OPT-NC, du plus au moins adapté.



    Args:

        id_avp: identifiant de l'AVP, par exemple "3134-26-1264/SR".

        cvs_json: liste de CV au format JSON Resume (texte JSON). Un champ "ref"

            optionnel par CV permet de retrouver le candidat.



    Returns:

        Un rapport Markdown : classement avec score sur 100, puis forces, écarts et

        prérequis à vérifier pour les premiers candidats.

    """
    store, encodeur = _obtenir_etat()
    try:
        cvs = json.loads(cvs_json)
    except json.JSONDecodeError as e:
        return f"**Vivier illisible** : JSON invalide ({e.msg}, ligne {e.lineno})."
    if not isinstance(cvs, list) or not cvs:
        return "**Vivier illisible** : il faut une liste `[ {...}, {...} ]` d'au moins un CV."
    try:
        r = classer_candidats(id_avp, cvs, store, encodeur,
                              seuil=config.SEUIL_COUVERTURE, top=len(cvs))
    except KeyError:
        return f"**AVP inconnu** : `{id_avp}`."
    except ValueError as e:                      # vivier trop grand
        return f"**Vivier refusé** : {e}"

    lignes = [f"## {r.titre}",
              f"`{r.id_avp}` · {'ouvert' if r.avp_ouvert else '**clos**'} · "
              f"{r.nb_attendus} attendus notés",
              "\n**Attendus les plus discriminants** (rares parmi les AVP, donc décisifs) : "
              + " ; ".join(_md(a, 80) for a in r.attendus_les_plus_discriminants),
              "\n| Rang | Candidat | Avis | % du poste | Compétences | Score /100 | "
              "Spécificité | Cet AVP est son n° | Remarque |",
              "|---|---|---|---|---|---|---|---|---|"]
    for c in r.candidats:
        remarques = []
        if c.ex_aequo_avec_precedent:
            remarques.append("ex aequo")
        if not c.fiable:
            remarques.append("peu fiable")
        if c.specificite < 0:
            remarques.append("correspond mieux à d'autres AVP")
        elif c.specificite < 5:
            remarques.append("profil peu ciblé")
        lignes.append(f"| {c.rang} | {_md(c.ref or f'CV {c.index}', 50)} | {c.libelle} | "
                      f"**{_pct(c.pourcentage_competences)} %** | {c.nb_savoir_faire_couverts} / "
                      f"{c.nb_savoir_faire} | {c.score:.0f} | {c.specificite:+.0f} | "
                      f"{c.rang_de_cet_avp_pour_le_candidat} | {', '.join(remarques)} |")
    if r.ecartes:
        lignes.append("\n**Écartés** : " + " ; ".join(
            f"{_md(e.ref or f'CV {e.index}', 50)} ({e.raison})" for e in r.ecartes))

    for c in r.candidats[:3]:
        lignes.append(f"\n### {c.rang}. {_md(c.ref or f'CV {c.index}', 80)} — {c.libelle} · "
                      f"{_pct(c.pourcentage_competences)} % des compétences du poste "
                      f"({c.nb_savoir_faire_couverts} / {c.nb_savoir_faire}, score de classement "
                      f"{c.score:.0f}/100)")
        if c.avertissement:
            lignes.append(f"> ⚠ {c.avertissement}")
        # "\n" avant chaque titre : sinon Markdown le rattache au dernier point de la liste
        if c.forces:
            lignes.append("\n**Forces**")
            lignes += [f"- {_md(f.attendu)} ← « {_md(f.phrase_cv)} » *({f.source_cv})*"
                       for f in c.forces]
        if c.ecarts:
            lignes.append("\n**Écarts**")
            lignes += [f"- {_md(e.attendu)}" for e in c.ecarts]
        if c.savoir_etre:
            lignes.append("\n**Savoir-être à vérifier en entretien** : " + " ; ".join(
                _md(s.attendu, 60) + (" (évoqué dans le CV)" if s.statut == "mention_probable" else "")
                for s in c.savoir_etre))
        if c.prerequis:
            etats = {"rempli": "✓", "non_rempli": "✗", "mention_probable": "✓ ?", "a_verifier": "?"}
            lignes.append("\n**Prérequis** (jamais notés ni éliminatoires, le recruteur décide) : " + " ; ".join(
                f"{etats.get(p.statut, '?')} {_md(p.prerequis, 60)}" + (f" ({_md(p.motif, 70)})" if p.motif else "")
                + ("" if p.obligatoire else " — apprécié") for p in c.prerequis))
    lignes.append("\n*Spécificité = score sur cet AVP moins le score habituel du candidat sur "
                  "les autres AVP. Proche de 0 : le CV obtient le même score partout.*")
    return "\n".join(lignes)

def construire(obtenir_etat, gpu=None, encodeur_cpu=None):
    """obtenir_etat() -> (store, encodeur), disponibles une fois le service démarré.

    gpu : décorateur spaces.GPU sur Hugging Face ZeroGPU (app_zerogpu.py) ; None en local,

    où le GPU, s'il existe, est toujours disponible.

    encodeur_cpu() -> Encodeur sur le processeur : mode de secours du front si ZeroGPU refuse.



    La page est le front (app/front.py). matcher_cv et classer_candidats restent exposés pour

    les programmes (API Gradio) et les agents (MCP), avec leur réponse Markdown habituelle."""
    global _obtenir_etat
    _obtenir_etat = obtenir_etat
    # Durées maximales demandées à ZeroGPU : classer 23 CV relit ~37 000 paires
    fn_matcher = gpu(duration=60)(matcher_cv) if gpu else matcher_cv
    fn_classer = gpu(duration=75)(classer_vivier) if gpu else classer_vivier

    # Clé vérifiée AVANT de demander la carte graphique : un appel refusé ne coûte rien.
    # gr.Header : Gradio lit l'en-tête X-API-Key de la requête (API Gradio et MCP) ; l'outil MCP
    # le déclare comme en-tête requis, sans l'ajouter aux paramètres visibles par l'agent.
    def matcher_cv_api(cv_json: str, inclure_clos: bool = False, x_api_key: gr.Header = None) -> str:
        if not cle_valide(x_api_key):
            raise gr.Error("Clé API manquante ou invalide (en-tête X-API-Key).")
        return fn_matcher(cv_json, inclure_clos)

    def classer_vivier_api(id_avp: str, cvs_json: str, x_api_key: gr.Header = None) -> str:
        if not cle_valide(x_api_key):
            raise gr.Error("Clé API manquante ou invalide (en-tête X-API-Key).")
        return fn_classer(id_avp, cvs_json)

    # Le nom et la description des outils MCP viennent de __name__ et __doc__
    matcher_cv_api.__doc__, classer_vivier_api.__doc__ = matcher_cv.__doc__, classer_vivier.__doc__
    matcher_cv_api.__name__, classer_vivier_api.__name__ = "matcher_cv", "classer_candidats"

    with gr.Blocks(title="HackAVP · Matching CV ↔ AVP", analytics_enabled=False) as demo:
        front.composant(obtenir_etat, EXEMPLES, gpu=gpu, encodeur_cpu=encodeur_cpu)
        gr.api(matcher_cv_api, api_name="matcher_cv")
        gr.api(classer_vivier_api, api_name="classer_candidats")

    return demo