| from __future__ import annotations |
|
|
| import html |
| import json |
| import os |
| from typing import Any |
|
|
| import gradio as gr |
| import requests |
|
|
|
|
| DEFAULT_API_URL = os.getenv("IDREF_QUALINKA_API_URL", "https://idref-linker.smartbiblia.fr") |
| DEFAULT_API_KEY = os.getenv("IDREF_QUALINKA_API_KEY", "") |
| EMBEDDING_MODEL = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2" |
|
|
| PERSON_FIELDS = [ |
| "author", |
| "advisor", |
| "jury_president", |
| "reviewers", |
| "committee_members", |
| ] |
|
|
| FIELD_LABELS = { |
| "author": "Auteur", |
| "advisor": "Directeur", |
| "jury_president": "President du jury", |
| "reviewers": "Rapporteurs", |
| "committee_members": "Membres du jury", |
| } |
|
|
| EXAMPLE_JSON = """{ |
| "title": "La question de l'hygiène aux Indes-Néerlandaises", |
| "subtitle": "Les enjeux médicaux, culturels et sociaux", |
| "author": "Gani Achmad JAE LANI", |
| "degree_type": "Thèse de doctorat", |
| "discipline": "Histoire et civilisations", |
| "granting_institution": "École des Hautes Études en Sciences Sociales", |
| "co_tutelle_institutions": [], |
| "doctoral_school": "École doctorale de l'EHESS", |
| "defense_year": 2017, |
| "advisor": "Gérard JORLAND", |
| "jury_president": "", |
| "reviewers": "", |
| "committee_members": "Romain BERTRAND|Patrice BOURDELAIS|Charles ILLOUZ|Annick OPINEL|Patrick ZYLBERMAN|Gérard JORLAND", |
| "language": "fre", |
| "confidence": 0.98 |
| }""" |
|
|
|
|
| def split_people(value: Any) -> list[str]: |
| if value is None: |
| return [] |
| if isinstance(value, list): |
| raw_items = value |
| else: |
| raw_items = str(value).split("|") |
| names = [] |
| for item in raw_items: |
| name = str(item).strip() |
| if name: |
| names.append(name) |
| return names |
|
|
|
|
| def normalize_name_key(name: str) -> str: |
| return " ".join(name.lower().split()) |
|
|
|
|
| def parse_extraction_json(json_text: str) -> dict[str, Any]: |
| try: |
| payload = json.loads(json_text) |
| except json.JSONDecodeError as exc: |
| raise gr.Error(f"JSON invalide: {exc}") from exc |
| if not isinstance(payload, dict): |
| raise gr.Error("Le JSON colle doit etre un objet.") |
| return payload |
|
|
|
|
| def extract_people(payload: dict[str, Any]) -> list[dict[str, Any]]: |
| people_by_key: dict[str, dict[str, Any]] = {} |
| for field in PERSON_FIELDS: |
| for name in split_people(payload.get(field)): |
| key = normalize_name_key(name) |
| if key not in people_by_key: |
| people_by_key[key] = {"name": name, "roles": []} |
| if field not in people_by_key[key]["roles"]: |
| people_by_key[key]["roles"].append(field) |
| return list(people_by_key.values()) |
|
|
|
|
| def people_to_rows(people: list[dict[str, Any]]) -> list[list[str]]: |
| rows = [] |
| for person in people: |
| labels = [FIELD_LABELS.get(role, role) for role in person["roles"]] |
| rows.append([person["name"], " | ".join(labels)]) |
| return rows |
|
|
|
|
| def people_to_choices(people: list[dict[str, Any]]) -> list[str]: |
| choices = [] |
| for person in people: |
| labels = [FIELD_LABELS.get(role, role) for role in person["roles"]] |
| choices.append(f"{person['name']} — {' | '.join(labels)}") |
| return choices |
|
|
|
|
| def selected_choice_to_name(choice: str) -> str: |
| return choice.split(" — ", 1)[0].strip() |
|
|
|
|
| def build_align_payload( |
| extraction: dict[str, Any], |
| selected_name: str, |
| use_embeddings: bool, |
| max_candidates: int, |
| max_docs_per_role: int, |
| reference_top_k: int, |
| accept_threshold: float, |
| margin_threshold: float, |
| weight_name: float, |
| weight_attrra_source: float, |
| weight_attrra_note: float, |
| weight_references: float, |
| weight_institution_year: float, |
| ) -> dict[str, Any]: |
| return { |
| "name": selected_name, |
| "title": str(extraction.get("title") or ""), |
| "subtitle": str(extraction.get("subtitle") or ""), |
| "discipline": str(extraction.get("discipline") or ""), |
| "institution": str(extraction.get("granting_institution") or extraction.get("institution") or ""), |
| "doctoral_school": str(extraction.get("doctoral_school") or ""), |
| "degree_type": str(extraction.get("degree_type") or ""), |
| "year": str(extraction.get("defense_year") or extraction.get("year") or ""), |
| "max_candidates": int(max_candidates), |
| "max_docs_per_role": int(max_docs_per_role), |
| "reference_top_k": int(reference_top_k), |
| "embedding_model": EMBEDDING_MODEL if use_embeddings else "", |
| "accept_threshold": float(accept_threshold), |
| "margin_threshold": float(margin_threshold), |
| "weight_name": float(weight_name), |
| "weight_attrra_source": float(weight_attrra_source), |
| "weight_attrra_note": float(weight_attrra_note), |
| "weight_references": float(weight_references), |
| "weight_institution_year": float(weight_institution_year), |
| } |
|
|
|
|
| def status_badge(status: str) -> str: |
| colors = { |
| "accepted": ("#dcfce7", "#166534"), |
| "ambiguous": ("#fef9c3", "#854d0e"), |
| "low_confidence": ("#fee2e2", "#991b1b"), |
| "not_found": ("#e5e7eb", "#374151"), |
| } |
| bg, fg = colors.get(status, ("#e5e7eb", "#374151")) |
| return ( |
| f'<span style="display:inline-block;padding:4px 9px;border-radius:999px;' |
| f'background:{bg};color:{fg};font-weight:700;font-size:13px">{html.escape(status)}</span>' |
| ) |
|
|
|
|
| def score_table(candidate: dict[str, Any] | None) -> str: |
| if not candidate: |
| return "" |
| score = candidate.get("score") or {} |
| rows = [] |
| for key in ["final", "name", "attrra_source", "attrra_note", "references", "institution_year"]: |
| value = score.get(key) |
| value_text = "" if value is None else f"{float(value):.4f}" |
| rows.append( |
| "<tr>" |
| f"<td>{html.escape(key)}</td>" |
| f"<td><strong>{value_text}</strong></td>" |
| "</tr>" |
| ) |
| return ( |
| '<table class="score-table">' |
| "<thead><tr><th>Composante</th><th>Score</th></tr></thead>" |
| "<tbody>" |
| + "".join(rows) |
| + "</tbody></table>" |
| ) |
|
|
|
|
| def evidence_block(candidate: dict[str, Any] | None) -> str: |
| if not candidate: |
| return "" |
| evidence = candidate.get("evidence") or {} |
| forms = evidence.get("preferred_forms") or [] |
| best_refs = evidence.get("best_references") or [] |
|
|
| def value_block(label: str, value: Any) -> str: |
| if value is None or value == []: |
| content = '<span class="muted">Aucun indice</span>' |
| elif isinstance(value, list): |
| content = "<ul>" + "".join(f"<li>{html.escape(str(item))}</li>" for item in value) + "</ul>" |
| else: |
| content = f"<p>{html.escape(str(value))}</p>" |
| return f"<div class='evidence-item'><h4>{label}</h4>{content}</div>" |
|
|
| return ( |
| "<div class='evidence-grid'>" |
| + value_block("Formes preferees", forms) |
| + value_block("Meilleure source attrra", evidence.get("best_attrra_source")) |
| + value_block("Meilleure note attrra", evidence.get("best_attrra_note")) |
| + value_block("Meilleures references", best_refs) |
| + "</div>" |
| ) |
|
|
|
|
| def candidates_table(candidates: list[dict[str, Any]]) -> str: |
| if not candidates: |
| return '<p class="muted">Aucun candidat.</p>' |
| rows = [] |
| for candidate in candidates: |
| score = candidate.get("score") or {} |
| forms = (candidate.get("evidence") or {}).get("preferred_forms") or [] |
| rows.append( |
| "<tr>" |
| f"<td><a href='{html.escape(candidate.get('url') or '')}' target='_blank'>{html.escape(candidate.get('ppn') or '')}</a></td>" |
| f"<td>{html.escape(candidate.get('first_name') or '')}</td>" |
| f"<td>{html.escape(candidate.get('last_name') or '')}</td>" |
| f"<td>{float(score.get('final') or 0):.4f}</td>" |
| f"<td>{html.escape(' | '.join(str(form) for form in forms[:3]))}</td>" |
| "</tr>" |
| ) |
| return ( |
| '<table class="candidates-table">' |
| "<thead><tr><th>PPN</th><th>Prenom</th><th>Nom</th><th>Final</th><th>Formes</th></tr></thead>" |
| "<tbody>" |
| + "".join(rows) |
| + "</tbody></table>" |
| ) |
|
|
|
|
| def score_value(candidate: dict[str, Any], key: str) -> float: |
| try: |
| return max(0.0, min(1.0, float((candidate.get("score") or {}).get(key) or 0.0))) |
| except Exception: |
| return 0.0 |
|
|
|
|
| def weighted_context_score(candidate: dict[str, Any], weights: dict[str, Any]) -> float: |
| components = [ |
| ("attrra_source", "attrra_source"), |
| ("attrra_note", "attrra_note"), |
| ("references", "references"), |
| ("institution_year", "institution_year"), |
| ] |
| weighted_sum = 0.0 |
| weight_sum = 0.0 |
| for score_key, weight_key in components: |
| try: |
| weight = float(weights.get(weight_key, 0.0)) |
| except Exception: |
| weight = 0.0 |
| if weight <= 0.0: |
| continue |
| weighted_sum += weight * score_value(candidate, score_key) |
| weight_sum += weight |
| if weight_sum == 0.0: |
| return sum(score_value(candidate, key) for key, _ in components) / len(components) |
| return weighted_sum / weight_sum |
|
|
|
|
| def candidate_profile_plot(result: dict[str, Any]) -> str: |
| candidates = (result.get("candidates") or [])[:12] |
| if not candidates: |
| return '<p class="muted">Aucun profil candidat a afficher.</p>' |
|
|
| weights = result.get("score_weights") or {} |
| width = 760 |
| height = 420 |
| left = 70 |
| right = 34 |
| top = 28 |
| bottom = 64 |
| plot_w = width - left - right |
| plot_h = height - top - bottom |
| colors = ["#2563eb", "#dc2626", "#16a34a", "#9333ea", "#ea580c", "#0891b2", "#4f46e5", "#be123c"] |
|
|
| def x_pos(value: float) -> float: |
| return left + value * plot_w |
|
|
| def y_pos(value: float) -> float: |
| return top + (1.0 - value) * plot_h |
|
|
| grid = [] |
| for tick in [0.0, 0.25, 0.5, 0.75, 1.0]: |
| x = x_pos(tick) |
| y = y_pos(tick) |
| grid.append(f'<line x1="{x:.1f}" y1="{top}" x2="{x:.1f}" y2="{top + plot_h}" class="plot-grid" />') |
| grid.append(f'<line x1="{left}" y1="{y:.1f}" x2="{left + plot_w}" y2="{y:.1f}" class="plot-grid" />') |
| grid.append(f'<text x="{x:.1f}" y="{top + plot_h + 22}" class="plot-tick">{tick:.2f}</text>') |
| grid.append(f'<text x="{left - 12}" y="{y + 4:.1f}" class="plot-tick" text-anchor="end">{tick:.2f}</text>') |
|
|
| points = [ |
| '<circle cx="{:.1f}" cy="{:.1f}" r="7" fill="#111827"><title>Profil de reference: correspondance parfaite avec le document courant</title></circle>'.format( |
| x_pos(1.0), |
| y_pos(1.0), |
| ), |
| '<text x="{:.1f}" y="{:.1f}" class="plot-label">document courant</text>'.format( |
| x_pos(1.0) - 112, |
| y_pos(1.0) - 10, |
| ), |
| ] |
| legend_rows = [] |
| for idx, candidate in enumerate(candidates): |
| score = candidate.get("score") or {} |
| ppn = str(candidate.get("ppn") or "") |
| label = ppn or f"candidat {idx + 1}" |
| x = score_value(candidate, "name") |
| y = weighted_context_score(candidate, weights) |
| final = float(score.get("final") or 0.0) |
| color = colors[idx % len(colors)] |
| radius = 5.0 + min(7.0, final * 7.0) |
| points.append( |
| '<circle cx="{:.1f}" cy="{:.1f}" r="{:.1f}" fill="{}" fill-opacity="0.82" stroke="#111827" stroke-width="1">' |
| "<title>PPN {} | name {:.3f} | contexte {:.3f} | final {:.3f}</title></circle>".format( |
| x_pos(x), |
| y_pos(y), |
| radius, |
| color, |
| html.escape(label), |
| x, |
| y, |
| final, |
| ) |
| ) |
| points.append( |
| '<text x="{:.1f}" y="{:.1f}" class="plot-point-label">{}</text>'.format( |
| x_pos(x) + 8, |
| y_pos(y) - 8, |
| html.escape(label), |
| ) |
| ) |
| legend_rows.append( |
| "<tr>" |
| f"<td><span class='legend-dot' style='background:{color}'></span>{html.escape(label)}</td>" |
| f"<td>{x:.3f}</td>" |
| f"<td>{y:.3f}</td>" |
| f"<td>{final:.3f}</td>" |
| "</tr>" |
| ) |
|
|
| svg = f""" |
| <svg class="profile-plot" viewBox="0 0 {width} {height}" role="img" aria-label="Carte des profils de similarite"> |
| <rect x="0" y="0" width="{width}" height="{height}" fill="#ffffff" /> |
| {''.join(grid)} |
| <line x1="{left}" y1="{top + plot_h}" x2="{left + plot_w}" y2="{top + plot_h}" class="plot-axis" /> |
| <line x1="{left}" y1="{top}" x2="{left}" y2="{top + plot_h}" class="plot-axis" /> |
| <text x="{left + plot_w / 2:.1f}" y="{height - 18}" class="plot-axis-label">similarite du nom</text> |
| <text x="18" y="{top + plot_h / 2:.1f}" class="plot-axis-label" transform="rotate(-90 18 {top + plot_h / 2:.1f})">similarite contexte documentaire</text> |
| {''.join(points)} |
| </svg> |
| """ |
| return ( |
| '<div class="plot-wrap">' |
| f"{svg}" |
| '<p class="plot-note">Chaque point represente le profil de similarite d un PPN candidat par rapport au document courant. ' |
| "L axe X utilise le score du nom; l axe Y agrege les indices documentaires avec les coefficients actifs.</p>" |
| '<table class="plot-legend"><thead><tr><th>PPN</th><th>Nom</th><th>Contexte</th><th>Final</th></tr></thead>' |
| f"<tbody>{''.join(legend_rows)}</tbody></table>" |
| "</div>" |
| ) |
|
|
|
|
| def render_result(result: dict[str, Any]) -> str: |
| status = result.get("status") or "" |
| best_ppn = result.get("best_ppn") |
| best = result.get("best_candidate") |
| similarity = result.get("similarity") or {} |
| query = result.get("query") or {} |
|
|
| best_html = "" |
| if best: |
| best_html = f""" |
| <section class="panel"> |
| <h3>Meilleur candidat</h3> |
| <p><strong>PPN :</strong> <a href="{html.escape(best.get('url') or '')}" target="_blank">{html.escape(best.get('ppn') or '')}</a></p> |
| <p><strong>Nom :</strong> {html.escape((best.get('first_name') or '') + ' ' + (best.get('last_name') or ''))}</p> |
| {score_table(best)} |
| {evidence_block(best)} |
| </section> |
| """ |
|
|
| return f""" |
| <div class="result"> |
| <section class="panel"> |
| <h3>Decision</h3> |
| <p>{status_badge(status)}</p> |
| <p><strong>PPN accepte :</strong> {html.escape(str(best_ppn)) if best_ppn else '<span class="muted">aucun</span>'}</p> |
| <p><strong>Mode de similarite :</strong> {html.escape(str(similarity.get('type') or ''))} |
| {f" / {html.escape(str(similarity.get('model')))}" if similarity.get('model') else ""}</p> |
| <p><strong>Nom aligne :</strong> {html.escape(str(query.get('name') or ''))}</p> |
| </section> |
| {best_html} |
| <section class="panel"> |
| <h3>Tous les candidats</h3> |
| {candidates_table(result.get('candidates') or [])} |
| </section> |
| <section class="panel"> |
| <h3>Carte des profils de similarite</h3> |
| {candidate_profile_plot(result)} |
| </section> |
| </div> |
| """ |
|
|
|
|
| def parse_json_ui(json_text: str) -> tuple[list[list[str]], gr.Dropdown, str, dict[str, Any]]: |
| payload = parse_extraction_json(json_text) |
| people = extract_people(payload) |
| if not people: |
| return [], gr.Dropdown(choices=[], value=None), "Aucun nom trouve dans les champs personnes.", payload |
| choices = people_to_choices(people) |
| summary = f"{len(people)} personne(s) unique(s) trouvee(s). Selectionnez une personne puis lancez l'alignement." |
| return people_to_rows(people), gr.Dropdown(choices=choices, value=choices[0]), summary, payload |
|
|
|
|
| def align_selected_ui( |
| extraction: dict[str, Any] | None, |
| selected_person: str | None, |
| api_url: str, |
| api_key: str, |
| use_embeddings: bool, |
| max_candidates: int, |
| max_docs_per_role: int, |
| reference_top_k: int, |
| accept_threshold: float, |
| margin_threshold: float, |
| weight_name: float, |
| weight_attrra_source: float, |
| weight_attrra_note: float, |
| weight_references: float, |
| weight_institution_year: float, |
| ) -> tuple[str, str]: |
| if not extraction: |
| raise gr.Error("Collez et analysez d'abord le JSON d'extraction.") |
| if not selected_person: |
| raise gr.Error("Selectionnez une personne a aligner.") |
| selected_name = selected_choice_to_name(selected_person) |
| payload = build_align_payload( |
| extraction, |
| selected_name, |
| use_embeddings, |
| max_candidates, |
| max_docs_per_role, |
| reference_top_k, |
| accept_threshold, |
| margin_threshold, |
| weight_name, |
| weight_attrra_source, |
| weight_attrra_note, |
| weight_references, |
| weight_institution_year, |
| ) |
|
|
| base_url = api_url.rstrip("/") |
| headers = {"Content-Type": "application/json"} |
| if api_key.strip(): |
| headers["X-API-Key"] = api_key.strip() |
|
|
| try: |
| response = requests.post(f"{base_url}/align/person", headers=headers, json=payload, timeout=180) |
| response.raise_for_status() |
| result = response.json() |
| except requests.RequestException as exc: |
| raise gr.Error(f"Erreur lors de l'appel API: {exc}") from exc |
| except ValueError as exc: |
| raise gr.Error("La reponse API n'est pas un JSON valide.") from exc |
|
|
| return render_result(result), json.dumps(result, ensure_ascii=False, indent=2) |
|
|
|
|
| CSS = """ |
| .gradio-container { |
| max-width: 1280px !important; |
| } |
| .muted { |
| color: #6b7280; |
| } |
| .panel { |
| border: 1px solid #e5e7eb; |
| border-radius: 8px; |
| padding: 14px 16px; |
| margin: 12px 0; |
| background: #fff; |
| } |
| .panel h3 { |
| margin-top: 0; |
| } |
| .score-table, |
| .candidates-table { |
| width: 100%; |
| border-collapse: collapse; |
| margin-top: 10px; |
| } |
| .score-table th, |
| .score-table td, |
| .candidates-table th, |
| .candidates-table td { |
| border-bottom: 1px solid #e5e7eb; |
| padding: 7px 8px; |
| text-align: left; |
| vertical-align: top; |
| } |
| .score-table th, |
| .candidates-table th { |
| background: #f9fafb; |
| font-weight: 700; |
| } |
| .evidence-grid { |
| display: grid; |
| grid-template-columns: repeat(2, minmax(0, 1fr)); |
| gap: 10px; |
| margin-top: 12px; |
| } |
| .evidence-item { |
| border: 1px solid #e5e7eb; |
| border-radius: 8px; |
| padding: 10px; |
| background: #f9fafb; |
| } |
| .evidence-item h4 { |
| margin: 0 0 6px 0; |
| } |
| .evidence-item p, |
| .evidence-item ul { |
| margin: 0; |
| } |
| .plot-wrap { |
| overflow-x: auto; |
| } |
| .profile-plot { |
| width: 100%; |
| max-width: 760px; |
| min-width: 560px; |
| display: block; |
| } |
| .plot-grid { |
| stroke: #e5e7eb; |
| stroke-width: 1; |
| } |
| .plot-axis { |
| stroke: #111827; |
| stroke-width: 1.4; |
| } |
| .plot-tick, |
| .plot-label, |
| .plot-point-label, |
| .plot-axis-label { |
| fill: #374151; |
| font-size: 12px; |
| } |
| .plot-axis-label { |
| font-weight: 700; |
| } |
| .plot-point-label { |
| font-size: 11px; |
| } |
| .plot-note { |
| color: #6b7280; |
| font-size: 13px; |
| margin: 8px 0 10px 0; |
| } |
| .plot-legend { |
| width: 100%; |
| max-width: 760px; |
| border-collapse: collapse; |
| } |
| .plot-legend th, |
| .plot-legend td { |
| border-bottom: 1px solid #e5e7eb; |
| padding: 6px 8px; |
| text-align: left; |
| } |
| .legend-dot { |
| display: inline-block; |
| width: 10px; |
| height: 10px; |
| border-radius: 999px; |
| margin-right: 7px; |
| } |
| @media (max-width: 800px) { |
| .evidence-grid { |
| grid-template-columns: 1fr; |
| } |
| } |
| """ |
|
|
|
|
| with gr.Blocks(css=CSS, title="IdRef Qualinka Alignment") as demo: |
| extraction_state = gr.State({}) |
|
|
| gr.Markdown( |
| """ |
| # Alignement IdRef / Qualinka |
| |
| Collez le JSON produit par l'extraction VLM, analysez les personnes, |
| puis lancez l'alignement IdRef personne par personne. |
| """ |
| ) |
|
|
| with gr.Row(): |
| with gr.Column(scale=3): |
| json_input = gr.Code( |
| value=EXAMPLE_JSON, |
| language="json", |
| label="JSON d'extraction", |
| lines=22, |
| ) |
| with gr.Column(scale=2): |
| api_url = gr.Textbox(value=DEFAULT_API_URL, label="URL de l'API IdRef Qualinka") |
| api_key = gr.Textbox(value=DEFAULT_API_KEY, label="API key", type="password") |
| use_embeddings = gr.Checkbox( |
| value=False, |
| label=f"Utiliser le mode embedding ({EMBEDDING_MODEL})", |
| ) |
| with gr.Accordion("Parametres avances", open=False): |
| max_candidates = gr.Slider(1, 100, value=20, step=1, label="Max candidats") |
| max_docs_per_role = gr.Slider(0, 200, value=20, step=1, label="Max references par role") |
| reference_top_k = gr.Slider(1, 20, value=3, step=1, label="Top-k references") |
| accept_threshold = gr.Slider(0.0, 1.0, value=0.65, step=0.01, label="Seuil d'acceptation") |
| margin_threshold = gr.Slider(0.0, 1.0, value=0.08, step=0.01, label="Marge d'ambiguite") |
| gr.Markdown("### Coefficients du score final") |
| weight_name = gr.Slider(0.0, 1.0, value=0.40, step=0.01, label="Poids nom") |
| weight_attrra_source = gr.Slider(0.0, 1.0, value=0.25, step=0.01, label="Poids source attrra") |
| weight_attrra_note = gr.Slider(0.0, 1.0, value=0.15, step=0.01, label="Poids note attrra") |
| weight_references = gr.Slider(0.0, 1.0, value=0.15, step=0.01, label="Poids references") |
| weight_institution_year = gr.Slider(0.0, 1.0, value=0.05, step=0.01, label="Poids institution / annee") |
|
|
| parse_btn = gr.Button("1. Analyser les personnes", variant="primary") |
| parse_status = gr.Markdown() |
|
|
| with gr.Row(): |
| people_table = gr.Dataframe( |
| headers=["Nom", "Roles extraits"], |
| datatype=["str", "str"], |
| label="Personnes uniques extraites", |
| interactive=False, |
| wrap=True, |
| ) |
| selected_person = gr.Dropdown(label="Personne a aligner", choices=[]) |
|
|
| align_btn = gr.Button("2. Lancer l'alignement pour la personne selectionnee", variant="primary") |
|
|
| result_html = gr.HTML(label="Resultat lisible") |
| raw_json = gr.Code(language="json", label="Reponse API brute", lines=18) |
|
|
| parse_btn.click( |
| parse_json_ui, |
| inputs=[json_input], |
| outputs=[people_table, selected_person, parse_status, extraction_state], |
| ) |
|
|
| align_btn.click( |
| align_selected_ui, |
| inputs=[ |
| extraction_state, |
| selected_person, |
| api_url, |
| api_key, |
| use_embeddings, |
| max_candidates, |
| max_docs_per_role, |
| reference_top_k, |
| accept_threshold, |
| margin_threshold, |
| weight_name, |
| weight_attrra_source, |
| weight_attrra_note, |
| weight_references, |
| weight_institution_year, |
| ], |
| outputs=[result_html, raw_json], |
| ) |
| demo.launch(mcp_server=True) |
