"""Front du matching dans la page Gradio : un composant gr.HTML, et un canal pour les calculs.
Deux chemins entre le JavaScript (app/front/front.js) et Python :
- catalogue() fonction serveur du gr.HTML : les AVP et les CV fictifs, sans calcul ;
- le canal les calculs GPU (expliquer un CV, classer les CV pour un AVP).
Pourquoi un canal : ZeroGPU reconnaît le visiteur (son compte, donc son quota) grâce aux
en-têtes X-IP-Token et x-gradio-user que la page Gradio ajoute seulement aux événements de sa
file d'attente. Une fonction serveur n'en profite pas : le visiteur y passe pour anonyme. Le
front dépose donc sa demande (JSON) dans un champ caché et clique sur un bouton caché ; Gradio
traite l'événement par sa file d'attente et écrit la réponse (JSON) dans un autre champ caché.
Mode de secours : si ZeroGPU refuse la carte graphique (quota du visiteur épuisé), le calcul
est refait sur le processeur avec bge-m3 seul, sans reranker (un peu moins précis, mais personne
n'est bloqué). La réponse porte alors "mode": "cpu" et le front l'indique.
"""
from __future__ import annotations
import base64
import json
import logging
import time
from datetime import date
from pathlib import Path
import gradio as gr
from app import config, scoring
from app.explications import expliquer_cv, expliquer_vivier, fiche_avp, fiche_cv
DOSSIER = Path(__file__).resolve().parent / "front"
journal = logging.getLogger("cv_matching.front")
# Bandeau de logos en tête de page, dans cet ordre ; un logo absent de app/front/logos/ est ignoré
LOGOS = [("cv_matching.png", "CV-Matching", None), ("opt.png", "OPT-NC", "https://www.opt.nc"),
("iae.png", "IAE de Nouvelle-Calédonie", None), ("station_n.png", "Station N", None)]
def _logos() -> str:
"""Logos intégrés à la page (data URI) : pas de route de fichiers à ouvrir sur le Space."""
morceaux = []
for nom, alt, lien in LOGOS:
f = DOSSIER / "logos" / nom
if not f.exists():
continue
img = f'
'
morceaux.append(f'{img}'
if lien else f'{img}')
return f'
{"".join(morceaux)}
' if morceaux else ""
HTML = (DOSSIER / "front.html").read_text(encoding="utf-8").replace("", _logos())
JS = (DOSSIER / "front.js").read_text(encoding="utf-8")
def _renforcer(css: str) -> str:
"""Gradio remet à zéro les titres et paragraphes avec « .gradio-container- h1 »,
aussi spécifique que « .avf h1 » et chargé après sur le Space : on préfixe nos règles par
« .gradio-container ». SAUF dans les @media : Gradio y ajoute déjà son propre préfixe
(« .gradio-container.gradio-container- .contain »), et le nôtre en plus ferait
exiger deux .gradio-container imbriqués : les règles téléphone et tablette ne
s'appliqueraient jamais."""
sortie, profondeur, debut = [], 0, 0
for k, c in enumerate(css):
if c == "{":
if profondeur == 0:
tete = css[debut:k]
sortie.append(tete if tete.strip().startswith("@media") else tete.replace(".avf", ".gradio-container .avf"))
sortie.append("{")
debut = k + 1
profondeur += 1
elif c == "}":
profondeur -= 1
if profondeur == 0:
sortie.append(css[debut:k]) # corps (ou règles du @media) tel quel
sortie.append("}")
debut = k + 1
sortie.append(css[debut:])
return "".join(sortie)
CSS = _renforcer((DOSSIER / "front.css").read_text(encoding="utf-8")) + """
/* Canal des calculs : présent dans la page (pour que Gradio le gère) mais invisible */
.gradio-container .avf-canal { position: absolute !important; width: 1px !important; height: 1px !important;
overflow: hidden !important; opacity: 0 !important; pointer-events: none !important; }
"""
DUREES_GPU = {"cv": 60, "avp": 75} # s ; un visiteur sans compte est refusé au-delà d'environ 80
def composant(obtenir_etat, exemples: dict[str, dict], gpu=None, encodeur_cpu=None) -> gr.HTML:
"""À appeler dans un gr.Blocks. obtenir_etat() -> (store, encodeur).
exemples : {libellé: cv} sans réponse attendue. gpu : spaces.GPU sur ZeroGPU, sinon None.
encodeur_cpu() -> Encodeur sur le processeur, pour le mode de secours (None : pas de secours)."""
cvs = list(exemples.values())
def catalogue(donnees=None) -> dict:
store, _ = obtenir_etat()
avps = [fiche_avp(i, p) for i, p in store.prepares.items() if len(p.attendus)]
return {"avps": avps, "aujourd_hui": date.today().isoformat(),
"seuils_libelle": config.SEUILS_LIBELLE,
"juge": {"actif": bool(config.JUGE_SPACE and config.JUGE_TOKEN), "postes": config.JUGE_TOP_POSTES,
"candidats": config.JUGE_TOP_CANDIDATS},
"modeles": config.MODEL_NAME + (" + " + config.RERANKER_MODEL if scoring.RERANKER else ""),
"exemples": [{"index": k, "titre": fiche_cv(k, cv)["titre"], "cv": cv}
for k, cv in enumerate(cvs)]}
def calculer(op: str, args: list, encodeur=None, avec_reranker: bool = True) -> dict:
store, encodeur_gpu = obtenir_etat()
encodeur = encodeur or encodeur_gpu
if op == "cv":
cv_json, inclure_clos = (list(args) + [None, True])[:2]
try:
cv = json.loads(cv_json)
except (TypeError, json.JSONDecodeError) as e:
return {"erreur": f"CV illisible : le texte n'est pas du JSON valide ({getattr(e, 'msg', e)})."}
if not isinstance(cv, dict):
return {"erreur": "CV illisible : un CV JSON Resume est un objet { ... }."}
try:
return expliquer_cv(store, encodeur, cv, bool(inclure_clos), avec_reranker)
except ValueError as e:
return {"erreur": str(e)}
if op == "avp":
id_avp = (list(args) + [None])[0]
try:
return expliquer_vivier(store, encodeur, id_avp,
[dict(cv, ref=f"CV fictif {k:02d}") for k, cv in enumerate(cvs)],
avec_reranker)
except KeyError:
return {"erreur": f"AVP inconnu : {id_avp}"}
except ValueError as e:
return {"erreur": str(e)}
return {"erreur": f"Opération inconnue : {op}"}
def _demande(requete: str) -> dict:
try:
d = json.loads(requete or "{}")
return d if isinstance(d, dict) else {}
except json.JSONDecodeError:
return {}
def calcul_gpu(requete: str) -> str:
d = _demande(requete)
return json.dumps({"id": d.get("id"), "resultat": calculer(d.get("op"), d.get("args") or [])},
ensure_ascii=False)
# Durée demandée à ZeroGPU selon l'opération (fonction de mêmes arguments que calcul_gpu)
calcul = gpu(duration=lambda requete: DUREES_GPU.get(_demande(requete).get("op"), 60))(calcul_gpu) \
if gpu else calcul_gpu
def avis_ia(args: list, ip_token: str | None) -> dict:
"""Deuxième avis IA (app/juge.py) sur les meilleurs résultats déjà affichés. Aucun GPU de ce
Space : le LLM tourne sur JUGE_SPACE, avec le quota du visiteur."""
from app import juge
store, _ = obtenir_etat()
d = (list(args) + [{}])[0] or {}
try:
if d.get("sens") == "candidat":
cv = json.loads(d.get("cv") or "{}")
ids = [i for i in (d.get("avps") or [])[:config.JUGE_TOP_POSTES] if i in store.prepares]
couples = [(i, store.prepares[i].avp, cv) for i in ids]
elif d.get("sens") == "recruteur":
id_avp = d.get("avp")
if id_avp not in store.prepares:
return {"erreur": f"AVP inconnu : {id_avp}"}
index = [int(k) for k in (d.get("cvs") or [])[:config.JUGE_TOP_CANDIDATS] if 0 <= int(k) < len(cvs)]
couples = [(str(k), store.prepares[id_avp].avp, cvs[k]) for k in index]
else:
return {"erreur": "Demande de deuxième avis incomplète."}
if not couples:
return {"erreur": "Rien à relire."}
return {"sens": d.get("sens"), "avis": juge.juger(couples, ip_token)}
except juge.ErreurJuge as e:
return {"erreur": str(e)}
except (TypeError, ValueError, json.JSONDecodeError) as e:
return {"erreur": f"Demande illisible ({e})."}
def traiter(requete: str, request: gr.Request = None) -> str:
"""Si ZeroGPU refuse (quota épuisé, durée trop longue) : mode de secours sur le
processeur s'il existe, sinon le front reçoit un message."""
op, debut = _demande(requete).get("op"), time.perf_counter()
if op == "avis_ia":
d = _demande(requete)
ip = request.headers.get("x-ip-token") if request is not None else None
resultat = avis_ia(d.get("args") or [], ip)
journal.info("page web : avis_ia en %.1f s%s", time.perf_counter() - debut,
f" ({resultat['erreur']})" if "erreur" in resultat else "")
return json.dumps({"id": d.get("id"), "resultat": resultat}, ensure_ascii=False)
try:
reponse = calcul(requete)
journal.info("page web : %s en %.1f s", op, time.perf_counter() - debut)
return reponse
except Exception as e: # gradio.Error levée par ZeroGPU
message = str(e).strip("'\" ")
refus_gpu = any(m in message.lower() for m in ("quota", "duration", "limit", "gpu"))
journal.warning("page web : %s, %s après %.1f s : %s", op, "carte graphique refusée" if refus_gpu
else "erreur", time.perf_counter() - debut, message)
if refus_gpu and encodeur_cpu:
d = _demande(requete)
try:
resultat = calculer(d.get("op"), d.get("args") or [], encodeur_cpu(), avec_reranker=False)
except Exception as e2:
resultat = {"erreur": f"Carte graphique refusée ({message}) et mode de secours "
f"indisponible ({e2}). Réessaie dans une minute."}
if "erreur" not in resultat:
resultat["mode"] = "cpu"
return json.dumps({"id": d.get("id"), "resultat": resultat}, ensure_ascii=False)
if refus_gpu:
message = ("La carte graphique de Hugging Face est refusée pour ce calcul : quota du "
"jour épuisé, ou visiteur non reconnu. Ouvre la page depuis "
"huggingface.co/spaces/Myz0/CV-Matching en étant connecté à ton compte "
f"Hugging Face, ou réessaie plus tard. Détail : {message}")
return json.dumps({"id": _demande(requete).get("id"), "resultat": {"erreur": message}},
ensure_ascii=False)
page = gr.HTML(html_template=HTML, js_on_load=JS, server_functions=[catalogue],
container=False, padding=False, apply_default_css=False)
with gr.Column(elem_classes="avf-canal"):
requete = gr.Textbox(elem_id="avf-requete", show_label=False, container=False, lines=1)
reponse = gr.Textbox(elem_id="avf-reponse", show_label=False, container=False, lines=1)
envoyer = gr.Button("Calculer", elem_id="avf-envoyer")
envoyer.click(traiter, requete, reponse, api_visibility="private", show_progress="hidden")
return page