Spaces:
Running on Zero
Running on Zero
Download app/front.py from Myz0/CV-Matching: direct link, hf CLI and curl.
- Browser
- Download file 12.3 kB
-
https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/app/front.py
- Command line
-
hf download hf://spaces/Myz0/CV-Matching/app/front.py
-
curl -L -o front.py https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/app/front.py
12.3 kB
| """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'<img alt="{alt}" src="data:image/png;base64,{base64.b64encode(f.read_bytes()).decode()}">' | |
| morceaux.append(f'<a class="logo" href="{lien}" target="_blank" rel="noopener" title="{alt}">{img}</a>' | |
| if lien else f'<span class="logo" title="{alt}">{img}</span>') | |
| return f'<div class="logos" aria-label="CV-Matching et partenaires du projet">{"".join(morceaux)}</div>' if morceaux else "" | |
| HTML = (DOSSIER / "front.html").read_text(encoding="utf-8").replace("<!--LOGOS-->", _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-<version> 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-<version> .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 | |