Ajout d’une version anglaise

.gitattributes

@@ -41,5 +41,3 @@ application_neo4j/static/notice/notice_html/media/image2.png filter=lfs diff=lfs
 application_neo4j/static/notice/notice_html/media/image4.png filter=lfs diff=lfs merge=lfs -text
 application_neo4j/static/notice/notice.docx filter=lfs diff=lfs merge=lfs -text
 application_neo4j/static/notice/notice.pdf filter=lfs diff=lfs merge=lfs -text
-opengds/*.jar filter=lfs diff=lfs merge=lfs -text
-application_neo4j/static/notice/notice_en.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,3 +1,2 @@
 __pycache__/
 *.pyc
-.venv/

Dockerfile

@@ -4,9 +4,7 @@ FROM neo4j:2025.09.0-community
 RUN mkdir -p /backups
 RUN chmod 640 /var/lib/neo4j/conf/neo4j.conf
 RUN chmod 640 /var/lib/neo4j/conf/neo4j-admin.conf
-ENV NEO4J_PLUGINS='[]'
-ENV NEO4J_dbms_security_procedures_unrestricted='gds.*'
-COPY opengds/open-gds-2.22.0-genmod.jar /var/lib/neo4j/plugins/graph-data-science.jar
+ENV NEO4J_PLUGINS='["graph-data-science"]'
 
 # python
 RUN apt-get update \

application_neo4j/README.md

@@ -130,26 +130,3 @@ Lors de son lancement, le Space charge un export de la base de données neo4j de
 
 Puisque le dataset est privé sur Hugging Face, le Space utilise un secret `HF_TOKEN` qui donne accès en lecture au dataset.
 
-### Recherches simultanées
-
-L'application accepte par défaut deux recherches simultanées. Chaque recherche
-conserve son propre identifiant, son état de progression et son résultat. Les
-requêtes supplémentaires restent dans l'état `queued` jusqu'à ce qu'un worker
-soit disponible.
-
-Le nombre de recherches simultanées peut être configuré avec la variable
-d'environnement `SEARCH_MAX_WORKERS`. La valeur doit être un entier strictement
-positif ; une valeur absente ou invalide utilise la valeur par défaut `2`.
-
-La création initiale des projections GDS reste sérialisée afin que deux
-requêtes arrivant au démarrage ne tentent pas de créer le même graphe. Une fois
-les projections disponibles, les BFS et la construction de leurs résultats
-s'exécutent indépendamment.
-
-Lorsqu'un utilisateur quitte la page pendant une recherche, le navigateur
-envoie une demande d'annulation. Un job encore en file est retiré
-immédiatement. Pour un job actif, l'application termine la transaction Neo4j
-identifiée par les métadonnées du job, puis vérifie aussi un drapeau
-d'annulation entre les lots de construction du résultat. Le signal envoyé par
-le navigateur est une garantie au mieux : une fermeture brutale du processus
-ou une coupure réseau peut empêcher son émission.

application_neo4j/app.py

@@ -1,22 +1,14 @@
 # --- Import et initialisation Flask ---
 import os
 from flask import Flask, request, render_template, jsonify, session, redirect, url_for
-from neo4j import GraphDatabase, Query, basic_auth
+from neo4j import GraphDatabase, basic_auth
 from graphdatascience import GraphDataScience
 import app_algorithms as algo
 from translations import t
 import pandas as pd
 from typing import Dict
 from collections import defaultdict
-from concurrent.futures import ThreadPoolExecutor
-from threading import Lock
-from time import time
-from uuid import uuid4
 import argparse
-import atexit
-import math
-import json
-from datetime import datetime
 
 app = Flask(__name__, static_url_path="/static/")  # Application Flask
 app.secret_key = os.urandom(24)
@@ -24,72 +16,6 @@ app.secret_key = os.urandom(24)
 # --- Connexion à Neo4j et GDS ---
 NEO4J_URI = "bolt://localhost:7687"
 GDS_GRAPH_NAME = "genealogie_gds"
-GDS_RELATIONSHIP_TYPES = ("IS_IN", "POSTED", "USED_IN")
-SEARCH_JOB_TTL_SECONDS = 60 * 60
-RESULT_BATCH_SIZE = 25
-DEFAULT_SEARCH_MAX_WORKERS = 2
-DATABASE_METADATA_PATH = os.environ.get(
-    "DATABASE_METADATA_PATH",
-    "/backups/database_metadata.json",
-)
-
-
-def database_dates():
-    """Return display dates from metadata shipped with the loaded dump."""
-    fallback = {"fr": "01/09/2025", "en": "2025-09-01"}
-    try:
-        with open(DATABASE_METADATA_PATH, encoding="utf-8") as metadata_file:
-            built_at = json.load(metadata_file)["built_at"]
-        built_date = datetime.fromisoformat(built_at.replace("Z", "+00:00")).date()
-    except (OSError, KeyError, TypeError, ValueError, json.JSONDecodeError):
-        return fallback
-    return {
-        "fr": built_date.strftime("%d/%m/%Y"),
-        "en": built_date.isoformat(),
-    }
-
-
-DATABASE_DATES = database_dates()
-
-
-def positive_int_env(name, default):
-    """Read a strictly positive integer setting, falling back safely."""
-    try:
-        value = int(os.environ.get(name, default))
-    except (TypeError, ValueError):
-        return default
-    return value if value > 0 else default
-
-
-# Neo4j's driver and the projected GDS graphs support concurrent read jobs.
-# Keep the pool bounded because every BFS is CPU- and memory-intensive. Jobs
-# beyond this limit remain visible in the existing "queued" stage.
-SEARCH_MAX_WORKERS = positive_int_env(
-    "SEARCH_MAX_WORKERS",
-    DEFAULT_SEARCH_MAX_WORKERS,
-)
-search_executor = ThreadPoolExecutor(
-    max_workers=SEARCH_MAX_WORKERS,
-    thread_name_prefix="search",
-)
-search_jobs = {}
-search_jobs_lock = Lock()
-graph_projection_lock = Lock()
-
-
-class SearchCancelled(Exception):
-    """Raised by a worker when its browser no longer needs the result."""
-
-
-def search_cancel_requested(job_id):
-    with search_jobs_lock:
-        job = search_jobs.get(job_id)
-        return bool(job and job.get("cancel_requested"))
-
-
-def raise_if_search_cancelled(job_id):
-    if search_cancel_requested(job_id):
-        raise SearchCancelled()
 
 # --- Configuration des arguments du script ---
 parser = argparse.ArgumentParser(description="Script pour lancer la web application.")
@@ -119,12 +45,7 @@ except Exception as e:
     exit()  # Si la connexion échoue, l'application ne peut pas tourner
 
 # --- Projection du graphe pour GDS ---
-def ensure_graph_projected(
-    gds: GraphDataScience,
-    graph_name,
-    search_job_id=None,
-    progress_callback=None,
-):
+def ensure_graph_projected(gds: GraphDataScience, graph_name):
     """
     Projette deux graphes dans :
     - Graphe "naturel" : relations descendant (source -> target)
@@ -135,107 +56,50 @@ def ensure_graph_projected(
     natural_graph_name = f"{graph_name}_natural"
     reverse_graph_name = f"{graph_name}_reverse"
 
-    # Projections are immutable for the lifetime of this Space container: the
-    # database is restored only at startup. Reusing them makes subsequent
-    # searches faster and avoids races between concurrent searches.
-    with graph_projection_lock:
-        g_natural_exists = gds.graph.exists(natural_graph_name).exists
-        g_reverse_exists = gds.graph.exists(reverse_graph_name).exists
-        if g_natural_exists and g_reverse_exists:
-            return
-
-        if g_natural_exists:
-            gds.graph.get(natural_graph_name).drop()
-        if g_reverse_exists:
-            gds.graph.get(reverse_graph_name).drop()
-
-        relationship_types_result = gds.run_cypher(
-            """
-            CALL db.relationshipTypes()
-            YIELD relationshipType
-            RETURN relationshipType
-            """
-        )
-        available_relationship_types = set(
-            relationship_types_result["relationshipType"].tolist()
-        )
-        projected_relationship_types = [
-            relationship_type
-            for relationship_type in GDS_RELATIONSHIP_TYPES
-            if relationship_type in available_relationship_types
-        ]
-        if not projected_relationship_types:
-            raise RuntimeError(
-                "Aucun type de relation compatible avec la recherche GDS "
-                "n'est présent dans Neo4j."
-            )
-        reverse_relationship_projection = {
-            relationship_type: {
-                "type": relationship_type,
-                "orientation": "REVERSE",
-            }
-            for relationship_type in projected_relationship_types
-        }
-        print(
-            "Types de relations projetés dans GDS : "
-            + ", ".join(projected_relationship_types)
-        )
-
-        # Native projections accept a jobId, allowing gds.listProgress to
-        # expose real progress while the first search prepares the graph.
-        natural_projection_job_id = (
-            f"{search_job_id}-project-natural" if search_job_id else uuid4().hex
-        )
-        if progress_callback:
-            progress_callback("preparing_graph", natural_projection_job_id)
-
-        # --- 1. Projection pour les descendants (sens normal) ---
-        print("Projection du graphe naturel (descendant)...")
-        gds.run_cypher(
-            """
-            CALL gds.graph.project(
-                $graph_name,
-                '*',
-                $relationship_projection,
-                {jobId: $job_id}
-            )
-            YIELD graphName, nodeCount, relationshipCount
-            RETURN graphName, nodeCount, relationshipCount
-            """,
-            {
-                "graph_name": natural_graph_name,
-                "job_id": natural_projection_job_id,
-                "relationship_projection": projected_relationship_types,
-            },
-        )
-        print(f"Graphe '{natural_graph_name}' projeté.")
-
-        reverse_projection_job_id = (
-            f"{search_job_id}-project-reverse" if search_job_id else uuid4().hex
-        )
-        if progress_callback:
-            progress_callback("preparing_graph", reverse_projection_job_id)
-
-        # --- 2. Projection pour les ascendants (sens inversé) ---
-        print("Projection du graphe inversé (ascendant)...")
-        gds.run_cypher(
-            """
-            CALL gds.graph.project(
-                $graph_name,
-                '*',
-                $relationship_projection,
-                {jobId: $job_id}
-            )
-            YIELD graphName, nodeCount, relationshipCount
-            RETURN graphName, nodeCount, relationshipCount
-            """,
-            {
-                "graph_name": reverse_graph_name,
-                "job_id": reverse_projection_job_id,
-                "relationship_projection": reverse_relationship_projection,
-            },
-        )
-        print(f"Graphe '{reverse_graph_name}' projeté.")
+    # Suppression de toute projection existante
+    g_natural_exists = gds.graph.exists(natural_graph_name).exists
+    if g_natural_exists:
+        gds.graph.get(natural_graph_name).drop()
+
+    g_reverse_exists = gds.graph.exists(reverse_graph_name).exists
+    if g_reverse_exists:
+        gds.graph.get(reverse_graph_name).drop()
+
+
+    # --- 1. Projection pour les descendants (sens normal) ---
+    # On sélectionne les relations et on les projette en gardant source -> target
+    print("Projection du graphe naturel (descendant)...")
+    gds.run_cypher(f"""
+        MATCH (source)-[r:IS_IN|POSTED|USED_IN]->(target)
+        WITH gds.graph.project(
+        '{natural_graph_name}',
+        source,
+        target,
+        {{
+            relationshipType: type(r)
+        }}
+        ) AS g
+        RETURN g.graphName AS graph, g.nodeCount AS nodes, g.relationshipCount AS rels
+    """)
+    print(f"Graphe '{natural_graph_name}' projeté.")
+
+
+    # --- 2. Projection pour les ascendants (sens inversé) ---
+    # On sélectionne les mêmes relations, mais on inverse source et target dans l'appel
+    print("Projection du graphe inversé (ascendant)...")
+    gds.run_cypher(f"""
+        MATCH (source)-[r:IS_IN|POSTED|USED_IN]->(target)
+        WITH gds.graph.project(
+        '{reverse_graph_name}',
+        target,   // <<< Le 'target' devient la source dans la projection
+        source,   // <<< Le 'source' devient la cible dans la projection
+        {{
+            relationshipType: type(r)
+        }}
+        ) AS g
+        RETURN g.graphName AS graph, g.nodeCount AS nodes, g.relationshipCount AS rels
+    """)
+    print(f"Graphe '{reverse_graph_name}' projeté.")
 
 @app.before_request
 def set_language():
@@ -267,10 +131,7 @@ def set_language_route():
 def inject_i18n():
     """Inject t() and current_lang into all Jinja2 templates."""
     def _t(key, **kwargs):
-        lang = session.get("lang", "fr")
-        if key in {"site.nav_subtitle_full", "home.download_date"}:
-            kwargs.setdefault("date", DATABASE_DATES[lang])
-        return t(key, lang, **kwargs)
+        return t(key, session.get("lang", "fr"), **kwargs)
     # Dictionnaire JS pour les clés utilisées côté client
     js_i18n_keys = [
         "js.node_info.name", "js.node_info.type", "js.node_info.followers",
@@ -278,23 +139,6 @@ def inject_i18n():
         "js.node_info.dataset", "js.node_info.undefined", "js.node_info.unknown_date",
         "js.node_info.see_on_hf",
         "js.unknown", "js.unknown_f", "js.na",
-        "search.progress_title",
-        "search.progress_stage_queued", "search.progress_stage_preparing",
-        "search.progress_stage_descendants", "search.progress_stage_ancestors",
-        "search.progress_stage_result", "search.progress_stage_nodes",
-        "search.progress_stage_relationships", "search.progress_stage_formatting",
-        "search.progress_stage_highlights",
-        "search.progress_stage_completed", "search.progress_stage_failed",
-        "search.progress_stage_cancelled",
-        "search.progress_elapsed", "search.progress_items",
-        "search.progress_queue_title",
-        "search.progress_queue_position", "search.progress_queue_ahead_one",
-        "search.progress_queue_ahead_many", "search.progress_queue_next",
-        "search.progress_queue_running_one", "search.progress_queue_running_many",
-        "search.progress_queue_note",
-        "search.progress_server_percent",
-        "search.progress_remaining_step", "search.progress_server_note",
-        "search.progress_connection_error",
     ]
     lang = session.get("lang", "fr")
     js_i18n_data = {k: t(k, lang) for k in js_i18n_keys}
@@ -326,16 +170,13 @@ def autocomplete():
     if node_filter and node_filter in ["Model", "Dataset"]: # Mesure de sécurité
         label_cypher = f":{node_filter}"
 
-    # Récupère les noms commençant par le préfixe fourni. Les suggestions les
-    # plus téléchargées sont proposées en premier ; le nom garantit un ordre
-    # stable lorsque plusieurs éléments ont le même nombre de téléchargements.
+    # Récupère les noms commençant par le préfixe fourni
     cypher = f"""
         MATCH (n{label_cypher})
         WHERE toLower(n.name) STARTS WITH toLower($prefix)
         AND n.name IS NOT NULL
-        RETURN n.name AS name, labels(n)[0] AS label,
-               coalesce(n.downloads, 0) AS downloads
-        ORDER BY downloads DESC, toLower(n.name) ASC
+        RETURN n.name AS name, labels(n)[0] as label
+        ORDER BY size(n.name) ASC
         LIMIT 10
     """
     try:
@@ -348,490 +189,12 @@ def autocomplete():
         return jsonify([])
 
 
-def update_search_job(job_id, **changes):
-    """Update a background search job without exposing mutable shared state."""
-    with search_jobs_lock:
-        job = search_jobs.get(job_id)
-        if not job:
-            return
-        stage_changed = (
-            "stage" in changes and changes["stage"] != job.get("stage")
-        )
-        gds_operation_changed = (
-            changes.get("gds_job_id")
-            and changes["gds_job_id"] != job.get("gds_job_id")
-        )
-        if stage_changed or gds_operation_changed:
-            changes.setdefault("stage_started_at", time())
-        job.update(changes)
-
-
-def set_search_stage(job_id, stage, gds_job_id=None):
-    update_search_job(
-        job_id,
-        stage=stage,
-        gds_job_id=gds_job_id,
-        application_progress_percent=None,
-        completed_items=None,
-        total_items=None,
-    )
-
-
-def report_application_progress(job_id, stage, completed_items, total_items):
-    percent = (
-        completed_items * 100 / total_items
-        if total_items
-        else None
-    )
-    update_search_job(
-        job_id,
-        stage=stage,
-        gds_job_id=None,
-        application_progress_percent=percent,
-        completed_items=completed_items,
-        total_items=total_items,
-    )
-
-
-def cleanup_search_jobs():
-    cutoff = time() - SEARCH_JOB_TTL_SECONDS
-    with search_jobs_lock:
-        expired_ids = [
-            job_id for job_id, job in search_jobs.items()
-            if job.get("created_at", 0) < cutoff
-        ]
-        for job_id in expired_ids:
-            del search_jobs[job_id]
-
-
-def make_search_result(name, depth, is_unlimited, filters, expert):
-    return {
-        "template": "expert.html" if expert else "search.html",
-        "message": None,
-        "message_key": None,
-        "message_kwargs": {},
-        "search": {
-            "name": name,
-            "depth": depth,
-            "unlimited": is_unlimited,
-            "filters": filters,
-        },
-        "graph_data": {"nodes": [], "edges": [], "models_count": []},
-        "highlights": {},
-    }
-
-
-def set_search_result_message(result, key, lang, **kwargs):
-    """Store a translatable message while keeping its current rendering."""
-    result["message_key"] = key
-    result["message_kwargs"] = kwargs
-    result["message"] = t(key, lang, **kwargs)
-
-
-def execute_search_job(job_id, name, depth, is_unlimited, filters, expert, lang):
-    """Run the existing search pipeline while publishing its real server stage."""
-    result = make_search_result(name, depth, is_unlimited, filters, expert)
-    graph_data = result["graph_data"]
-
-    try:
-        raise_if_search_cancelled(job_id)
-        update_search_job(job_id, status="running", started_at=time())
-        def report_gds_stage(stage, gds_job_id):
-            set_search_stage(job_id, stage, gds_job_id)
-
-        set_search_stage(job_id, "preparing_graph")
-        ensure_graph_projected(
-            gds,
-            GDS_GRAPH_NAME,
-            search_job_id=job_id,
-            progress_callback=report_gds_stage,
-        )
-        raise_if_search_cancelled(job_id)
-
-        natural_graph_name = f"{GDS_GRAPH_NAME}_natural"
-        reverse_graph_name = f"{GDS_GRAPH_NAME}_reverse"
-
-        gds_result = algo.run_gds_bfs(
-            gds,
-            natural_graph_name,
-            reverse_graph_name,
-            name,
-            None if is_unlimited else depth,
-            expert,
-            source_labels=filters,
-            job_id=job_id,
-            progress_callback=report_gds_stage,
-            neo4j_driver=driver,
-            cancel_check=lambda: raise_if_search_cancelled(job_id),
-        )
-
-        if not gds_result:
-            set_search_result_message(
-                result,
-                "error.node_not_found_expert" if expert else "error.model_not_found",
-                lang,
-                name=name,
-            )
-        else:
-            def report_result_progress(stage, completed_items, total_items):
-                report_application_progress(
-                    job_id, stage, completed_items, total_items
-                )
-
-            set_search_stage(job_id, "building_nodes")
-            process_gds_bfs_results(
-                gds_result,
-                graph_data,
-                job_id=job_id,
-                cancel_check=lambda: raise_if_search_cancelled(job_id),
-                progress_callback=report_result_progress,
-            )
-
-            if expert:
-                if not graph_data["nodes"] and not graph_data["edges"]:
-                    set_search_result_message(
-                        result, "error.no_neighbors", lang, name=name
-                    )
-            elif gds_result["source_label"] == "Model":
-                raise_if_search_cancelled(job_id)
-                set_search_stage(job_id, "building_highlights")
-                result["highlights"] = algo.get_genealogy_highlights(
-                    gds, name, lang=lang
-                )
-            elif gds_result["source_label"] == "Dataset":
-                result["template"] = "search_dataset.html"
-            elif not graph_data["nodes"] and not graph_data["edges"]:
-                set_search_result_message(
-                    result, "error.no_neighbors", lang, name=name
-                )
-
-        raise_if_search_cancelled(job_id)
-        update_search_job(
-            job_id,
-            status="completed",
-            stage="completed",
-            gds_job_id=None,
-            application_progress_percent=None,
-            completed_items=None,
-            total_items=None,
-            completed_at=time(),
-            result=result,
-        )
-    except SearchCancelled:
-        update_search_job(
-            job_id,
-            status="cancelled",
-            stage="cancelled",
-            gds_job_id=None,
-            application_progress_percent=None,
-            completed_items=None,
-            total_items=None,
-            completed_at=time(),
-            result=None,
-        )
-    except Exception as error:
-        if search_cancel_requested(job_id):
-            update_search_job(
-                job_id,
-                status="cancelled",
-                stage="cancelled",
-                gds_job_id=None,
-                application_progress_percent=None,
-                completed_items=None,
-                total_items=None,
-                completed_at=time(),
-                result=None,
-            )
-            return
-        if "Failed to find a node" in str(error):
-            message_key = "error.node_not_found"
-            message_kwargs = {"name": name}
-        else:
-            print(f"Background GDS search error ({job_id}): {error}")
-            message_key = "error.gds"
-            message_kwargs = {"error": str(error)}
-        set_search_result_message(
-            result, message_key, lang, **message_kwargs
-        )
-        update_search_job(
-            job_id,
-            status="failed",
-            stage="failed",
-            gds_job_id=None,
-            application_progress_percent=None,
-            completed_items=None,
-            total_items=None,
-            completed_at=time(),
-            result=result,
-        )
-
-
-def get_gds_progress(gds_job_id):
-    """Read the percentage published by Neo4j for the running GDS procedure."""
-    if not gds_job_id:
-        return None
-    try:
-        with driver.session() as neo4j_session:
-            record = neo4j_session.run(
-                """
-                CALL gds.listProgress($job_id, false)
-                YIELD progress, status
-                RETURN progress, status
-                LIMIT 1
-                """,
-                {"job_id": gds_job_id},
-            ).single()
-        if not record:
-            return None
-        progress_text = str(record["progress"]).strip().rstrip("%")
-        return {
-            "percent": max(0.0, min(100.0, float(progress_text))),
-            "status": record["status"],
-        }
-    except Exception as error:
-        # A progress lookup must never interrupt the actual search.
-        print(f"Could not read GDS progress for {gds_job_id}: {error}")
-        return None
-
-
-def terminate_search_transactions(job_id):
-    """Terminate any active Neo4j transaction tagged for this search."""
-    try:
-        with driver.session() as neo4j_session:
-            records = neo4j_session.run(
-                """
-                SHOW TRANSACTIONS
-                YIELD transactionId, metaData, status
-                WHERE metaData.search_job_id = $job_id
-                  AND NOT status STARTS WITH 'Terminated'
-                RETURN transactionId
-                """,
-                {"job_id": job_id},
-            )
-            transaction_ids = [
-                record["transactionId"] for record in records
-            ]
-            if transaction_ids:
-                neo4j_session.run(
-                    """
-                    TERMINATE TRANSACTIONS $transaction_ids
-                    YIELD transactionId, message
-                    RETURN transactionId, message
-                    """,
-                    {"transaction_ids": transaction_ids},
-                ).consume()
-    except Exception as error:
-        # The cooperative cancellation flag still stops the worker between
-        # batches if transaction termination is unavailable.
-        print(f"Could not terminate transactions for {job_id}: {error}")
-
-
-@app.route("/api/search-jobs", methods=["POST"])
-def create_search_job():
-    cleanup_search_jobs()
-
-    name = request.form.get("name", "").strip()
-    if not name:
-        return jsonify({"error": t("error.empty_name", session.get("lang", "fr"))}), 400
-
-    try:
-        depth = int(request.form.get("depth", 3))
-    except (TypeError, ValueError):
-        depth = 3
-    depth = max(1, min(5, depth))
-
-    is_unlimited = (
-        "depth_unlimited" in request.form
-        or "unlimited_depth" in request.form
-    )
-    expert = request.form.get("search_mode") == "expert"
-    filters = [
-        value for value in request.form.getlist("filters")
-        if value in ("Model", "Dataset", "Author")
-    ]
-    lang = session.get("lang", "fr")
-    job_id = uuid4().hex
-    now = time()
-
-    with search_jobs_lock:
-        search_jobs[job_id] = {
-            "status": "queued",
-            "stage": "queued",
-            "created_at": now,
-            "stage_started_at": now,
-            "started_at": None,
-            "gds_job_id": None,
-            "application_progress_percent": None,
-            "completed_items": None,
-            "total_items": None,
-            "lang": lang,
-            "result": None,
-            "cancel_requested": False,
-            "future": None,
-        }
-
-    future = search_executor.submit(
-        execute_search_job,
-        job_id,
-        name,
-        depth,
-        is_unlimited,
-        filters,
-        expert,
-        lang,
-    )
-    with search_jobs_lock:
-        job = search_jobs.get(job_id)
-        if job:
-            job["future"] = future
-            cancel_requested = job.get("cancel_requested")
-        else:
-            cancel_requested = True
-    if cancel_requested and future.cancel():
-        update_search_job(
-            job_id,
-            status="cancelled",
-            stage="cancelled",
-            completed_at=time(),
-        )
-
-    return jsonify({
-        "job_id": job_id,
-        "status_url": url_for("search_job_status", job_id=job_id),
-        "result_url": url_for("search_job_result", job_id=job_id, lang=lang),
-        "cancel_url": url_for("cancel_search_job", job_id=job_id),
-    }), 202
-
-
-@app.route("/api/search-jobs/<job_id>/cancel", methods=["POST"])
-def cancel_search_job(job_id):
-    with search_jobs_lock:
-        job = search_jobs.get(job_id)
-        if not job:
-            return jsonify({"error": "Search job not found"}), 404
-        if job["status"] in ("completed", "failed", "cancelled"):
-            return jsonify({"status": job["status"]})
-        job["cancel_requested"] = True
-        job["cancel_requested_at"] = time()
-        future = job.get("future")
-
-    cancelled_before_start = bool(future and future.cancel())
-    if cancelled_before_start:
-        update_search_job(
-            job_id,
-            status="cancelled",
-            stage="cancelled",
-            completed_at=time(),
-            result=None,
-        )
-    else:
-        terminate_search_transactions(job_id)
-
-    return jsonify({
-        "status": "cancelled" if cancelled_before_start else "cancelling"
-    }), 202
-
-
-@app.route("/api/search-jobs/<job_id>")
-def search_job_status(job_id):
-    with search_jobs_lock:
-        stored_job = search_jobs.get(job_id)
-        job = dict(stored_job) if stored_job else None
-        queued_jobs = sorted(
-            (
-                (queued_job.get("created_at", 0), queued_job_id)
-                for queued_job_id, queued_job in search_jobs.items()
-                if queued_job.get("status") == "queued"
-            )
-        )
-        queued_job_ids = [
-            queued_job_id for _, queued_job_id in queued_jobs
-        ]
-        queue_position = (
-            queued_job_ids.index(job_id) + 1
-            if job_id in queued_job_ids
-            else None
-        )
-        running_jobs = sum(
-            queued_job.get("status") == "running"
-            for queued_job in search_jobs.values()
-        )
-    if not job:
-        return jsonify({"error": "Search job not found"}), 404
-
-    now = time()
-    started_at = job.get("started_at")
-    response = {
-        "status": job["status"],
-        "stage": job["stage"],
-        "elapsed_seconds": max(0, math.floor(now - started_at)) if started_at else 0,
-        "progress_percent": None,
-        "remaining_seconds": None,
-        "queue_position": queue_position,
-        "queued_jobs": len(queued_job_ids),
-        "running_jobs": running_jobs,
-        "completed_items": job.get("completed_items"),
-        "total_items": job.get("total_items"),
-        "result_url": (
-            url_for("search_job_result", job_id=job_id, lang=job["lang"])
-            if job["status"] in ("completed", "failed")
-            else None
-        ),
-    }
-
-    gds_progress = get_gds_progress(job.get("gds_job_id"))
-    if gds_progress:
-        percent = gds_progress["percent"]
-        response["progress_percent"] = round(percent, 1)
-    elif job.get("application_progress_percent") is not None:
-        percent = job["application_progress_percent"]
-        response["progress_percent"] = round(percent, 1)
-    else:
-        percent = None
-
-    stage_elapsed = max(0, now - job.get("stage_started_at", now))
-    if percent is not None and 0 < percent < 100:
-        response["remaining_seconds"] = math.ceil(
-            stage_elapsed * (100 - percent) / percent
-        )
-
-    return jsonify(response)
-
-
-@app.route("/search-jobs/<job_id>/result")
-def search_job_result(job_id):
-    with search_jobs_lock:
-        stored_job = search_jobs.get(job_id)
-        job = dict(stored_job) if stored_job else None
-    if not job:
-        return redirect(url_for("findnode", lang=session.get("lang", "fr")))
-    if job["status"] not in ("completed", "failed") or not job.get("result"):
-        return redirect(url_for("findnode", lang=job["lang"]))
-
-    result = job["result"]
-    message = result["message"]
-    if result.get("message_key"):
-        message = t(
-            result["message_key"],
-            session.get("lang", "fr"),
-            **result.get("message_kwargs", {}),
-        )
-    template_args = {
-        "message": message,
-        "search": result["search"],
-        "graph_data": result["graph_data"],
-    }
-    if result["template"] == "search.html":
-        template_args["highlights"] = result["highlights"]
-    return render_template(result["template"], **template_args)
-
-
 @app.route("/search", methods=["GET", "POST"])  # Recherche d'un noeud
 def findnode():
     """
     1. Récupère le nom à chercher et la profondeur
-    2. S'assure que les graphes GDS existent
-    3. Lance le BFS qui renvoie directement la profondeur de chaque nœud
+    2. Appelle ensure_graph_projected pour s'assurer que les graphes GDS existent
+    3. Lance l'algorithme BFS via algo.run_gds_bfs
     4. Traite les résultats et construit le sous-graphe à afficher
     5. Met à jour les données pour le template Flask
     """  
@@ -852,17 +215,13 @@ def findnode():
     search_info = {
         "name": request.form.get("name", ""), 
         "depth": int(request.form.get("depth", 3)), 
-        "unlimited": request.method == "GET" or (
-            'depth_unlimited' in request.form or 'unlimited_depth' in request.form
-        ),
+        "unlimited": 'unlimited_depth' in request.form,
         "filters": current_filters  # On passe la liste des filtres au template
     }
 
     if request.method == "POST" and request.form.get("submit") == "find_node":
         name = request.form.get("name", "").strip()
-        is_unlimited = (
-            'depth_unlimited' in request.form or 'unlimited_depth' in request.form
-        )
+        is_unlimited = 'unlimited_depth' in request.form
         depth = None if is_unlimited else int(request.form.get("depth", 3))
 
         search_info = {"name": name, "depth": request.form.get("depth", 3), "unlimited": is_unlimited}
@@ -872,23 +231,18 @@ def findnode():
             return render_template("search.html", message=message, search=search_info, graph_data=graph_data, highlights=highlights)
 
         try:
+            # Projection des graphes ascendant et descendant
             ensure_graph_projected(gds, GDS_GRAPH_NAME)
             natural_graph_name = f"{GDS_GRAPH_NAME}_natural"
             reverse_graph_name = f"{GDS_GRAPH_NAME}_reverse"
-            gds_result = algo.run_gds_bfs(
-                gds,
-                natural_graph_name,
-                reverse_graph_name,
-                name,
-                depth,
-                False,
-                source_labels=current_filters,
-            )
+
+            # Appeler la fonction GDS BFS 
+            gds_result = algo.run_gds_bfs(gds, natural_graph_name,reverse_graph_name, name, depth,False)
             if not gds_result :
                 message = t("error.model_not_found", session.get("lang", "fr"), name=name)
                 return render_template("search.html", message=message, search=search_info, graph_data=graph_data,highlights=highlights)
 
-            process_gds_bfs_results(gds_result, graph_data)
+            process_gds_bfs_results(gds_result, graph_data, name)
             if gds_result["source_label"] == "Model" :
                 highlights = algo.get_genealogy_highlights(gds, name, lang=session.get("lang", "fr"))
                 return render_template("search.html", message=message, search=search_info, graph_data=graph_data,highlights=highlights)
@@ -914,8 +268,8 @@ def findnode():
 def findnode_expert():
     """
     1. Récupère le nom à chercher et la profondeur
-    2. S'assure que les graphes GDS existent
-    3. Lance le BFS qui renvoie directement la profondeur de chaque nœud
+    2. Appelle ensure_graph_projected pour s'assurer que les graphes GDS existent
+    3. Lance l'algorithme BFS via algo.run_gds_bfs
     4. Traite les résultats et construit le sous-graphe à afficher
     5. Met à jour les données pour le template Flask
     """  
@@ -934,17 +288,13 @@ def findnode_expert():
     search_info = {
         "name": request.form.get("name", ""), 
         "depth": int(request.form.get("depth", 3)), 
-        "unlimited": request.method == "GET" or (
-            'depth_unlimited' in request.form or 'unlimited_depth' in request.form
-        ),
+        "unlimited": 'unlimited_depth' in request.form,
         "filters": current_filters  # On passe la liste des filtres au template
     }
 
     if request.method == "POST" and request.form.get("submit") == "findnode_expert":
         name = request.form.get("name", "").strip()
-        is_unlimited = (
-            'depth_unlimited' in request.form or 'unlimited_depth' in request.form
-        )
+        is_unlimited = 'unlimited_depth' in request.form
         depth = None if is_unlimited else int(request.form.get("depth", 3))
 
         search_info = {"name": name, "depth": request.form.get("depth", 3), "unlimited": is_unlimited,"filters": current_filters }
@@ -954,24 +304,19 @@ def findnode_expert():
             return render_template("expert.html", message=message, search=search_info, graph_data=graph_data)
 
         try:
+            # Projection des graphes ascendant et descendant
             ensure_graph_projected(gds, GDS_GRAPH_NAME)
             natural_graph_name = f"{GDS_GRAPH_NAME}_natural"
             reverse_graph_name = f"{GDS_GRAPH_NAME}_reverse"
-            gds_result = algo.run_gds_bfs(
-                gds,
-                natural_graph_name,
-                reverse_graph_name,
-                name,
-                depth,
-                True,
-                source_labels=current_filters,
-            )
+
+            # Appeler la fonction GDS BFS 
+            gds_result = algo.run_gds_bfs(gds, natural_graph_name,reverse_graph_name, name, depth,True)
             if not gds_result :
                 message = t("error.node_not_found_expert", session.get("lang", "fr"), name=name)
                 return render_template("expert.html", message=message, search=search_info, graph_data=graph_data)
 
 
-            process_gds_bfs_results(gds_result, graph_data)
+            process_gds_bfs_results(gds_result, graph_data, name)
 
             if not graph_data["nodes"] and not graph_data["edges"]:
                 message = t("error.no_neighbors", session.get("lang", "fr"), name=name)                
@@ -986,13 +331,7 @@ def findnode_expert():
     return render_template("expert.html", message=message, search=search_info, graph_data=graph_data)
 
 
-def process_gds_bfs_results(
-    gds_result: Dict,
-    graph_data: Dict,
-    job_id=None,
-    cancel_check=None,
-    progress_callback=None,
-):
+def process_gds_bfs_results(gds_result: Dict, graph_data: Dict, origin_name: str):
     """
     Transforme les résultats d'un BFS GDS en un sous-graphe utilisable pour le front-end.
     
@@ -1002,204 +341,86 @@ def process_gds_bfs_results(
     3. Formatage des nœuds et arêtes pour construire le dictionnaire `graph_data`.
     """
 
-    # --- PHASE 1 : Collecte des nœuds et profondeurs produits par le BFS ---
-    #
-    # La profondeur est calculée au moment où GDS découvre le nœud. Il n'est
-    # donc plus nécessaire de rechercher ensuite un chemin à longueur variable
-    # entre chacun des nœuds et l'origine.
-    distance_by_node = {}
+    # --- PHASE 1 : Collecte des IDs de tous les nœuds visités ---
+    all_discovered_node_ids = set()
+    # Ajouter le nœud source
     source_id = gds_result.get("source_node")
     if source_id is not None:
-        distance_by_node[int(source_id)] = 0
+        all_discovered_node_ids.add(source_id)
 
+    # Ajouter les descendants (profondeur positive)
     desc_df = gds_result.get("descendant")
     if desc_df is not None and not desc_df.empty:
         node_ids = desc_df["nodeIds"].iloc[0]
-        depths = desc_df["depths"].iloc[0]
-        for node_id, depth in zip(node_ids, depths):
-            distance_by_node.setdefault(int(node_id), int(depth))
+        all_discovered_node_ids.update(node_ids)
 
+    # Ajouter les ascendants (profondeur négative)
     asc_df = gds_result.get("ascendant")
     if asc_df is not None and not asc_df.empty:
         node_ids = asc_df["nodeIds"].iloc[0]
-        depths = asc_df["depths"].iloc[0]
-        for node_id, depth in zip(node_ids, depths):
-            node_id = int(node_id)
-            if node_id != source_id:
-                # Conserver la convention historique : profondeur négative
-                # pour un ascendant. Si un cycle rend le nœud accessible dans
-                # les deux sens, l'ascendance reste prioritaire.
-                distance_by_node[node_id] = -int(depth)
+        all_discovered_node_ids.update(node_ids)
 
-    if not distance_by_node:
+    if not all_discovered_node_ids:
         return  # Aucun nœud découvert → rien à faire
 
-    discovered_node_ids = sorted(distance_by_node)
-    total_nodes = len(discovered_node_ids)
-    nodes_data = []
-    relationships = []
-
-    # --- PHASE 2 : Récupération des nœuds par lots ---
-    #
-    # Neo4j 2025.09 does not expose a percentage for this read query. Running
-    # it in bounded batches lets the server report completed/total items after
-    # each real unit of work, instead of inventing a browser-side countdown.
-    if progress_callback:
-        progress_callback("building_nodes", 0, total_nodes)
-
+    # --- PHASE 2 : Récupération du sous-graphe réel dans Neo4j ---
     with driver.session() as session:
-        for batch_start in range(0, total_nodes, RESULT_BATCH_SIZE):
-            if cancel_check:
-                cancel_check()
-            batch_ids = discovered_node_ids[
-                batch_start:batch_start + RESULT_BATCH_SIZE
-            ]
-            batch_nodes = [
-                {"id": node_id, "distance": distance_by_node[node_id]}
-                for node_id in batch_ids
-            ]
-            query = Query(
-                """
-                UNWIND $nodes AS node_info
-                MATCH (n) WHERE id(n) = node_info.id
-                OPTIONAL MATCH (author:Author)-[:POSTED]->(n)
-                OPTIONAL MATCH (dataset:Dataset)-[:USED_IN]->(n)
-                CALL {
-                    WITH n
-                    OPTIONAL MATCH (ancestor:Model)-[:USED_IN*1..]->(n)
-                    WITH n, count(DISTINCT ancestor) AS ascendantsCount
-                    OPTIONAL MATCH (descendant:Model)<-[:USED_IN*1..]-(n)
-                    WITH n, ascendantsCount,
-                         count(DISTINCT descendant) AS descendantsCount
-                    OPTIONAL MATCH (citation:Model)<-[:USED_IN]-(n)
-                    RETURN ascendantsCount, descendantsCount,
-                           count(DISTINCT citation) AS citationCount
-                }
-                WITH n, node_info, author, dataset, ascendantsCount,
-                     descendantsCount, citationCount
-                RETURN collect({
-                    id: id(n),
-                    node: n,
-                    dataset: properties(dataset),
-                    author: properties(author),
-                    task: n.task,
-                    license: n.license,
-                    createdAt: n.createdAt,
-                    likes: n.likes,
-                    properties: properties(n),
-                    labels: labels(n),
-                    ascendantsCount: ascendantsCount,
-                    descendantsCount: descendantsCount,
-                    citationCount: citationCount,
-                    distance: node_info.distance
-                }) AS nodes_data
-                """,
-                metadata={"search_job_id": job_id} if job_id else None,
-            )
-            record = session.run(
-                query,
-                {"nodes": batch_nodes},
-            ).single()
-            if record:
-                nodes_data.extend(record["nodes_data"])
-            if progress_callback:
-                progress_callback(
-                    "building_nodes",
-                    min(batch_start + len(batch_ids), total_nodes),
-                    total_nodes,
-                )
-
-        # --- PHASE 3 : Récupération des relations par lots ---
-        #
-        # First count the relationships whose two endpoints belong to the
-        # result graph. We can then publish a real relationship counter while
-        # hydrating them in bounded source-node batches. Matching directed
-        # relationships ensures that each stored relationship is returned
-        # once, regardless of its direction in the result graph.
-        if progress_callback:
-            progress_callback("building_relationships", 0, 0)
-
-        if cancel_check:
-            cancel_check()
-        count_query = Query(
-            """
-            UNWIND $all_ids AS source_id
-            MATCH (source) WHERE id(source) = source_id
-            MATCH (source)-[relationship]->(target)
-            WHERE id(target) IN $all_ids
-            RETURN count(relationship) AS relationship_count
-            """,
-            metadata={"search_job_id": job_id} if job_id else None,
-        )
-        count_record = session.run(
-            count_query,
-            {"all_ids": discovered_node_ids},
-        ).single()
-        total_relationships = (
-            count_record["relationship_count"] if count_record else 0
-        )
-        loaded_relationships = 0
-        if progress_callback:
-            progress_callback(
-                "building_relationships", 0, total_relationships
-            )
-
-        for batch_start in range(0, total_nodes, RESULT_BATCH_SIZE):
-            if cancel_check:
-                cancel_check()
-            source_ids = discovered_node_ids[
-                batch_start:batch_start + RESULT_BATCH_SIZE
-            ]
-            relationship_query = Query(
-                """
-                UNWIND $source_ids AS source_id
-                MATCH (source) WHERE id(source) = source_id
-                MATCH (source)-[relationship]->(target)
-                WHERE id(target) IN $all_ids
-                RETURN collect({
-                    relationship: relationship,
-                    sourceName: startNode(relationship).name,
-                    targetName: endNode(relationship).name
-                }) AS relationships
-                """,
-                metadata={"search_job_id": job_id} if job_id else None,
-            )
-            record = session.run(
-                relationship_query,
-                {
-                    "source_ids": source_ids,
-                    "all_ids": discovered_node_ids,
-                },
-            ).single()
-            batch_relationships = record["relationships"] if record else []
-            relationships.extend(batch_relationships)
-            loaded_relationships += len(batch_relationships)
-            if progress_callback:
-                progress_callback(
-                    "building_relationships",
-                    min(loaded_relationships, total_relationships),
-                    total_relationships,
-                )
-
-        print(
-            f"Result graph contains {len(nodes_data)} node rows and "
-            f"{len(relationships)}/{total_relationships} raw relationships."
-        )
-        if progress_callback:
-            progress_callback(
-                "building_relationships",
-                total_relationships,
-                total_relationships,
-            )
-
-    if cancel_check:
-        cancel_check()
-    if progress_callback:
-        progress_callback("formatting_result", 0, 0)
+        # Requête Cypher : récupère les nœuds, auteurs, datasets et relations entre eux
+        results = session.run("""
+            MATCH (n) WHERE id(n) IN $ids
+            OPTIONAL MATCH (author:Author)-[:POSTED]->(n)
+            OPTIONAL MATCH (dataset:Dataset)-[:USED_IN]->(n)
+            OPTIONAL MATCH (o:Model) WHERE o.name = $origin_name
+            CALL {
+                WITH n,o
+                OPTIONAL MATCH p = (n)-[:USED_IN*1..]->(o)
+                WITH n,o, length(p) AS rel_asc
+                OPTIONAL MATCH p= (n)<-[r:USED_IN*1..]-(o)
+                WITH n,o, rel_asc, length(p) AS rel_desc
+                OPTIONAL MATCH (ancestor:Model)-[:USED_IN*1..]->(n)
+                WITH n, rel_asc, rel_desc, count(DISTINCT ancestor) AS ascendantsCount
+                OPTIONAL MATCH (descendant:Model)<-[:USED_IN*1..]-(n)
+                WITH n,rel_asc, rel_desc, ascendantsCount, count(DISTINCT descendant) AS descendantsCount
+                OPTIONAL MATCH (citation:Model)<-[:USED_IN]-(n)
+                RETURN ascendantsCount, descendantsCount, count(DISTINCT citation) AS citationCount,rel_asc, rel_desc
+            }
+            WITH n, author,dataset, ascendantsCount, descendantsCount, citationCount,rel_asc, rel_desc
+            WITH collect({
+                id: id(n),
+                node: n,
+                dataset: properties(dataset),
+                author: properties(author),
+                task: n.task,
+                license: n.license,
+                createdAt:n.createdAt,
+                likes:n.likes,
+                properties: properties(n),
+                labels: labels(n),
+                ascendantsCount: ascendantsCount,
+                descendantsCount: descendantsCount,
+                citationCount: citationCount,  
+                distance: CASE
+                    WHEN rel_asc IS NOT NULL THEN -rel_asc
+                    WHEN rel_desc IS NOT NULL THEN rel_desc
+                    ELSE 0
+                END
+            }) AS nodes_data
+            CALL {
+                WITH nodes_data
+                UNWIND [item IN nodes_data | item.node] AS n1
+                UNWIND [item IN nodes_data | item.node] AS n2
+                MATCH (n1)-[r]-(n2)
+                RETURN collect(r) AS rels
+            }
+            RETURN nodes_data, rels
+        """, {"ids": list(all_discovered_node_ids), "origin_name": origin_name})
 
+        subgraph = results.single()
+        if not subgraph:
+            return
     count=0
-    # --- PHASE 4 : Formatage des nœuds et des arêtes ---
-    for node_obj in nodes_data:
+    # --- PHASE 3 : Formatage des nœuds et des arêtes ---
+    for node_obj in subgraph["nodes_data"]:
         # Extraire et compléter les propriétés du nœud
         node_properties = dict(node_obj["properties"])
         node_properties.update({
@@ -1229,10 +450,9 @@ def process_gds_bfs_results(
 
     # Construction des arêtes, en évitant les doublons
     added_edges_canonical_keys = set()
-    for relationship_data in relationships:
-        rel_obj = relationship_data["relationship"]
-        source_name = relationship_data["sourceName"]
-        target_name = relationship_data["targetName"]
+    for rel_obj in subgraph["rels"]:
+        source_name = rel_obj.start_node["name"]
+        target_name = rel_obj.end_node["name"]
         if not source_name or not target_name:
             continue
 
@@ -1249,13 +469,13 @@ def process_gds_bfs_results(
             })
 
 
-atexit.register(lambda: search_executor.shutdown(wait=False, cancel_futures=True))
-atexit.register(lambda: driver.close())
-atexit.register(lambda: gds.close())
-
-
 if __name__ == '__main__':
-    # Threaded mode lets the browser poll job status while the worker performs
-    # the search. The debug reloader is intentionally disabled because its
-    # second process would maintain a separate in-memory job registry.
-    app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)
+    # Le script de démarrage n'a plus besoin de projeter le graphe.
+    # Il se contente de lancer l'application. La projection se fera à la demande.
+    app.run(host='0.0.0.0', port=7860, debug=True)
+    
+    # Le driver doit être fermé quand l'application s'arrête.
+    # Une manière simple est d'utiliser `atexit`
+    import atexit
+    atexit.register(lambda: driver.close())
+    atexit.register(lambda: gds.close())

application_neo4j/app_algorithms.py

@@ -3,164 +3,79 @@ from graphdatascience import GraphDataScience
 from typing import Dict, List, Any
 import pandas as pd
 from translations import t
-from neo4j import Query
 
-def run_gds_bfs(
-    gds: GraphDataScience,
-    natural_graph_name: str,
-    reverse_graph_name: str,
-    source_name: str,
-    max_depth: int = None,
-    expert=False,
-    source_labels=None,
-    job_id: str = None,
-    progress_callback=None,
-    neo4j_driver=None,
-    cancel_check=None,
-) -> Dict[str, Any]:
+def run_gds_bfs(gds: GraphDataScience, natural_graph_name: str, reverse_graph_name: str, source_name: str, max_depth: int = None, expert = False) -> Dict[str, Any]:
     """
-    Parcourt les descendants et ascendants avec le fork OpenGDS.
+    Exécute un parcours en largeur (BFS) directionnel à l'aide de GDS pour trouver les descendants et les ascendants.
 
-    Le plugin personnalisé ajoute au résultat standard ``nodeIds`` une liste
-    ``depths`` alignée. La profondeur minimale de chaque nœud est ainsi calculée
-    pendant le BFS, sans second parcours Cypher.
+    Cette fonction nécessite deux graphes pré-projetés en mémoire GDS :
+    - Un graphe "naturel" pour trouver les descendants (relations dans le sens source -> cible).
+    - Un graphe "inversé" pour trouver les ascendants (relations dans le sens cible -> source).
+
+    Args:
+        gds: L'objet de connexion à la bibliothèque Graph Data Science.
+        natural_graph_name: Le nom du graphe GDS projeté avec une orientation NATURELLE.
+        reverse_graph_name: Le nom du graphe GDS projeté avec une orientation INVERSÉE.
+        source_name: La propriété 'name' du nœud de départ de la recherche.
+        max_depth: La profondeur maximale de recherche. Si None, la recherche est illimitée.
 
     Returns:
-        L'identifiant et le label de la source, ainsi que les résultats GDS
-        des parcours descendant et ascendant.
+        Un dictionnaire contenant l'ID du nœud source et deux DataFrames pandas :
+        un pour les chemins des descendants et un pour les chemins des ascendants.
     """
-    requested_source_labels = [
-        label
-        for label in (source_labels or [])
-        if label in ("Model", "Dataset", "Author")
-    ]
+    # GDS fonctionne avec des identifiants de nœuds internes (des nombres), pas avec des noms.
+    # La première étape est donc de trouver l'ID numérique de notre nœud de départ à partir de son nom.
     try:
         source_id_result = gds.run_cypher(
             """
-            MATCH (n {name: $source_name})
-            WHERE size($source_labels) = 0
-               OR any(label IN labels(n) WHERE label IN $source_labels)
-            RETURN id(n) AS id, labels(n) AS label
+            MATCH (n {name: $source_name}) 
+            RETURN id(n) AS id , labels(n) as label      
+            LIMIT 1                       
             """,
-            {
-                "source_name": source_name,
-                "source_labels": requested_source_labels,
-            },
+            {"source_name": source_name}
         )
-
-        if source_id_result.empty:
-            print(f"Le modèle ou dataset avec le nom '{source_name}' n'a pas été trouvé.")
-            return None
-
-        label_preferences = requested_source_labels or [
-            "Model",
-            "Dataset",
-            "Author",
-        ]
-        selected_source = None
-        source_label = None
-        for preferred_label in label_preferences:
-            matching_sources = source_id_result[
-                source_id_result["label"].apply(
-                    lambda node_labels: preferred_label in node_labels
-                )
-            ]
-            if not matching_sources.empty:
-                selected_source = matching_sources.iloc[0]
-                source_label = preferred_label
-                break
-        if selected_source is None:
-            selected_source = source_id_result.iloc[0]
-            source_label = selected_source["label"][0]
-
-        if source_label == "Author" and not expert:
+        
+        if source_id_result.empty or (source_id_result["label"][0]==["Author"] and not expert):
             print(f"Le modèle ou dataset avec le nom '{source_name}' n'a pas été trouvé.")
-            return None
-
-        source_node_id = int(selected_source["id"])
+            return None # Retourne des DataFrames vides
+        
+        # On récupère l'ID de la première ligne du résultat.
+        source_node_id = source_id_result['id'][0]
     except Exception as e:
         print(f"Erreur lors de la recherche de l'ID du nœud source pour '{source_name}': {e}")
-        return None
+        return {"source_label": source_id_result["label"][0][0],"descendant": pd.DataFrame(), "ascendant": pd.DataFrame()}
 
-    bfs_params = {"sourceNode": source_node_id}
+    # Préparation des paramètres pour l'algorithme BFS.
+    bfs_params = {'sourceNode': source_node_id}
+    print(bfs_params)
+    # Si une profondeur maximale est spécifiée, on l'ajoute aux paramètres.
     if max_depth is not None:
-        bfs_params["maxDepth"] = max_depth
-
-    def run_bfs(graph_name, params):
-        if cancel_check:
-            cancel_check()
-        if neo4j_driver is None:
-            graph = gds.graph.get(graph_name)
-            result = gds.bfs.stream(graph, **params)
-        else:
-            query = Query(
-                """
-                CALL gds.bfs.stream($graph_name, $configuration)
-                YIELD nodeIds, depths
-                RETURN nodeIds, depths
-                """,
-                metadata={"search_job_id": job_id},
-            )
-            with neo4j_driver.session() as neo4j_session:
-                records = neo4j_session.run(
-                    query,
-                    {
-                        "graph_name": graph_name,
-                        "configuration": params,
-                    },
-                )
-                result = pd.DataFrame(
-                    record.data() for record in records
-                )
-        if cancel_check:
-            cancel_check()
-        return result
-
-    desc_job_id = f"{job_id}-descendants" if job_id else None
-    if desc_job_id:
-        bfs_params["jobId"] = desc_job_id
-    if progress_callback:
-        progress_callback("searching_descendants", desc_job_id)
-    desc_df = run_bfs(natural_graph_name, bfs_params)
-    _validate_depths_result(desc_df)
-    print("BFS descendants terminé avec les profondeurs.")
-
-    asc_job_id = f"{job_id}-ancestors" if job_id else None
-    if asc_job_id:
-        bfs_params["jobId"] = asc_job_id
-    elif "jobId" in bfs_params:
-        del bfs_params["jobId"]
-    if progress_callback:
-        progress_callback("searching_ancestors", asc_job_id)
-    asc_df = run_bfs(reverse_graph_name, bfs_params)
-    _validate_depths_result(asc_df)
-    print("BFS ascendants terminé avec les profondeurs.")
-
+        bfs_params['maxDepth'] = max_depth
+
+    # --- Exécution du BFS pour trouver les DESCENDANTS sur le graphe NATUREL ---
+    # On récupère l'objet graphe depuis GDS.
+    g_natural = gds.graph.get(natural_graph_name)
+    # On exécute l'algorithme BFS en mode `stream` pour obtenir les chemins.
+    desc_df = gds.bfs.stream(g_natural, **bfs_params)
+    print("BFS pour les descendants sur le graphe naturel terminé.")
+
+    # --- Exécution du BFS pour trouver les ASCENDANTS sur le graphe INVERSÉ ---
+    # Utiliser un graphe inversé est très efficace pour trouver les parents/ancêtres.
+    g_reverse = gds.graph.get(reverse_graph_name)
+    asc_df = gds.bfs.stream(g_reverse, **bfs_params)
+    print("BFS pour les ascendants sur le graphe inversé terminé.")
+    print("DESC",desc_df)
+    print("ASC",asc_df)
+    print(source_id_result["label"][0][0])
+
+    # Retourne les résultats sous forme d'un dictionnaire structuré.
     return {
-        "source_node": source_node_id,
-        "source_label": source_label,
+        "source_node": source_node_id,"source_label": source_id_result["label"][0][0],
         "descendant": desc_df,
-        "ascendant": asc_df,
+        "ascendant": asc_df
     }
 
 
-def _validate_depths_result(result: pd.DataFrame) -> None:
-    """Fail explicitly if Neo4j did not load the custom OpenGDS plugin."""
-    if result.empty:
-        return
-    if "depths" not in result.columns:
-        raise RuntimeError(
-            "Le plugin OpenGDS personnalisé n'est pas chargé : "
-            "gds.bfs.stream ne renvoie pas la colonne depths."
-        )
-    node_ids = result["nodeIds"].iloc[0]
-    depths = result["depths"].iloc[0]
-    if len(node_ids) != len(depths):
-        raise RuntimeError(
-            "Résultat BFS invalide : nodeIds et depths n'ont pas la même taille."
-        )
-
-
 
 
 
@@ -186,50 +101,50 @@ def get_genealogy_highlights(gds: "GraphDataScience", model_name: str, num_highl
     # Les classes CSS sont directement des classes Bootstrap 5 pour simplifier le rendu dans le template HTML.
     badges_info = {
     'desc_cited_1': {
-        'text_key': 'badge.desc_cited_1.text',
+        'text': t('badge.desc_cited_1.text', lang), 
         'class': 'bg-success',
-        'title_key': 'badge.desc_cited_1.title'
+        'title': t('badge.desc_cited_1.title', lang)
     },
     'desc_cited_2': {
-        'text_key': 'badge.desc_cited_2.text',
+        'text': t('badge.desc_cited_2.text', lang), 
         'class': 'bg-success bg-opacity-75',
-        'title_key': 'badge.desc_cited_2.title'
+        'title': t('badge.desc_cited_2.title', lang)
     },
     'desc_downloaded_1': {
-        'text_key': 'badge.desc_downloaded_1.text',
+        'text': t('badge.desc_downloaded_1.text', lang), 
         'class': 'beta',
-        'title_key': 'badge.desc_downloaded_1.title'
+        'title': t('badge.desc_downloaded_1.title', lang)
     },
     'desc_downloaded_2': {
-        'text_key': 'badge.desc_downloaded_2.text',
+        'text': t('badge.desc_downloaded_2.text', lang), 
         'class': 'alpha',
-        'title_key': 'badge.desc_downloaded_2.title'
+        'title': t('badge.desc_downloaded_2.title', lang)
     },
     
     'asc_foundation': {
-        'text_key': 'badge.asc_foundation.text',
+        'text': t('badge.asc_foundation.text', lang), 
         'class': 'bg-warning text-dark',
-        'title_key': 'badge.asc_foundation.title'
+        'title': t('badge.asc_foundation.title', lang)
     },
     'asc_cited_1': {
-        'text_key': 'badge.asc_cited_1.text',
+        'text': t('badge.asc_cited_1.text', lang), 
         'class': 'bg-success',
-        'title_key': 'badge.asc_cited_1.title'
+        'title': t('badge.asc_cited_1.title', lang)
     },
     'asc_cited_2': {
-        'text_key': 'badge.asc_cited_2.text',
+        'text': t('badge.asc_cited_2.text', lang), 
         'class': 'bg-success bg-opacity-75',
-        'title_key': 'badge.asc_cited_2.title'
+        'title': t('badge.asc_cited_2.title', lang)
     },
     'asc_downloaded_1': {
-        'text_key': 'badge.asc_downloaded_1.text',
+        'text': t('badge.asc_downloaded_1.text', lang), 
         'class': 'beta',
-        'title_key': 'badge.asc_downloaded_1.title'
+        'title': t('badge.asc_downloaded_1.title', lang)
     },
     'asc_downloaded_2': {
-        'text_key': 'badge.asc_downloaded_2.text',
+        'text': t('badge.asc_downloaded_2.text', lang), 
         'class': 'alpha',
-        'title_key': 'badge.asc_downloaded_2.title'
+        'title': t('badge.asc_downloaded_2.title', lang)
     },
     }
     
@@ -387,3 +302,4 @@ def create_node_data(node_props, label):
         }
 
     return { "id": node_props['name'], "label": label, **node_props }
+

application_neo4j/static/css/style.css

@@ -2,79 +2,13 @@
  *  STYLE GLOBAL & GRAPHIQUE SIGMA
  * =================================================================== */
 
-/* Explicit sizing and minimum widths avoid engine-specific flexbox
- * expansion differences (notably between Blink and Gecko). */
-html {
-  -webkit-text-size-adjust: 100%;
-  text-size-adjust: 100%;
-}
-
-body {
-  min-width: 320px;
-}
-
-.legacy-browser-warning {
-  display: none;
-  margin: 0;
-  padding: 0.75rem 1rem;
-  color: #664d03;
-  background: #fff3cd;
-  border-bottom: 1px solid #ffecb5;
-  font-weight: 600;
-  text-align: center;
-}
-
-img,
-svg {
-  max-width: 100%;
-  height: auto;
-}
-
-.row > *,
-.card,
-.card-body,
-.flex-grow-1 {
-  min-width: 0;
-}
-
-.navbar .container {
-  column-gap: 1rem;
-  row-gap: 0.75rem;
-}
-
-.navbar-brand {
-  min-width: 0;
-  max-width: 100%;
-  white-space: normal;
-}
-
-.navbar-brand small,
-#suggestions-list li {
-  overflow-wrap: anywhere;
-  word-break: break-word;
-}
-
-.navbar-actions {
-  min-width: 0;
-  margin-left: auto;
-}
-
  #sigma-container {
   width: 100%;
   height: 600px; /* Un peu plus de hauteur pour un meilleur confort */
-  position: relative;
-  overflow: hidden;
-  border: 1px solid #dee2e6;
-  border: 1px solid var(--bs-border-color, #dee2e6); /* Variable Bootstrap */
+  border: 1px solid var(--bs-border-color); /* Variable Bootstrap */
   margin-top: 1rem;
-  border-radius: 0.375rem;
-  border-radius: var(--bs-border-radius, 0.375rem); /* Variable Bootstrap */
-  background-color: #f8f9fa;
-  background-color: var(--bs-light-bg-subtle, #f8f9fa); /* Fond légèrement teinté */
-}
-
-#floating-legend {
-  max-width: calc(100% - 1rem);
+  border-radius: var(--bs-border-radius); /* Variable Bootstrap */
+  background-color: var(--bs-light-bg-subtle); /* Fond légèrement teinté */
 }
 
 /* ===================================================================
@@ -98,62 +32,35 @@ svg {
 /* ===================================================================
  *  STYLE DES TABLES (DATATABLES)
  * =================================================================== */
-/* A single, deterministic wrapping policy replaces the previous contradictory
- * normal/nowrap declarations. */
+/* Permet au texte de revenir à la ligne naturellement */
 #descendance-table th, #descendance-table td,
-#ascendance-table th, #ascendance-table td,
-#train-table th, #train-table td,
-#graph-models-table th, #graph-models-table td {
-    white-space: nowrap;
-    vertical-align: middle;
+#ascendance-table th, #ascendance-table td {
+    white-space: normal; /* <-- La correction clé ! */
+    word-wrap: break-word; /* Force le retour à la ligne des mots longs */
+    vertical-align: middle; /* Garde le centrage vertical */
 }
 
-#descendance-table th,
-#ascendance-table th,
-#train-table th {
-    min-width: 120px;
+/* On peut donner une largeur minimale aux colonnes pour garder une bonne structure */
+#descendance-table th, #ascendance-table th {
+    min-width: 120px; /* Ajustez cette valeur selon vos besoins */
 }
 
-#descendance-table th:first-child, #descendance-table td:first-child,
-#ascendance-table th:first-child, #ascendance-table td:first-child,
-#train-table th:first-child, #train-table td:first-child,
-#graph-models-table th:first-child, #graph-models-table td:first-child {
+/* Cas spécifique pour les colonnes potentiellement longues comme le nom du modèle */
+#descendance-table th:first-child, #ascendance-table th:first-child {
     min-width: 200px;
-    white-space: normal;
-    overflow-wrap: anywhere;
-    word-break: break-word;
 }
 
-.table-responsive,
-div.dataTables_wrapper,
-div.dataTables_wrapper div.dataTables_scroll {
-  width: 100%;
-  max-width: 100%;
-}
-
-.table-responsive,
-div.dataTables_wrapper div.dataTables_scrollBody {
-  overflow-x: auto !important;
-  -webkit-overflow-scrolling: touch;
-}
-
-div.dataTables_wrapper div.dataTables_scrollHeadInner {
-  min-width: 100%;
-}
-
-div.dataTables_wrapper table.dataTable {
-  margin-left: 0 !important;
-  margin-right: 0 !important;
-  table-layout: auto;
+/* Empêche le texte de se couper dans les cellules, force le défilement horizontal */
+#descendance-table th, #descendance-table td,
+#ascendance-table th, #ascendance-table td {
+    white-space: nowrap;
+    vertical-align: middle; /* Centrage vertical pour un look plus propre */
 }
 
 /* Personnalisation de l'input de recherche de DataTables pour qu'il ressemble à un champ Bootstrap */
 div.dataTables_wrapper div.dataTables_filter input {
-  max-width: 100%;
-  border: 1px solid #dee2e6;
-  border: 1px solid var(--bs-border-color, #dee2e6);
-  border-radius: 0.375rem;
-  border-radius: var(--bs-border-radius, 0.375rem);
+  border: 1px solid var(--bs-border-color);
+  border-radius: var(--bs-border-radius);
   padding: 0.375rem 0.75rem;
   margin-left: 0.5em;
 }
@@ -193,12 +100,8 @@ div.dataTables_wrapper .table thead th.sorting_desc::after {
   /* Ce style est pour si vous utilisez une <ul> simple.
      Si vous avez bien une <ul class="list-group">, vous pouvez supprimer ce bloc. */
   box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
-  max-width: 100%;
-  overflow-x: hidden;
-  border-radius: 0.375rem;
-  border-radius: var(--bs-border-radius, 0.375rem);
-  background-color: #f8f9fa;
-  background-color: var(--bs-light, #f8f9fa);
+  border-radius: var(--bs-border-radius);
+  background-color: var(--bs-light);
 }
 #suggestions-list li:hover {
   background-color:  #94bfeb; ;
@@ -295,22 +198,11 @@ div.dataTables_wrapper .table thead th.sorting_desc::after {
 }
 
 /* Change la couleur de fond des cases à cocher lorsqu'elles sont cochées */
-.btn-primary {
+.btn {
   background-color: #6a11cb; 
   border-color:#6a11cb;    
 }
 
-.btn-outline-primary {
-  color: #6a11cb;
-  border-color: #6a11cb;
-}
-
-.btn-outline-primary:hover {
-  color: #fff;
-  background-color: #6a11cb;
-  border-color: #6a11cb;
-}
-
 .stretched-link{
 color: #6a11cb; 
 }
@@ -376,31 +268,4 @@ main {
 .btn-modern:hover {
   background: linear-gradient(135deg, #5a0fbf, #1d63e1);
   transform: translateY(-3px);
-}
-
-@media (max-width: 575.98px) {
-  .navbar-brand,
-  .navbar-actions {
-    flex: 1 1 100%;
-    margin-right: 0;
-  }
-
-  .navbar-actions {
-    justify-content: flex-start !important;
-  }
-
-  #sigma-container {
-    height: 70vh;
-    min-height: 420px;
-  }
-
-  div.dataTables_wrapper div.dataTables_filter label {
-    display: block;
-    width: 100%;
-  }
-
-  div.dataTables_wrapper div.dataTables_filter input {
-    width: 100%;
-    margin: 0.375rem 0 0;
-  }
-}
+}

application_neo4j/static/js/browser_compatibility.js

@@ -1,14 +0,0 @@
-(function () {
-  "use strict";
-
-  // `document.documentMode` is exposed by Internet Explorer only. The rest of
-  // the application deliberately targets maintained browsers supported by
-  // Bootstrap 5.
-  if (document.documentMode) {
-    var warning = document.getElementById("legacy-browser-warning");
-    if (warning) {
-      warning.hidden = false;
-      warning.style.display = "block";
-    }
-  }
-}());

application_neo4j/static/js/script.js

@@ -193,15 +193,12 @@ document.addEventListener("DOMContentLoaded", () => {
             const common_dt_options = {
                 "language": { "url": datatablesLangUrl },
                 "pageLength": 10,
-                "responsive": true,
-                "scrollX": true,
-                // Afficher en premier les modèles les plus téléchargés.
-                "order": [[2, "desc"]],
+                "responsive": true,"scrollX": true , "scrollY":true,
                 "columnDefs": [
                 {
                     // Appliquer notre plugin 'numeric-string' aux colonnes cibles
                     "type": "numeric-string", 
-                    "targets": [2, 4, 8, 9, 10, 11] // Downloads, Likes, Distance, Ascendants, Descendants, Citations
+                    "targets": [2, 4, 6, 7, 8, 9] // Indices des colonnes: Downloads, Likes, Distance, etc.
                 }
             ]
                 // "searching" est activé par défaut, on peut le customiser
@@ -233,12 +230,12 @@ document.addEventListener("DOMContentLoaded", () => {
                     node.id || "N/A",
                     node.author || "Inconnu",
                     // La conversion en string via la condition est parfaite ici
-                    String(node.downloads ?? (I18N['js.unknown'] || "Inconnu")),
-                    node.task || (I18N['js.unknown_f'] || "Inconnue"),
+                    String(node.downloads ?? (window.__I18N['js.unknown'] || "Inconnu")),
+                    node.task || (window.__I18N['js.unknown_f'] || "Inconnue"),
                     String(node.likes ?? "0"),
-                    String(node.createdAt ?? (I18N['js.unknown_f'] || "Inconnue")),
-                    node.dataset || (I18N['js.unknown'] || "Inconnu"),
-                    node.license || (I18N['js.unknown_f'] || "Inconnue"),
+                    String(node.createdAt ?? (window.__I18N['js.unknown_f'] || "Inconnue")),
+                    node.dataset || (window.__I18N['js.unknown'] || "Inconnu"),
+                    node.license || (window.__I18N['js.unknown_f'] || "Inconnue"),
                     distance > 0 ? `+${distance}` : String(distance ?? 0),
                     String(node.ascendantsCount ?? "0"),
                     String(node.descendantsCount ?? "0"),
@@ -354,4 +351,4 @@ document.addEventListener("DOMContentLoaded", () => {
         checkbox.addEventListener('change', toggleDepthInput);
         toggleDepthInput();
     }
-});
+});

application_neo4j/static/js/script_dataset.js

@@ -209,8 +209,7 @@ document.addEventListener("DOMContentLoaded", () => {
             const common_dt_options = {
                 "language": { "url": datatablesLangUrl },
                 "pageLength": 10,
-                "responsive": true,
-                "scrollX": true,
+                "responsive": true,"scrollX": true , "scrollY":true,
                 "columnDefs": [
                 {
                     // Appliquer notre plugin 'numeric-string' aux colonnes cibles
@@ -244,12 +243,12 @@ document.addEventListener("DOMContentLoaded", () => {
                     node.id || "N/A",
                     node.author || "Inconnu",
                     // La conversion en string via la condition est parfaite ici
-                    String(node.downloads ?? (I18N['js.unknown'] || "Inconnu")),
-                    node.task || (I18N['js.unknown_f'] || "Inconnue"),
+                    String(node.downloads ?? (window.__I18N['js.unknown'] || "Inconnu")),
+                    node.task || (window.__I18N['js.unknown_f'] || "Inconnue"),
                     String(node.likes ?? "0"),
-                    String(node.createdAt ?? (I18N['js.unknown_f'] || "Inconnue")),
-                    node.dataset || (I18N['js.unknown'] || "Inconnu"),
-                    node.license || (I18N['js.unknown_f'] || "Inconnue"),
+                    String(node.createdAt ?? (window.__I18N['js.unknown_f'] || "Inconnue")),
+                    node.dataset || (window.__I18N['js.unknown'] || "Inconnu"),
+                    node.license || (window.__I18N['js.unknown_f'] || "Inconnue"),
                     String(node.ascendantsCount ?? "0"),
                     String(node.descendantsCount ?? "0"),
                     String(node.citationCount ?? "0")
@@ -362,4 +361,4 @@ document.addEventListener("DOMContentLoaded", () => {
         checkbox.addEventListener('change', toggleDepthInput);
         toggleDepthInput();
     }
-});
+});

application_neo4j/static/js/script_expert.js

@@ -34,9 +34,9 @@ function populateGraphModelsTable(graphData, table) {
         
 
         // Construction de la ligne avec les nouvelles données
-        const unknown = I18N['js.unknown'] || "Inconnu";
-        const unknownF = I18N['js.unknown_f'] || "Inconnue";
-        const na = I18N['js.na'] || "N/A";
+        const unknown = window.__I18N['js.unknown'] || "Inconnu";
+        const unknownF = window.__I18N['js.unknown_f'] || "Inconnue";
+        const na = window.__I18N['js.na'] || "N/A";
         const rowData = [
             node.id || na,
             node.author || unknown,
@@ -380,3 +380,4 @@ document.addEventListener("DOMContentLoaded", () => {
 
       
 });
+

application_neo4j/static/js/search_progress.js

@@ -1,324 +0,0 @@
-(() => {
-  const POLL_INTERVAL_MS = 750;
-  let activeCancelUrl = null;
-
-  function translate(key, fallback) {
-    return window.__I18N_DATA?.[key] || fallback;
-  }
-
-  function format(template, values) {
-    return Object.entries(values).reduce(
-      (text, [key, value]) => text.replace(`{${key}}`, String(value)),
-      template
-    );
-  }
-
-  function stageLabel(stage) {
-    const labels = {
-      queued: ["search.progress_stage_queued", "En attente du serveur…"],
-      preparing_graph: ["search.progress_stage_preparing", "Préparation du graphe…"],
-      searching_descendants: ["search.progress_stage_descendants", "Recherche des descendants…"],
-      searching_ancestors: ["search.progress_stage_ancestors", "Recherche des ascendants…"],
-      building_result: ["search.progress_stage_result", "Construction du résultat…"],
-      building_nodes: ["search.progress_stage_nodes", "Analyse des nœuds du résultat…"],
-      building_relationships: ["search.progress_stage_relationships", "Chargement des relations…"],
-      formatting_result: ["search.progress_stage_formatting", "Mise en forme du résultat…"],
-      building_highlights: ["search.progress_stage_highlights", "Calcul des modèles importants…"],
-      completed: ["search.progress_stage_completed", "Recherche terminée."],
-      failed: ["search.progress_stage_failed", "La recherche a échoué."],
-      cancelled: ["search.progress_stage_cancelled", "Recherche annulée."],
-    };
-    const [key, fallback] = labels[stage] || labels.queued;
-    return translate(key, fallback);
-  }
-
-  function findProgressPanel(form) {
-    return form.parentElement.querySelector(".search-progress");
-  }
-
-  function setSubmitting(form, submitting) {
-    form.dataset.submitting = submitting ? "true" : "false";
-    const submitButton = form.querySelector('button[type="submit"]');
-    if (submitButton) submitButton.disabled = submitting;
-  }
-
-  function showError(form, progress, message) {
-    const stage = progress.querySelector(".search-progress-stage");
-    const status = progress.querySelector(".search-progress-status");
-    const bar = progress.querySelector(".search-progress-bar");
-    stage.textContent = translate(
-      "search.progress_stage_failed",
-      "La recherche a échoué."
-    );
-    status.textContent = message || translate(
-      "search.progress_connection_error",
-      "Impossible d’obtenir la progression depuis le serveur."
-    );
-    bar.style.width = "0%";
-    progress.classList.remove("alert-info");
-    progress.classList.add("alert-danger");
-    setSubmitting(form, false);
-  }
-
-  function showCancelled(form, progress) {
-    const stage = progress.querySelector(".search-progress-stage");
-    const status = progress.querySelector(".search-progress-status");
-    const note = progress.querySelector(".search-progress-note");
-    const bar = progress.querySelector(".search-progress-bar");
-    stage.textContent = stageLabel("cancelled");
-    status.textContent = "";
-    note.textContent = "";
-    bar.style.width = "0%";
-    progress.classList.remove("alert-info", "alert-danger");
-    progress.classList.add("alert-secondary");
-    setSubmitting(form, false);
-  }
-
-  function cancelActiveSearch() {
-    if (!activeCancelUrl) return;
-    const cancelUrl = activeCancelUrl;
-    activeCancelUrl = null;
-    if (
-      navigator.sendBeacon
-      && navigator.sendBeacon(
-        cancelUrl,
-        new Blob([], { type: "text/plain" })
-      )
-    ) {
-      return;
-    }
-    fetch(cancelUrl, {
-      method: "POST",
-      credentials: "same-origin",
-      keepalive: true,
-    }).catch(() => {});
-  }
-
-  function renderStatus(progress, job) {
-    const title = progress.querySelector(".search-progress-title");
-    const stage = progress.querySelector(".search-progress-stage");
-    const status = progress.querySelector(".search-progress-status");
-    const note = progress.querySelector(".search-progress-note");
-    const bar = progress.querySelector(".search-progress-bar");
-
-    stage.textContent = stageLabel(job.stage);
-
-    if (job.status === "queued" || job.stage === "queued") {
-      title.textContent = translate(
-        "search.progress_queue_title",
-        "Recherche en file d’attente"
-      );
-      progress.classList.remove("alert-info", "alert-danger", "alert-secondary");
-      progress.classList.add("alert-warning");
-
-      const queueDetails = [];
-      if (job.queue_position && job.queued_jobs) {
-        queueDetails.push(
-          format(
-            translate(
-              "search.progress_queue_position",
-              "Position dans la file : {position}/{total}"
-            ),
-            {
-              position: job.queue_position,
-              total: job.queued_jobs,
-            }
-          )
-        );
-        const jobsAhead = job.queue_position - 1;
-        if (jobsAhead === 0) {
-          queueDetails.push(
-            translate(
-              "search.progress_queue_next",
-              "Votre recherche est la prochaine."
-            )
-          );
-        } else {
-          queueDetails.push(
-            format(
-              translate(
-                jobsAhead === 1
-                  ? "search.progress_queue_ahead_one"
-                  : "search.progress_queue_ahead_many",
-                jobsAhead === 1
-                  ? "1 recherche devant la vôtre"
-                  : "{count} recherches devant la vôtre"
-              ),
-              { count: jobsAhead }
-            )
-          );
-        }
-      }
-      if (job.running_jobs) {
-        queueDetails.push(
-          format(
-            translate(
-              job.running_jobs === 1
-                ? "search.progress_queue_running_one"
-                : "search.progress_queue_running_many",
-              job.running_jobs === 1
-                ? "1 recherche en cours"
-                : "{count} recherches en cours"
-            ),
-            { count: job.running_jobs }
-          )
-        );
-      }
-      status.textContent = queueDetails.join(" · ");
-      note.textContent = translate(
-        "search.progress_queue_note",
-        "La recherche démarrera automatiquement dès qu’une capacité sera disponible."
-      );
-      bar.style.width = "0%";
-      bar.removeAttribute("aria-valuenow");
-      return;
-    }
-
-    title.textContent = translate(
-      "search.progress_title",
-      "Recherche en cours…"
-    );
-    progress.classList.remove("alert-warning", "alert-danger", "alert-secondary");
-    progress.classList.add("alert-info");
-
-    const details = [
-      format(
-        translate("search.progress_elapsed", "Temps écoulé : {seconds} s"),
-        { seconds: job.elapsed_seconds }
-      ),
-    ];
-
-    if (job.completed_items !== null && job.total_items) {
-      details.push(
-        format(
-          translate(
-            "search.progress_items",
-            "Éléments traités par le serveur : {completed}/{total}"
-          ),
-          {
-            completed: job.completed_items,
-            total: job.total_items,
-          }
-        )
-      );
-    }
-
-    if (job.progress_percent !== null) {
-      details.push(
-        format(
-          translate(
-            "search.progress_server_percent",
-            "Progression indiquée par le serveur : {percent} %"
-          ),
-          { percent: job.progress_percent }
-        )
-      );
-      bar.style.width = `${job.progress_percent}%`;
-      bar.setAttribute("aria-valuenow", String(job.progress_percent));
-    } else {
-      bar.style.width = "0%";
-      bar.removeAttribute("aria-valuenow");
-    }
-
-    if (job.remaining_seconds !== null) {
-      details.push(
-        format(
-          translate(
-            "search.progress_remaining_step",
-            "Temps restant estimé pour cette étape : {seconds} s"
-          ),
-          { seconds: job.remaining_seconds }
-        )
-      );
-    }
-
-    status.textContent = details.join(" · ");
-    note.textContent = translate(
-      "search.progress_server_note",
-      "La progression repose sur les opérations réellement terminées par le serveur."
-    );
-  }
-
-  async function readJson(response) {
-    const body = await response.json().catch(() => ({}));
-    if (!response.ok) {
-      throw new Error(body.error || `${response.status} ${response.statusText}`);
-    }
-    return body;
-  }
-
-  async function pollJob(form, progress, statusUrl) {
-    try {
-      const job = await readJson(await fetch(statusUrl, {
-        credentials: "same-origin",
-        cache: "no-store",
-      }));
-      renderStatus(progress, job);
-
-      if (job.status === "cancelled") {
-        activeCancelUrl = null;
-        showCancelled(form, progress);
-        return;
-      }
-      if (job.result_url) {
-        activeCancelUrl = null;
-        window.location.assign(job.result_url);
-        return;
-      }
-      window.setTimeout(() => pollJob(form, progress, statusUrl), POLL_INTERVAL_MS);
-    } catch (error) {
-      cancelActiveSearch();
-      showError(form, progress, error.message);
-    }
-  }
-
-  async function startSearch(form, progress) {
-    const formData = new FormData(form);
-    const endpoint = form.dataset.searchJobUrl || "/api/search-jobs";
-
-    progress.classList.remove("d-none", "alert-danger");
-    progress.classList.add("alert-info");
-    progress.querySelector(".search-progress-title").textContent = translate(
-      "search.progress_title",
-      "Recherche en cours…"
-    );
-    renderStatus(progress, {
-      stage: "queued",
-      elapsed_seconds: 0,
-      progress_percent: null,
-      remaining_seconds: null,
-      queue_position: null,
-      queued_jobs: null,
-      running_jobs: null,
-      completed_items: null,
-      total_items: null,
-    });
-    setSubmitting(form, true);
-
-    try {
-      const job = await readJson(await fetch(endpoint, {
-        method: "POST",
-        body: formData,
-        credentials: "same-origin",
-        headers: { Accept: "application/json" },
-      }));
-      activeCancelUrl = job.cancel_url;
-      pollJob(form, progress, job.status_url);
-    } catch (error) {
-      showError(form, progress, error.message);
-    }
-  }
-
-  document.addEventListener("DOMContentLoaded", () => {
-    document.querySelectorAll("form[data-search-progress]").forEach((form) => {
-      form.addEventListener("submit", (event) => {
-        event.preventDefault();
-        if (form.dataset.submitting === "true" || !form.reportValidity()) return;
-        const progress = findProgressPanel(form);
-        if (progress) startSearch(form, progress);
-      });
-    });
-  });
-
-  window.addEventListener("pagehide", cancelActiveSearch);
-})();

application_neo4j/static/js/utils.js

@@ -231,9 +231,6 @@ function formatDateFr(dateString) {
 
 // Fonction pour parser la valeur : enlève les espaces et convertit en nombre si possible
 function parseNumericValue(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return { isNumber: true, value };
-    }
     if (typeof value === 'string') {
         // Enlève les espaces (pour les nombres comme "12 345") et les virgules
         const cleanedValue = value.replace(/[\s,]/g, '');
@@ -247,7 +244,7 @@ function parseNumericValue(value) {
 }
 
 // Définition du tri ascendant
-jQuery.fn.dataTable.ext.type.order['numeric-string-asc'] = function (a, b) {
+jQuery.fn.dataTable.ext.order['numeric-string-asc'] = function (a, b) {
     const valA = parseNumericValue(a);
     const valB = parseNumericValue(b);
 
@@ -263,19 +260,9 @@ jQuery.fn.dataTable.ext.type.order['numeric-string-asc'] = function (a, b) {
     }
 };
 
-// Tri descendant, en conservant les valeurs inconnues après les nombres.
-jQuery.fn.dataTable.ext.type.order['numeric-string-desc'] = function (a, b) {
-    const valA = parseNumericValue(a);
-    const valB = parseNumericValue(b);
-
-    if (valA.isNumber && valB.isNumber) {
-        return valB.value - valA.value;
-    } else if (valA.isNumber && !valB.isNumber) {
-        return -1;
-    } else if (!valA.isNumber && valB.isNumber) {
-        return 1;
-    }
-    return String(valB.value).localeCompare(String(valA.value));
+// Le tri descendant est simplement l'inverse de l'ascendant
+jQuery.fn.dataTable.ext.order['numeric-string-desc'] = function (a, b) {
+    return jQuery.fn.dataTable.ext.order['numeric-string-asc'](a, b) * -1;
 };
 
 /**

application_neo4j/static/notice/generate_notice_en.py

@@ -1,503 +0,0 @@
-"""Generate the English version of the CNIL GenMod information notice.
-
-This is a maintainer utility, not a runtime dependency of the Space. Run it
-from the repository root after installing ``pypdf`` and ``reportlab``:
-
-    python application_neo4j/static/notice/generate_notice_en.py \
-        --source application_neo4j/static/notice/notice.pdf
-"""
-
-from __future__ import annotations
-
-import argparse
-import math
-import tempfile
-from pathlib import Path
-
-from PIL import Image as PillowImage
-from pypdf import PdfReader
-from reportlab.lib import colors
-from reportlab.lib.enums import TA_CENTER
-from reportlab.lib.pagesizes import A4
-from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
-from reportlab.lib.units import mm
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
-from reportlab.platypus import (
-    Flowable,
-    Image,
-    PageBreak,
-    Paragraph,
-    SimpleDocTemplate,
-    Spacer,
-    Table,
-    TableStyle,
-)
-
-
-CNIL_BLUE = colors.HexColor("#0046A8")
-LIGHT_BLUE = colors.HexColor("#EAF2FB")
-RED = colors.HexColor("#E52A22")
-GOLD = colors.HexColor("#F7B500")
-
-
-class NeuralNetworkDiagram(Flowable):
-    """Small English recreation of the neural-network diagram."""
-
-    def __init__(self, width=170 * mm, height=54 * mm):
-        super().__init__()
-        self.width = width
-        self.height = height
-
-    def draw(self):
-        canvas = self.canv
-        canvas.saveState()
-        scale_x = self.width / 480
-        scale_y = self.height / 155
-        canvas.scale(scale_x, scale_y)
-
-        inputs = [(45, 115), (45, 78), (45, 41)]
-        hidden_1 = [(190, 130), (190, 97), (190, 64), (190, 31)]
-        hidden_2 = [(330, 130), (330, 97), (330, 64), (330, 31)]
-        outputs = [(445, 113), (445, 78), (445, 43)]
-
-        canvas.setStrokeColor(colors.HexColor("#222222"))
-        canvas.setLineWidth(0.6)
-        for x1, y1 in inputs:
-            for x2, y2 in hidden_1:
-                canvas.line(x1 + 32, y1, x2 - 10, y2)
-        for x1, y1 in hidden_2:
-            for x2, y2 in outputs:
-                canvas.line(x1 + 10, y1, x2 - 32, y2)
-
-        canvas.setFont("DejaVuSans", 7.5)
-        for index, (x, y) in enumerate(inputs, 1):
-            canvas.setFillColor(colors.HexColor("#DDEFD6"))
-            canvas.roundRect(x - 32, y - 10, 64, 20, 4, fill=1, stroke=1)
-            canvas.setFillColor(colors.black)
-            canvas.drawCentredString(x, y - 3, f"Input {index}")
-        for layer in (hidden_1, hidden_2):
-            for x, y in layer:
-                canvas.setFillColor(colors.HexColor("#FFF1C9"))
-                canvas.circle(x, y, 10, fill=1, stroke=1)
-        for index, (x, y) in enumerate(outputs, 1):
-            canvas.setFillColor(colors.HexColor("#DCE9FF"))
-            canvas.roundRect(x - 32, y - 10, 64, 20, 4, fill=1, stroke=1)
-            canvas.setFillColor(colors.black)
-            canvas.drawCentredString(x, y - 3, f"Output {index}")
-
-        canvas.setFillColor(colors.white)
-        path = canvas.beginPath()
-        path.moveTo(255, 80)
-        path.lineTo(275, 98)
-        path.lineTo(295, 80)
-        path.lineTo(275, 62)
-        path.close()
-        canvas.drawPath(path, fill=1, stroke=1)
-        canvas.setFillColor(colors.black)
-        canvas.setFont("DejaVuSans", 10)
-        canvas.drawCentredString(275, 77, "f")
-        canvas.setFont("DejaVuSans", 7.5)
-        canvas.drawCentredString(190, 8, "Layer 1")
-        canvas.drawCentredString(330, 8, "Layer 2")
-        canvas.drawCentredString(275, 118, "Activation function")
-        canvas.drawCentredString(405, 145, "Edge parameters")
-        canvas.restoreState()
-
-
-class HuggingFaceDiagram(Flowable):
-    """English recreation of the platform example diagram."""
-
-    def __init__(self, width=170 * mm, height=55 * mm):
-        super().__init__()
-        self.width = width
-        self.height = height
-
-    def draw_arrow(self, canvas, x1, y1, x2, y2, color):
-        canvas.setStrokeColor(color)
-        canvas.setFillColor(color)
-        canvas.setLineWidth(1.8)
-        canvas.line(x1, y1, x2, y2)
-        angle = math.atan2(y2 - y1, x2 - x1)
-        for offset in (-0.5, 0.5):
-            canvas.line(
-                x2,
-                y2,
-                x2 - 7 * math.cos(angle + offset),
-                y2 - 7 * math.sin(angle + offset),
-            )
-
-    def box(self, canvas, x, y, width, height, text, color):
-        canvas.setStrokeColor(color)
-        canvas.setFillColor(colors.white)
-        canvas.rect(x, y, width, height, fill=1, stroke=1)
-        canvas.setFillColor(color)
-        canvas.setFont("DejaVuSans-Bold", 8)
-        canvas.drawCentredString(x + width / 2, y + height / 2 - 3, text)
-
-    def draw(self):
-        canvas = self.canv
-        canvas.saveState()
-        scale_x = self.width / 500
-        scale_y = self.height / 170
-        canvas.scale(scale_x, scale_y)
-        self.box(canvas, 5, 118, 70, 24, "USER A", CNIL_BLUE)
-        self.box(canvas, 105, 105, 105, 48, "", RED)
-        canvas.setFillColor(RED)
-        canvas.setFont("DejaVuSans-Bold", 8)
-        canvas.drawCentredString(157.5, 130, "MACHINE-LEARNING")
-        canvas.drawCentredString(157.5, 116, "MODEL")
-        self.box(canvas, 290, 105, 85, 48, "DATASET", RED)
-        self.box(canvas, 420, 118, 75, 24, "USER B", CNIL_BLUE)
-        self.box(canvas, 205, 15, 90, 26, "USER C", CNIL_BLUE)
-        self.box(canvas, 207, 66, 86, 25, "NEW MODEL", RED)
-
-        canvas.setFillColor(GOLD)
-        canvas.circle(250, 130, 21, fill=1, stroke=0)
-        canvas.setFillColor(colors.HexColor("#795500"))
-        canvas.setFont("DejaVuSans-Bold", 8)
-        canvas.drawCentredString(250, 127, "HF")
-        canvas.setFont("DejaVuSans-Bold", 7)
-        canvas.drawCentredString(250, 157, "Hugging Face")
-
-        self.draw_arrow(canvas, 75, 130, 101, 130, colors.black)
-        self.draw_arrow(canvas, 420, 130, 379, 130, colors.black)
-        self.draw_arrow(canvas, 210, 130, 225, 130, RED)
-        self.draw_arrow(canvas, 290, 130, 275, 130, RED)
-        self.draw_arrow(canvas, 250, 65, 250, 43, colors.black)
-        self.draw_arrow(canvas, 250, 93, 250, 106, RED)
-        self.draw_arrow(canvas, 157, 103, 218, 42, colors.HexColor("#2385CC"))
-        self.draw_arrow(canvas, 332, 103, 282, 42, colors.HexColor("#2385CC"))
-
-        canvas.setFillColor(colors.black)
-        canvas.setFont("DejaVuSans", 6.8)
-        canvas.drawString(5, 106, "individual or organisation")
-        canvas.drawString(402, 106, "individual or organisation")
-        canvas.drawCentredString(250, 3, "individual or organisation")
-        canvas.setFillColor(CNIL_BLUE)
-        canvas.setFont("DejaVuSans-Bold", 13)
-        canvas.drawString(12, 12, "CNIL")
-        canvas.restoreState()
-
-
-def extract_figures(source: Path, work_dir: Path) -> tuple[Path, Path]:
-    reader = PdfReader(str(source))
-    fox_image = reader.pages[2].images[0].image
-    fox_crop = fox_image.crop((0, 0, int(fox_image.width * 0.35), fox_image.height))
-    fox_path = work_dir / "fox.jpg"
-    fox_crop.save(fox_path, quality=92)
-
-    memorisation_path = work_dir / "memorisation.jpg"
-    reader.pages[5].images[0].image.save(memorisation_path, quality=92)
-    return fox_path, memorisation_path
-
-
-def build_styles():
-    pdfmetrics.registerFont(
-        TTFont("DejaVuSans", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf")
-    )
-    pdfmetrics.registerFont(
-        TTFont(
-            "DejaVuSans-Bold",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
-        )
-    )
-    styles = getSampleStyleSheet()
-    styles.add(
-        ParagraphStyle(
-            "NoticeTitle",
-            fontName="DejaVuSans-Bold",
-            fontSize=20,
-            leading=24,
-            textColor=CNIL_BLUE,
-            spaceAfter=8 * mm,
-        )
-    )
-    styles.add(
-        ParagraphStyle(
-            "Section",
-            fontName="DejaVuSans-Bold",
-            fontSize=14,
-            leading=17,
-            textColor=CNIL_BLUE,
-            spaceBefore=3 * mm,
-            spaceAfter=2.5 * mm,
-        )
-    )
-    styles.add(
-        ParagraphStyle(
-            "Subsection",
-            fontName="DejaVuSans-Bold",
-            fontSize=11,
-            leading=14,
-            textColor=colors.HexColor("#222222"),
-            spaceBefore=2 * mm,
-            spaceAfter=1.5 * mm,
-        )
-    )
-    styles.add(
-        ParagraphStyle(
-            "BodyNotice",
-            fontName="DejaVuSans",
-            fontSize=8.7,
-            leading=11.3,
-            alignment=4,
-            spaceAfter=2.1 * mm,
-        )
-    )
-    styles.add(
-        ParagraphStyle(
-            "Caption",
-            fontName="DejaVuSans",
-            fontSize=7.2,
-            leading=9,
-            alignment=TA_CENTER,
-            textColor=colors.HexColor("#555555"),
-            spaceAfter=2 * mm,
-        )
-    )
-    return styles
-
-
-def generate(source: Path, output: Path) -> None:
-    styles = build_styles()
-    body = styles["BodyNotice"]
-    title = styles["NoticeTitle"]
-    section = styles["Section"]
-    subsection = styles["Subsection"]
-    caption = styles["Caption"]
-
-    def p(text: str):
-        return Paragraph(text, body)
-
-    def bullet(text: str):
-        style = ParagraphStyle(
-            "BulletNotice",
-            parent=body,
-            leftIndent=5 * mm,
-            firstLineIndent=-3.5 * mm,
-            bulletIndent=1.5 * mm,
-            spaceAfter=1.4 * mm,
-        )
-        return Paragraph(text, style, bulletText="•")
-
-    with tempfile.TemporaryDirectory(prefix="genmod-notice-") as temp_dir:
-        fox_path, memorisation_path = extract_figures(source, Path(temp_dir))
-
-        doc = SimpleDocTemplate(
-            str(output),
-            pagesize=A4,
-            rightMargin=18 * mm,
-            leftMargin=18 * mm,
-            topMargin=18 * mm,
-            bottomMargin=16 * mm,
-            title="A tool for exploring the genealogy of open-source AI models",
-            author="CNIL",
-            subject="English translation of the GenMod information notice",
-        )
-
-        def decorate_page(canvas, document):
-            canvas.saveState()
-            canvas.setStrokeColor(CNIL_BLUE)
-            canvas.setLineWidth(1.2)
-            canvas.line(18 * mm, 12 * mm, A4[0] - 18 * mm, 12 * mm)
-            canvas.setFont("DejaVuSans-Bold", 8)
-            canvas.setFillColor(CNIL_BLUE)
-            canvas.drawString(18 * mm, 7.5 * mm, "CNIL · GenMod")
-            canvas.setFont("DejaVuSans", 8)
-            canvas.drawRightString(
-                A4[0] - 18 * mm, 7.5 * mm, f"Page {document.page}"
-            )
-            canvas.restoreState()
-
-        story = [
-            Paragraph(
-                "A tool for exploring the genealogy of open-source AI models",
-                title,
-            ),
-            Paragraph("What is an AI model?", section),
-            Paragraph("Training", subsection),
-            p(
-                "The fields in which AI can be used are vast and difficult to delimit, as they extend to many aspects of everyday life: online searches and purchases, targeted advertising, machine translation, personal digital assistants and connected cities, as well as transport, healthcare and many other areas."
-            ),
-            p(
-                "Under Article 3 of the European Union Artificial Intelligence Act, an AI system is ‘a machine-based system that is designed to operate with varying levels of autonomy and that may exhibit adaptiveness after deployment, and that, for explicit or implicit objectives, infers, from the input it receives, how to generate outputs such as predictions, content, recommendations, or decisions that can influence physical or virtual environments.’"
-            ),
-            p(
-                "These systems incorporate one or more AI models. Such models can be described as algorithms whose operation is determined by a set of attributes and which are designed to perform tasks such as prediction, classification, inference or generation. Deep neural-network models, for example, consist of nodes (neurons) arranged in layers and connected by edges, each of which has a parameter or ‘weight’. During training, these parameters are adjusted to learn the statistical distribution of the training data."
-            ),
-            p("For a simple neural network, the model’s attributes might include:"),
-            bullet("the type and size of each layer (linear, convolutional, attention, etc.);"),
-            bullet("the weights assigned to each edge (also called parameters);"),
-            bullet("the activation functions between layers; and"),
-            bullet("possibly other operations located within or between layers."),
-            Spacer(1, 1.5 * mm),
-            NeuralNetworkDiagram(),
-            Paragraph("Figure 1 — Diagram of a neural network (authors)", caption),
-            PageBreak(),
-            Paragraph("Training from examples", subsection),
-            p(
-                "When a neural network is trained to recognise images, it is given examples in which the image pixels are associated with an annotation, or label. The model then adjusts its parameters—the weights—to learn to assign the correct label as often as possible."
-            ),
-            p(
-                "The main difference between a deep-learning model and a conventional computer program is that the model learns inference rules autonomously from data. In a conventional program, a task is solved using explicit rules defined in advance by the developer. To sort a list of numbers, for example, the order in which elements are compared is precisely programmed. This works very well for clearly delimited tasks for which explicit rules can be established."
-            ),
-            p(
-                "By contrast, the rules of a deep-learning model are not specified directly. Instead, the model is given a large volume of examples—its training data—so that, during the learning phase, it can identify the statistical regularities or strategies that solve the task. This makes it possible to automate much more complex tasks for which defining every rule by hand would be extremely difficult or impossible."
-            ),
-            Paragraph("Using a trained model", subsection),
-            p(
-                "Once trained, a model can be used as it is, without further modification, to perform specific tasks automatically. This is called the inference phase. The model receives an input—an image, text or an audio signal, for example—and produces an output based on what it learned during training. It then acts as a ‘black box’: it applies the regularities it has learned without changing its internal structure or learning anything new."
-            ),
-            p(
-                "Consider machine translation. A neural-network model trained on millions of pairs of Spanish and English sentences can translate a new text from English into Spanish at inference time. Linguistic rules are not explicitly implemented in the model; it has learned to match sequences of words by drawing on statistical regularities in the training data."
-            ),
-            p(
-                "Another example is image-to-text models, which generate image captions. A model can be trained to associate images with textual descriptions. Once trained, it can receive a new image—such as a photograph of a dog running in a park—and automatically produce a sentence such as ‘A dog is running on the grass in a park.’"
-            ),
-            Table(
-                [[
-                    Image(str(fox_path), width=58 * mm, height=41 * mm),
-                    Paragraph(
-                        "The image is a close-up portrait of a red fox standing in the snow. The fox is in the centre, its vibrant orange fur lit by golden sunrise or sunset light. It stands alert, ears upright and looking off-camera. The pristine white snow has a bluish tint reflecting the cool colours of the sky. The softly blurred blue-grey background adds depth and highlights the fox as the subject.",
-                        body,
-                    ),
-                ]],
-                colWidths=[62 * mm, 105 * mm],
-                style=TableStyle([
-                    ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
-                    ("LEFTPADDING", (0, 0), (-1, -1), 2),
-                    ("RIGHTPADDING", (0, 0), (-1, -1), 4),
-                    ("BOX", (0, 0), (-1, -1), 0.4, colors.HexColor("#BBBBBB")),
-                    ("BACKGROUND", (0, 0), (-1, -1), colors.HexColor("#F7F7F7")),
-                ]),
-            ),
-            Paragraph(
-                "Figure 2 — Example of an image’s textual description (source: imagedescriber.online)",
-                caption,
-            ),
-            PageBreak(),
-            p(
-                "These use cases illustrate the power of advances in deep learning to automate complex, often subjective or ambiguous tasks for which writing explicit rules by hand would be difficult or impossible."
-            ),
-            Paragraph("Derivatives: fine-tuning, merging, quantisation, etc.", subsection),
-            p(
-                "To adapt a neural network more closely to a specific task, optimise its performance or reduce its running costs, several transformations can be applied to an initial pre-trained model. Such modifications are very common in the open-source ecosystem. They make it possible to create new models from one or more initial models, sometimes with additional data. Four common transformations between a target model and a source model are:"
-            ),
-            bullet(
-                "<b>Fine-tuning:</b> a general-purpose source model continues training on a specific dataset to improve its performance on a more precise task. A large language model initially trained on freely accessible internet sources may, for example, be fine-tuned on a company’s business data so that it better understands the company’s specialist vocabulary and expressions."
-            ),
-            bullet(
-                "<b>Quantisation:</b> the precision of the source model’s weights is reduced to lower its memory footprint. Weights initially encoded using 32 bits may, for example, be rounded to the nearest value that can be encoded using 16 bits."
-            ),
-            bullet(
-                "<b>Adaptation:</b> the source model is adjusted so that it can be used with limited computing resources—for example, on a mobile phone—most often using a Low-Rank Adaptation (LoRA) technique."
-            ),
-            bullet(
-                "<b>Merging:</b> layers from different models are combined to improve performance. For example, two LLMs, A and B, may both have been trained on general text corpora. Averaging the weights in their twelfth layers and replacing A’s twelfth layer with that average may produce a model C that performs better than either A or B."
-            ),
-            PageBreak(),
-            Paragraph("A platform for open-source AI: Hugging Face", section),
-            p(
-                "To enable AI models to be shared and made available by and for as many people as possible, the Franco-American company Hugging Face, founded in 2016, developed a platform that centralises models and datasets. It also provides software tools for deploying AI models. Today it hosts more open-source models than any other platform—over two million were available in September 2025—and acts as a catalyst for the open-source AI ecosystem."
-            ),
-            p("The following example illustrates how the platform works:"),
-            bullet("User C wants to create a model that automatically detects fraudulent emails."),
-            bullet(
-                "User A has published a natural-language-processing model on Hugging Face—for example, Google’s <i>google/gemma-3-27b-it</i>—and User B has published a dataset containing millions of emails labelled as fraudulent or non-fraudulent."
-            ),
-            bullet(
-                "User C downloads the model and dataset, then trains the model on the dataset to specialise it for classification. Once the resulting classifier performs well, User C can publish it on Hugging Face so that anyone can use it as is or train it again on other datasets to improve its performance."
-            ),
-            HuggingFaceDiagram(),
-            Paragraph("Figure 3 — Example of how Hugging Face is used", caption),
-            p(
-                "In short, Hugging Face provides tools for building, training and deploying deep-learning models based on open-source technologies and code. It also offers a space where researchers, engineers and enthusiasts can exchange ideas, obtain support and contribute to open-source projects."
-            ),
-            Paragraph("Benefits of open-source AI", section),
-            p(
-                "The rise of open-source AI shows that powerful and partly transparent models can compete with proprietary solutions while stimulating collective innovation. BLOOM (176 billion parameters, 2022), developed by the BigScience consortium, illustrates this dynamic: trained in 46 languages, it enabled multilingual conversational assistants to be developed in Africa, Latin America and the Arab world, where commercial models remained poorly adapted to local languages."
-            ),
-            PageBreak(),
-            p(
-                "Similarly, GPT-J and GPT-NeoX (EleutherAI) and Vicuna (LMSYS) provided the basis for open-source projects that enabled universities and start-ups to create specialised chatbots without relying on closed services. These models also made research into bias detection and the robustness of large language models possible."
-            ),
-            p(
-                "In computer vision, Stable Diffusion (Stability AI) transformed visual creation. Its weights were made freely available, opening the way to applications in video games, advertising and audiovisual production, including concept images, storyboards and rapid design. Its open-source code enabled tools such as Automatic1111 and ComfyUI, used by hundreds of thousands of artists and researchers."
-            ),
-            p(
-                "The impact is industrial as well. LLaMA (Meta), initially released to the research community, gave rise to a generation of derivatives—including Zephyr, Nous-Hermes and OpenChat—that are now used for customer support, summarising legal or medical documents and prototyping code."
-            ),
-            p(
-                "In science, projects such as BioGPT (Microsoft Research) and OpenFold (inspired by AlphaFold) demonstrate how opening code and weights accelerates biomedical research by allowing independent laboratories to reproduce and improve results in protein-structure prediction and molecule discovery."
-            ),
-            p(
-                "These achievements show that open source is not limited to reusing models: it enables technological ownership, local adaptation and open innovation in fields as varied as artistic creation, healthcare, education, data science and the cultural industries. Nevertheless, some opacity may remain as to how models are built: with what data and which training algorithm? A CNIL paper and a PEReN paper provide further discussion of this issue."
-            ),
-            Paragraph("Privacy issues", section),
-            Paragraph("Memorisation by AI models", subsection),
-            p(
-                "The scientific community has long established that information about the data used to train an AI model can often be extracted from even partial access to the model. In generative AI, a model may reproduce text or images that are very close to examples in its training dataset. In the figure below, when Stable Diffusion is asked to generate an image matching the caption ‘Emma Watson to play Belle in Disney’s Beauty and the Beast’, its output closely resembles an image from the training database."
-            ),
-            p(
-                "This is regurgitation—only one form of memorisation. Statistical methods can sometimes reveal other information, such as whether a particular record belonged to the training dataset, through membership-inference attacks."
-            ),
-            Image(str(memorisation_path), width=153 * mm, height=91 * mm),
-            Paragraph(
-                "Figure 4 — Source: Louis Hunt (LinkedIn). Original photograph: UN Women.",
-                caption,
-            ),
-            PageBreak(),
-            p(
-                "For text models such as chatbots, prominent cases of regurgitation are already widely documented. One version of ChatGPT, for example, was reported to reproduce New York Times articles almost verbatim and to provide personal information such as a person’s name, address and telephone number."
-            ),
-            Paragraph("The GDPR and AI models", subsection),
-            p(
-                "If information about an AI model’s training database can generally be extracted from the model, what legal regime should apply when that database contains personal data? The European Data Protection Board clarified this question in Opinion 28/2024 on AI models, on which the CNIL’s latest recommendations are based. In particular, the Opinion concludes that the GDPR applies in many cases to AI models trained on personal data because of their capacity for memorisation."
-            ),
-            Paragraph("Exercising rights in relation to AI models", subsection),
-            p(
-                "For AI models subject to the GDPR, people affected by memorisation have rights in relation to their data, including the rights to object, access and erasure. These rights are not absolute: a controller may depart from them in several situations, for example where a request is manifestly unfounded or excessive (Article 12), or where the controller is unable to identify the person concerned. The CNIL’s guidance on exercising rights provides further details."
-            ),
-            p(
-                "At a time when European bodies are confirming that data-protection law also applies to AI models, the CNIL wishes to study the conditions under which these rights could be exercised within the highly dynamic open-source AI ecosystem."
-            ),
-            Spacer(1, 8 * mm),
-            Table(
-                [[Paragraph(
-                    "This document is an English translation of the French information notice made available by the CNIL for the GenMod application. In the event of any discrepancy, the French version is the reference version.",
-                    ParagraphStyle(
-                        "TranslationNote",
-                        parent=body,
-                        textColor=CNIL_BLUE,
-                        backColor=LIGHT_BLUE,
-                        borderPadding=8,
-                    ),
-                )]],
-                colWidths=[170 * mm],
-            ),
-        ]
-
-        doc.build(story, onFirstPage=decorate_page, onLaterPages=decorate_page)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--source",
-        type=Path,
-        default=Path("application_neo4j/static/notice/notice.pdf"),
-    )
-    parser.add_argument(
-        "--output",
-        type=Path,
-        default=Path("application_neo4j/static/notice/notice_en.pdf"),
-    )
-    args = parser.parse_args()
-    args.output.parent.mkdir(parents=True, exist_ok=True)
-    generate(args.source, args.output)
-    print(f"Generated {args.output}")
-
-
-if __name__ == "__main__":
-    main()

application_neo4j/static/notice/notice.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:98c0455e1d8419a184a2471fc69960027976f9cb7d9ee07752516c3b216b4a79
-size 1166198
+oid sha256:dced59e9dc43bd1823fd18cee4005415e375e9f77c7a58bc6ffcf3a48e732a3c
+size 409000

application_neo4j/static/notice/notice_en.pdf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:abec965848c0fd334609151abd08615455a57872fbd0709961e6c8a8ddb2e93b
-size 383279

application_neo4j/templates/expert.html

@@ -18,18 +18,13 @@
 </head>
 
 <body class="d-flex flex-column min-vh-100">
-    <div id="legacy-browser-warning" class="legacy-browser-warning" role="alert" hidden>{{ t('site.legacy_browser_warning') }}</div>
-    <script src="{{ url_for('static', filename='js/browser_compatibility.js') }}"></script>
     <header class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
     <div class="container">
       <a class="navbar-brand" href="{{ url_for('home', lang=current_lang) }}">
         <span class="fw-bold">{{ t('site.nav_brand_model_expert') }}</span>
         <small class="d-block text-muted">{{ t('site.nav_subtitle') }}</small>
       </a>
-      <div class="navbar-actions d-flex align-items-center justify-content-end flex-wrap gap-2">
-        <a href="{{ url_for('home', lang=current_lang) }}" class="btn btn-sm btn-dark me-3">
-          <i class="bi bi-house-door-fill me-1" aria-hidden="true"></i>{{ t('site.home_button') }}
-        </a>
+      <div class="d-flex gap-2">
         <a href="{{ url_for('set_language_route', lang='fr') }}" class="btn btn-sm {{ 'btn-primary' if current_lang == 'fr' else 'btn-outline-primary' }}">{{ t('lang.fr') }}</a>
         <a href="{{ url_for('set_language_route', lang='en') }}" class="btn btn-sm {{ 'btn-primary' if current_lang == 'en' else 'btn-outline-primary' }}">{{ t('lang.en') }}</a>
       </div>
@@ -45,9 +40,7 @@
     </div>   
     <div class="row g-3 mb-4">
       <div class="col-12">
-        <form method="POST" action="{{ url_for('findnode_expert', lang=current_lang) }}" autocomplete="off"
-              data-search-progress data-search-job-url="{{ url_for('create_search_job') }}">
-          <input type="hidden" name="search_mode" value="expert">
+        <form method="POST" action="{{ url_for('findnode_expert', lang=current_lang) }}" autocomplete="off">
           <input type="hidden" name="filter" value="{{ search.filter or '' }}">
       
           <div class="row g-3 align-items-end">
@@ -57,7 +50,7 @@
               <div class="position-relative">
                 <input type="text" name="name" id="search-input" class="form-control"
                           placeholder="{{ t('expert.placeholder') }}"
-                          value="{{ search.name or '' }}" required autocomplete="off" />
+                          value="{{ request.form.name or '' }}" required autocomplete="off" />
                 <ul id="suggestions-list" class="list-group position-absolute w-100" style="display: none; z-index: 1000;"></ul>
               </div>
             </div>
@@ -86,15 +79,13 @@
               <label class="form-label fw-bold">{{ t('search.label_depth') }}</label>
               <div class="d-flex align-items-center gap-3">
                 <div class="form-check form-switch">
-                  <input class="form-check-input" type="checkbox" id="depth-unlimited" name="depth_unlimited"
-                         {% if search.unlimited %}checked{% endif %}>
+                  <input class="form-check-input" type="checkbox" id="depth-unlimited" name="depth_unlimited" checked>
                   <label class="form-check-label" for="depth-unlimited">{{ t('search.depth_unlimited') }}</label>
                 </div>
                 <div class="input-group input-group-sm">
                   <span class="input-group-text">{{ t('search.depth_limited') }}</span>
                   <input class="form-control" type="number" name="depth" id="depth"
-                          value="{{ search.depth or 3 }}" min="1" max="5"
-                          {% if search.unlimited %}disabled{% endif %}>
+                          value="{{ request.form.depth }}" min="1" max="5" disabled>
                 </div>
               </div>
             </div>
@@ -107,21 +98,6 @@
             </div>
           </div>
         </form>
-        <div class="search-progress alert alert-info mt-3 d-none" role="status" aria-live="polite">
-          <div class="d-flex align-items-start gap-3">
-            <div class="spinner-border text-primary flex-shrink-0" aria-hidden="true"></div>
-            <div class="flex-grow-1">
-              <strong class="search-progress-title"></strong>
-              <div class="search-progress-stage mt-1 fw-semibold"></div>
-              <div class="search-progress-status small mt-1"></div>
-              <div class="progress mt-2" style="height: 0.5rem;">
-                <div class="search-progress-bar progress-bar progress-bar-striped progress-bar-animated"
-                     role="progressbar" aria-valuemin="0" aria-valuemax="100" style="width: 0%;"></div>
-              </div>
-              <small class="search-progress-note text-muted d-block mt-2"></small>
-            </div>
-          </div>
-        </div>
       </div>
     </div>
                 
@@ -269,12 +245,11 @@
   <script src="https://cdnjs.cloudflare.com/ajax/libs/sigma.js/2.4.0/sigma.min.js"></script>
   <script src="https://unpkg.com/graphology@0.25.1/dist/graphology.umd.min.js"></script>
   <script src="https://cdn.jsdelivr.net/npm/graphology-library/dist/graphology-library.min.js"></script>
+  <script src="{{ url_for('static', filename='js/utils.js') }}"></script>
   <script>
     window.__I18N_DATA = {{ js_i18n_data | tojson }};
     window.__I18N_LANG = "{{ current_lang }}";
   </script>
-  <script src="{{ url_for('static', filename='js/utils.js') }}"></script>
-  <script src="{{ url_for('static', filename='js/search_progress.js') }}"></script>
   <script src="{{ url_for('static', filename='js/script_expert.js') }}"></script>
   <script>
     document.addEventListener('DOMContentLoaded', function () {

application_neo4j/templates/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>{{ t('site.title_home') }}</title>
     <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet">
 
 <style>/* Style simple pour la page d'accueil */
  body {
@@ -116,30 +116,11 @@
       background: #3498db;
       color: #fff;
     }
-
-    @media (max-width: 575.98px) {
-      .lang-switch {
-        position: static;
-        justify-content: flex-end;
-        padding: 12px 15px 0;
-      }
-
-      .welcome-container {
-        padding-top: 24px;
-      }
-
-      .content-card {
-        padding: 22px;
-        text-align: left;
-      }
-    }
     
     </style>
     </head>
 
 <body>
-    <div id="legacy-browser-warning" class="legacy-browser-warning" role="alert" hidden>{{ t('site.legacy_browser_warning') }}</div>
-    <script src="{{ url_for('static', filename='js/browser_compatibility.js') }}"></script>
     <!-- Language selector -->
     <div class="lang-switch">
       <a href="{{ url_for('set_language_route', lang='fr') }}" class="{{ 'active' if current_lang == 'fr' else '' }}">{{ t('lang.fr') }}</a>
@@ -148,7 +129,7 @@
 
     <div class="welcome-container">
       <h1>{{ t('home.welcome_title') }}</h1>
-      <a href="{{ url_for('static', filename='notice/notice_en.pdf' if current_lang == 'en' else 'notice/notice.pdf') }}" class="btn-modern" target="_blank">{{ t('home.more_info') }}</a>
+      <a href="{{ url_for('static', filename='notice/notice.pdf') }}" class="btn-modern" target="_blank">{{ t('home.more_info') }}</a>
     </div>
     <div class="container content-section">
       <div class="row g-4">

application_neo4j/templates/infos.html

@@ -1,43 +1,18 @@
 <!DOCTYPE html>
-<html lang="{{ current_lang }}">
+<html lang="fr">
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{{ t('home.more_info') }}</title>
+    <title>Plus d'informations</title>
     <style>
         body, html { margin: 0; padding: 0; height: 100%; overflow: hidden; }
-        body { display: flex; flex-direction: column; font-family: sans-serif; }
-        .legacy-browser-warning { display: none; padding: 0.75rem 1rem; color: #664d03; background: #fff3cd; border-bottom: 1px solid #ffecb5; font-weight: 600; text-align: center; }
-        .toolbar {
-            display: flex;
-            align-items: center;
-            padding: 0.75rem 1rem;
-            background: #f8f9fa;
-            border-bottom: 1px solid #dee2e6;
-        }
-        .home-button {
-            color: #fff;
-            background: #212529;
-            border: 1px solid #212529;
-            border-radius: 0.25rem;
-            padding: 0.375rem 0.75rem;
-            text-decoration: none;
-            font-weight: 600;
-        }
-        .home-button:hover { color: #fff; background: #424649; }
-        .pdf-container { width: 100%; height: calc(100% - 52px); flex: 1; min-height: 0; }
-        .pdf-container iframe { display: block; border: none; width: 100%; height: 100%; }
+        .pdf-container { width: 100%; height: 100%; }
+        .pdf-container iframe { border: none; width: 100%; height: 100%; }
     </style>
 </head>
 <body>
-    <div id="legacy-browser-warning" class="legacy-browser-warning" role="alert" hidden>{{ t('site.legacy_browser_warning') }}</div>
-    <script src="{{ url_for('static', filename='js/browser_compatibility.js') }}"></script>
-    <nav class="toolbar" aria-label="{{ t('site.home_button') }}">
-        <a class="home-button" href="{{ url_for('home', lang=current_lang) }}">⌂ {{ t('site.home_button') }}</a>
-    </nav>
     <div class="pdf-container">
         <!-- Cette balise iframe va afficher votre PDF -->
         <iframe src="{{ url_for('static', filename='pdf/plus_infos_interface.pdf') }}"></iframe>
     </div>
 </body>
-</html>
+</html>

application_neo4j/templates/search.html

@@ -33,18 +33,13 @@
 </head>
 
 <body class="d-flex flex-column min-vh-100">
-    <div id="legacy-browser-warning" class="legacy-browser-warning" role="alert" hidden>{{ t('site.legacy_browser_warning') }}</div>
-    <script src="{{ url_for('static', filename='js/browser_compatibility.js') }}"></script>
     <header class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
     <div class="container">
       <a class="navbar-brand" href="{{ url_for('home', lang=current_lang) }}">
         <span class="fw-bold">{{ t('site.nav_brand') }}</span>
         <small class="d-block text-muted">{{ t('site.nav_subtitle_full') }}</small>
       </a>
-      <div class="navbar-actions d-flex align-items-center justify-content-end flex-wrap gap-2">
-        <a href="{{ url_for('home', lang=current_lang) }}" class="btn btn-sm btn-dark me-3">
-          <i class="bi bi-house-door-fill me-1" aria-hidden="true"></i>{{ t('site.home_button') }}
-        </a>
+      <div class="d-flex gap-2">
         <a href="{{ url_for('set_language_route', lang='fr') }}" class="btn btn-sm {{ 'btn-primary' if current_lang == 'fr' else 'btn-outline-primary' }}">{{ t('lang.fr') }}</a>
         <a href="{{ url_for('set_language_route', lang='en') }}" class="btn btn-sm {{ 'btn-primary' if current_lang == 'en' else 'btn-outline-primary' }}">{{ t('lang.en') }}</a>
       </div>
@@ -62,9 +57,7 @@
     
     <div class="row g-3 mb-4">
       <div class="col-12">
-        <form method="POST" action="{{ url_for('findnode', lang=current_lang) }}" autocomplete="off"
-              data-search-progress data-search-job-url="{{ url_for('create_search_job') }}">
-          <input type="hidden" name="search_mode" value="standard">
+        <form method="POST" action="{{ url_for('findnode', lang=current_lang) }}" autocomplete="off">
           <input type="hidden" name="filter" value="{{ search.filter or '' }}">
     
           <div class="row g-3 align-items-end">
@@ -74,7 +67,7 @@
               <div class="position-relative">
                 <input type="text" name="name" id="search-input" class="form-control"
                        placeholder="{{ t('search.placeholder_model') }}"
-                       value="{{ search.name or '' }}" required autocomplete="off" />
+                       value="{{ request.form.name or '' }}" required autocomplete="off" />
                 <ul id="suggestions-list" class="list-group position-absolute w-100" style="display: none; z-index: 1000;"></ul>
               </div>
             </div>
@@ -101,15 +94,13 @@
               <label class="form-label fw-bold">{{ t('search.label_depth') }}</label>
               <div class="d-flex align-items-center gap-3">
                 <div class="form-check form-switch">
-                  <input class="form-check-input" type="checkbox" id="depth-unlimited" name="depth_unlimited"
-                         {% if search.unlimited %}checked{% endif %}>
+                  <input class="form-check-input" type="checkbox" id="depth-unlimited" name="depth_unlimited" checked>
                   <label class="form-check-label" for="depth-unlimited">{{ t('search.depth_unlimited') }}</label>
                 </div>
                 <div class="input-group input-group-sm">
                   <span class="input-group-text">{{ t('search.depth_limited') }}</span>
                   <input class="form-control" type="number" name="depth" id="depth"
-                         value="{{ search.depth or 3 }}" min="1" max="5"
-                         {% if search.unlimited %}disabled{% endif %}>
+                         value="{{ request.form.depth }}" min="1" max="5" disabled>
                 </div>
               </div>
             </div>
@@ -124,21 +115,6 @@
             </div>
           </div>
         </form>
-        <div class="search-progress alert alert-info mt-3 d-none" role="status" aria-live="polite">
-          <div class="d-flex align-items-start gap-3">
-            <div class="spinner-border text-primary flex-shrink-0" aria-hidden="true"></div>
-            <div class="flex-grow-1">
-              <strong class="search-progress-title"></strong>
-              <div class="search-progress-stage mt-1 fw-semibold"></div>
-              <div class="search-progress-status small mt-1"></div>
-              <div class="progress mt-2" style="height: 0.5rem;">
-                <div class="search-progress-bar progress-bar progress-bar-striped progress-bar-animated"
-                     role="progressbar" aria-valuemin="0" aria-valuemax="100" style="width: 0%;"></div>
-              </div>
-              <small class="search-progress-note text-muted d-block mt-2"></small>
-            </div>
-          </div>
-        </div>
       </div>
     </div>
     
@@ -179,8 +155,8 @@
                                       <span class="badge {{ badge.class }} on-top" 
                                             data-bs-toggle="tooltip" 
                                             data-bs-placement="top" 
-                                            title="{{ t(badge.title_key) }}">
-                                          {{ t(badge.text_key) }}
+                                            title="{{ badge.title }}">
+                                          {{ badge.text }}
                                       </span>
                                   {% endfor %}
                                     </div>
@@ -305,8 +281,8 @@
                           <span class="badge {{ badge.class }} on-top" 
                                 data-bs-toggle="tooltip" 
                                 data-bs-placement="top" 
-                                title="{{ t(badge.title_key) }}">
-                              {{ t(badge.text_key) }}
+                                title="{{ badge.title }}">
+                              {{ badge.text }}
                           </span>
                       {% endfor %}
                         </div>
@@ -453,12 +429,11 @@
   <script src="https://cdnjs.cloudflare.com/ajax/libs/sigma.js/2.4.0/sigma.min.js"></script>
   <script src="https://unpkg.com/graphology@0.25.1/dist/graphology.umd.min.js"></script>
   <script src="https://cdn.jsdelivr.net/npm/graphology-library/dist/graphology-library.min.js"></script>
+  <script src="{{ url_for('static', filename='js/utils.js') }}"></script>
   <script>
     window.__I18N_DATA = {{ js_i18n_data | tojson }};
     window.__I18N_LANG = "{{ current_lang }}";
   </script>
-  <script src="{{ url_for('static', filename='js/utils.js') }}"></script>
-  <script src="{{ url_for('static', filename='js/search_progress.js') }}"></script>
   <script src="{{ url_for('static', filename='js/script.js') }}"></script>
   <script>
     document.addEventListener('DOMContentLoaded', function () {

application_neo4j/templates/search_dataset.html

@@ -33,18 +33,13 @@
 </head>
 
 <body class="d-flex flex-column min-vh-100">
-    <div id="legacy-browser-warning" class="legacy-browser-warning" role="alert" hidden>{{ t('site.legacy_browser_warning') }}</div>
-    <script src="{{ url_for('static', filename='js/browser_compatibility.js') }}"></script>
     <header class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
     <div class="container">
       <a class="navbar-brand" href="{{ url_for('home', lang=current_lang) }}">
         <span class="fw-bold">{{ t('site.nav_brand') }}</span>
         <small class="d-block text-muted">{{ t('site.nav_subtitle') }}</small>
       </a>
-      <div class="navbar-actions d-flex align-items-center justify-content-end flex-wrap gap-2">
-        <a href="{{ url_for('home', lang=current_lang) }}" class="btn btn-sm btn-dark me-3">
-          <i class="bi bi-house-door-fill me-1" aria-hidden="true"></i>{{ t('site.home_button') }}
-        </a>
+      <div class="d-flex gap-2">
         <a href="{{ url_for('set_language_route', lang='fr') }}" class="btn btn-sm {{ 'btn-primary' if current_lang == 'fr' else 'btn-outline-primary' }}">{{ t('lang.fr') }}</a>
         <a href="{{ url_for('set_language_route', lang='en') }}" class="btn btn-sm {{ 'btn-primary' if current_lang == 'en' else 'btn-outline-primary' }}">{{ t('lang.en') }}</a>
       </div>
@@ -62,9 +57,7 @@
     
     <div class="row g-3 mb-4">
       <div class="col-12">
-        <form method="POST" action="{{ url_for('findnode', lang=current_lang) }}" autocomplete="off"
-              data-search-progress data-search-job-url="{{ url_for('create_search_job') }}">
-          <input type="hidden" name="search_mode" value="standard">
+        <form method="POST" action="{{ url_for('findnode', lang=current_lang) }}" autocomplete="off">
           <input type="hidden" name="filter" value="{{ search.filter or '' }}">
     
           <div class="row g-3 align-items-end">
@@ -74,7 +67,7 @@
               <div class="position-relative">
                 <input type="text" name="name" id="search-input" class="form-control"
                        placeholder="{{ t('search.placeholder_dataset') }}"
-                       value="{{ search.name or '' }}" required autocomplete="off" />
+                       value="{{ request.form.name or '' }}" required autocomplete="off" />
                 <ul id="suggestions-list" class="list-group position-absolute w-100" style="display: none; z-index: 1000;"></ul>
               </div>
             </div>
@@ -101,15 +94,13 @@
               <label class="form-label fw-bold">{{ t('search.label_depth') }}</label>
               <div class="d-flex align-items-center gap-3">
                 <div class="form-check form-switch">
-                  <input class="form-check-input" type="checkbox" id="depth-unlimited" name="depth_unlimited"
-                         {% if search.unlimited %}checked{% endif %}>
+                  <input class="form-check-input" type="checkbox" id="depth-unlimited" name="depth_unlimited" checked>
                   <label class="form-check-label" for="depth-unlimited">{{ t('search.depth_unlimited') }}</label>
                 </div>
                 <div class="input-group input-group-sm">
                   <span class="input-group-text">{{ t('search.depth_limited') }}</span>
                   <input class="form-control" type="number" name="depth" id="depth"
-                         value="{{ search.depth or 3 }}" min="1" max="5"
-                         {% if search.unlimited %}disabled{% endif %}>
+                         value="{{ request.form.depth }}" min="1" max="5" disabled>
                 </div>
               </div>
             </div>
@@ -124,21 +115,6 @@
             </div>
           </div>
         </form>
-        <div class="search-progress alert alert-info mt-3 d-none" role="status" aria-live="polite">
-          <div class="d-flex align-items-start gap-3">
-            <div class="spinner-border text-primary flex-shrink-0" aria-hidden="true"></div>
-            <div class="flex-grow-1">
-              <strong class="search-progress-title"></strong>
-              <div class="search-progress-stage mt-1 fw-semibold"></div>
-              <div class="search-progress-status small mt-1"></div>
-              <div class="progress mt-2" style="height: 0.5rem;">
-                <div class="search-progress-bar progress-bar progress-bar-striped progress-bar-animated"
-                     role="progressbar" aria-valuemin="0" aria-valuemax="100" style="width: 0%;"></div>
-              </div>
-              <small class="search-progress-note text-muted d-block mt-2"></small>
-            </div>
-          </div>
-        </div>
       </div>
     </div>
 
@@ -263,12 +239,11 @@
   <script src="https://cdnjs.cloudflare.com/ajax/libs/sigma.js/2.4.0/sigma.min.js"></script>
   <script src="https://unpkg.com/graphology@0.25.1/dist/graphology.umd.min.js"></script>
   <script src="https://cdn.jsdelivr.net/npm/graphology-library/dist/graphology-library.min.js"></script>
+  <script src="{{ url_for('static', filename='js/utils.js') }}"></script>
   <script>
     window.__I18N_DATA = {{ js_i18n_data | tojson }};
     window.__I18N_LANG = "{{ current_lang }}";
   </script>
-  <script src="{{ url_for('static', filename='js/utils.js') }}"></script>
-  <script src="{{ url_for('static', filename='js/search_progress.js') }}"></script>
   <script src="{{ url_for('static', filename='js/script_dataset.js') }}"></script>
   <script>
     document.addEventListener('DOMContentLoaded', function () {

application_neo4j/translations.py

@@ -44,9 +44,7 @@ TRANSLATIONS = {
         "site.nav_brand": "Généalogie des Modèles",
         "site.nav_brand_model_expert": "Généalogie des Modèles",
         "site.nav_subtitle": "Exploration des relations entre modèles et datasets",
-        "site.nav_subtitle_full": "Exploration des relations entre modèles et datasets (base de données actualisée le {date})",
-        "site.home_button": "Accueil",
-        "site.legacy_browser_warning": "Ce navigateur n’est plus pris en charge. Pour un affichage stable, utilisez une version récente de Firefox, Chrome, Edge ou Safari.",
+        "site.nav_subtitle_full": "Exploration des relations entre modèles et datasets (base de données actualisée le 01/09/2025)",
         "site.footer": "Application de recherche et visualisation des relations entre modèles et jeux de données publiés sur la plateforme HuggingFace. © 2025",
         "site.footer_expert": "Application de recherche et visualisation... © 2025",
 
@@ -83,7 +81,7 @@ TRANSLATIONS = {
         "home.btn_unsure": "Je ne sais pas",
         "home.expert_label": "Vous êtes un chercheur",
         "home.btn_expert": "Mode expert",
-        "home.download_date": "Date de téléchargement de la base de données : {date}",
+        "home.download_date": "Date de téléchargement de la base de donnée : 01/09/2025",
         "home.notice_title": "Mentions d'information sur les traitements de données à caractère personnel",
         "home.notice_p1": "Afin d'étudier le développement de la communauté de l'IA open source, et de préparer la possibilité d'exercices de droits des citoyens, le projet vise à étudier la base de données des jeux de données et modèles présents sur la plateforme HuggingFace. Cette base de données permet d'établir un arbre généalogique des modèles.",
         "home.notice_p2": "Les données traitées sont le pseudonyme de l'auteur (quand il apparaît dans les métadonnées), le nom du modèle/jeu de données et plusieurs informations inhérentes à ce modèle/jeu de données telles que la date de publication, la licence utilisée ou encore le nombre de téléchargements.",
@@ -100,42 +98,15 @@ TRANSLATIONS = {
         "search.page_lead_dataset": "Explorez la généalogie des modèles et datasets",
         "search.label_name": "Nom à rechercher",
         "search.placeholder_model": "Taper le nom du modèle ou l'id de son repo Hugging Face.",
-        "search.placeholder_dataset": "Taper le nom du dataset à investiguer.",
+        "search.placeholder_dataset": "Taper le nom du dataset suspecté.",
         "search.label_filters": "Filtres",
         "search.filter_model": "Modèle",
         "search.filter_dataset": "Dataset",
         "search.label_depth": "Profondeur de recherche",
         "search.depth_unlimited": "Illimitée",
         "search.depth_limited": "Limité à:",
-        "search.btn_search": "Rechercher",
+        "search.btn_search": "Rechercher (le chargement peut prendre jusqu'à une minute pour les grandes généalogies)",
         "search.btn_search_simple": "Rechercher",
-        "search.progress_title": "Recherche en cours…",
-        "search.progress_stage_queued": "En attente d’une capacité de recherche…",
-        "search.progress_stage_preparing": "Préparation du graphe…",
-        "search.progress_stage_descendants": "Recherche des descendants…",
-        "search.progress_stage_ancestors": "Recherche des ascendants…",
-        "search.progress_stage_result": "Construction du résultat…",
-        "search.progress_stage_nodes": "Analyse des nœuds du résultat…",
-        "search.progress_stage_relationships": "Chargement des relations…",
-        "search.progress_stage_formatting": "Mise en forme du résultat…",
-        "search.progress_stage_highlights": "Calcul des modèles importants…",
-        "search.progress_stage_completed": "Recherche terminée.",
-        "search.progress_stage_failed": "La recherche a échoué.",
-        "search.progress_stage_cancelled": "Recherche annulée.",
-        "search.progress_elapsed": "Temps écoulé : {seconds} s",
-        "search.progress_items": "Éléments traités par le serveur : {completed}/{total}",
-        "search.progress_queue_title": "Recherche en file d’attente",
-        "search.progress_queue_position": "Position dans la file : {position}/{total}",
-        "search.progress_queue_ahead_one": "1 recherche devant la vôtre",
-        "search.progress_queue_ahead_many": "{count} recherches devant la vôtre",
-        "search.progress_queue_next": "Votre recherche est la prochaine.",
-        "search.progress_queue_running_one": "1 recherche en cours",
-        "search.progress_queue_running_many": "{count} recherches en cours",
-        "search.progress_queue_note": "La recherche démarrera automatiquement dès qu’une capacité sera disponible.",
-        "search.progress_server_percent": "Progression indiquée par le serveur : {percent} %",
-        "search.progress_remaining_step": "Temps restant estimé pour cette étape : {seconds} s",
-        "search.progress_server_note": "La progression repose sur les opérations réellement terminées par le serveur.",
-        "search.progress_connection_error": "Impossible d’obtenir la progression depuis le serveur.",
 
         # ── search.html — vue highlights ──
         "search.asc_section": "Modèles importants de l'ascendance",
@@ -197,7 +168,7 @@ TRANSLATIONS = {
         # ── expert.html ──
         "expert.page_title": "Recherche Experte",
         "expert.page_lead": "Explorez et filtrez la généalogie des modèles",
-        "expert.placeholder": "Taper le nom du modèle à investiguer.",
+        "expert.placeholder": "Taper le nom du modèle suspecté.",
         "expert.filter_author": "Auteur",
         "expert.connected_component": "Composante connexe du noeud recherché",
         "expert.legend_title": "Légendes",
@@ -283,9 +254,7 @@ TRANSLATIONS = {
         "site.nav_brand": "Model Genealogy",
         "site.nav_brand_model_expert": "Model Genealogy",
         "site.nav_subtitle": "Exploration of relations between models and datasets",
-        "site.nav_subtitle_full": "Exploration of relations between models and datasets (database updated on {date})",
-        "site.home_button": "Home",
-        "site.legacy_browser_warning": "This browser is no longer supported. For a stable display, use a recent version of Firefox, Chrome, Edge or Safari.",
+        "site.nav_subtitle_full": "Exploration of relations between models and datasets (database updated on 01/09/2025)",
         "site.footer": "Application for searching and visualizing relations between models and datasets published on the HuggingFace platform. © 2025",
         "site.footer_expert": "Application for searching and visualizing... © 2025",
 
@@ -322,7 +291,7 @@ TRANSLATIONS = {
         "home.btn_unsure": "I don't know",
         "home.expert_label": "You are a researcher",
         "home.btn_expert": "Expert mode",
-        "home.download_date": "Database download date: {date}",
+        "home.download_date": "Database download date: 01/09/2025",
         "home.notice_title": "Information on the processing of personal data",
         "home.notice_p1": "In order to study the development of the open-source AI community and to prepare for the possibility of citizens exercising their rights, the project aims to study the database of datasets and models present on the HuggingFace platform. This database makes it possible to establish a genealogy tree of the models.",
         "home.notice_p2": "The data processed includes the author's pseudonym (when it appears in the metadata), the name of the model/dataset and several pieces of information inherent to this model/dataset such as the publication date, the license used or the number of downloads.",
@@ -346,35 +315,8 @@ TRANSLATIONS = {
         "search.label_depth": "Search depth",
         "search.depth_unlimited": "Unlimited",
         "search.depth_limited": "Limited to:",
-        "search.btn_search": "Search",
+        "search.btn_search": "Search (loading may take up to a minute for large genealogies)",
         "search.btn_search_simple": "Search",
-        "search.progress_title": "Search in progress…",
-        "search.progress_stage_queued": "Waiting for search capacity…",
-        "search.progress_stage_preparing": "Preparing the graph…",
-        "search.progress_stage_descendants": "Searching descendants…",
-        "search.progress_stage_ancestors": "Searching ancestors…",
-        "search.progress_stage_result": "Building the result…",
-        "search.progress_stage_nodes": "Analyzing result nodes…",
-        "search.progress_stage_relationships": "Loading relationships…",
-        "search.progress_stage_formatting": "Formatting the result…",
-        "search.progress_stage_highlights": "Computing important models…",
-        "search.progress_stage_completed": "Search completed.",
-        "search.progress_stage_failed": "The search failed.",
-        "search.progress_stage_cancelled": "Search cancelled.",
-        "search.progress_elapsed": "Elapsed time: {seconds} s",
-        "search.progress_items": "Items processed by the server: {completed}/{total}",
-        "search.progress_queue_title": "Search queued",
-        "search.progress_queue_position": "Queue position: {position}/{total}",
-        "search.progress_queue_ahead_one": "1 search ahead of yours",
-        "search.progress_queue_ahead_many": "{count} searches ahead of yours",
-        "search.progress_queue_next": "Your search is next.",
-        "search.progress_queue_running_one": "1 search currently running",
-        "search.progress_queue_running_many": "{count} searches currently running",
-        "search.progress_queue_note": "Your search will start automatically as soon as capacity becomes available.",
-        "search.progress_server_percent": "Progress reported by the server: {percent}%",
-        "search.progress_remaining_step": "Estimated time remaining for this step: {seconds} s",
-        "search.progress_server_note": "Progress is based on operations actually completed by the server.",
-        "search.progress_connection_error": "Unable to retrieve progress from the server.",
 
         # ── search.html — highlights view ──
         "search.asc_section": "Important ancestor models",

database_refresh/README.md

@@ -1,70 +0,0 @@
-# Actualisation hebdomadaire de la base
-
-La source est le dataset public
-[`cfahlgren1/hub-stats`](https://huggingface.co/datasets/cfahlgren1/hub-stats).
-Le pipeline télécharge ses configurations `models` et `datasets`, reconstruit
-hors ligne une base Neo4j, crée `neo4j.dump`, puis publie ce dump et son fichier
-`database_metadata.json` dans le dataset privé configuré.
-
-Le Space continue à utiliser le dump précédent pendant toute la reconstruction.
-Il ne voit la nouvelle base qu'après un redémarrage. La date affichée dans
-l'interface vient de `database_metadata.json`; elle n'est donc mise à jour que
-si la reconstruction et la publication ont réussi.
-
-## Test sans modifier la production
-
-Le dépôt de dumps accepte une branche de test :
-
-```bash
-export HF_TOKEN=hf_...
-bash database_refresh/run_weekly_refresh.sh \
-  --dump-revision weekly-refresh
-```
-
-Pour un test rapide du prétraitement :
-
-```bash
-bash database_refresh/run_weekly_refresh.sh \
-  --max-models 10000 \
-  --max-datasets 10000 \
-  --prepare-only
-```
-
-## Job Hugging Face hebdomadaire
-
-Le Job peut monter en lecture la branche du Space qui contient ce script et
-utiliser l'image Neo4j correspondant exactement à celle de l'application :
-
-Le compte qui crée le Job doit avoir au minimum le rôle `write` dans
-l'organisation CNIL. Le token utilisé par la CLI doit explicitement autoriser
-`Start and manage Jobs`. Puisque le même token est transmis au Job avec
-`--secrets HF_TOKEN`, il doit également pouvoir écrire dans
-`cnil/genmod-dump-neo4j` et redémarrer le Space ciblé. L'option
-`--namespace cnil` est indispensable pour créer et facturer le Job sous
-l'organisation plutôt que sous le compte personnel.
-
-```bash
-hf jobs scheduled run "@weekly" \
-  --namespace cnil \
-  --name genmod-weekly-database-refresh \
-  --flavor cpu-basic \
-  --timeout 12h \
-  --no-concurrency \
-  --secrets HF_TOKEN \
-  --env NEO4J_DUMP_REPO=cnil/genmod-dump-neo4j \
-  --env NEO4J_DUMP_REVISION=weekly-refresh \
-  --env SPACES_TO_RESTART=cnil/genmod-faster \
-  --volume hf://spaces/cnil/genmod@refresh-hub-database:/workspace:ro \
-  neo4j:2025.09.0-community \
-  bash /workspace/database_refresh/run_weekly_refresh.sh
-```
-
-La révision `weekly-refresh` permet de valider le nouveau dump avec
-`genmod-faster` sans remplacer le dump de production. Après validation, il
-suffit de programmer le même Job avec `NEO4J_DUMP_REVISION=main`.
-Pour la production, `SPACES_TO_RESTART` doit alors être remplacé par
-`cnil/genmod`.
-
-Les Hugging Face Jobs nécessitent un solde positif et sont facturés uniquement
-pendant leur exécution. Un Space CPU Basic ne constitue pas à lui seul un cron
-fiable : il peut être mis en veille et son disque est éphémère.

database_refresh/refresh_database.py

@@ -1,484 +0,0 @@
-#!/usr/bin/env python3
-"""Build and publish a Neo4j dump from the public cfahlgren1/hub-stats dataset."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import shutil
-import subprocess
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-import duckdb
-from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download
-
-
-SOURCE_REPO = "cfahlgren1/hub-stats"
-DEFAULT_DUMP_REPO = "cnil/genmod-dump-neo4j"
-PARQUET_REVISION = "refs/convert/parquet"
-
-
-def log(message: str) -> None:
-    print(f"[genmod-refresh] {message}", flush=True)
-
-
-def download_sources(work_dir: Path) -> tuple[Path, Path]:
-    cache_dir = work_dir / "hf-cache"
-    log(f"Downloading the model snapshot from {SOURCE_REPO}")
-    models = Path(
-        hf_hub_download(
-            repo_id=SOURCE_REPO,
-            repo_type="dataset",
-            revision=PARQUET_REVISION,
-            filename="models/train/0000.parquet",
-            cache_dir=cache_dir,
-        )
-    )
-    log(f"Downloading the dataset snapshot from {SOURCE_REPO}")
-    datasets = Path(
-        hf_hub_download(
-            repo_id=SOURCE_REPO,
-            repo_type="dataset",
-            revision=PARQUET_REVISION,
-            filename="datasets/train/0000.parquet",
-            cache_dir=cache_dir,
-        )
-    )
-    return models, datasets
-
-
-def sql_path(path: Path) -> str:
-    return str(path).replace("'", "''")
-
-
-def create_views(
-    connection: duckdb.DuckDBPyConnection,
-    models_path: Path,
-    datasets_path: Path,
-    max_models: int | None,
-    max_datasets: int | None,
-) -> None:
-    model_limit = f" LIMIT {max_models}" if max_models else ""
-    dataset_limit = f" LIMIT {max_datasets}" if max_datasets else ""
-    connection.execute(
-        f"""
-        CREATE VIEW source_models AS
-        SELECT * EXCLUDE (_dedupe_rank)
-        FROM (
-            SELECT
-                *,
-                row_number() OVER (
-                    PARTITION BY id
-                    ORDER BY lastModified DESC NULLS LAST, _id DESC NULLS LAST
-                ) AS _dedupe_rank
-            FROM read_parquet('{sql_path(models_path)}')
-            WHERE id IS NOT NULL AND trim(id) <> ''
-        )
-        WHERE _dedupe_rank = 1
-        {model_limit}
-        """
-    )
-    connection.execute(
-        f"""
-        CREATE VIEW source_datasets AS
-        SELECT * EXCLUDE (_dedupe_rank)
-        FROM (
-            SELECT
-                *,
-                row_number() OVER (
-                    PARTITION BY id
-                    ORDER BY lastModified DESC NULLS LAST, _id DESC NULLS LAST
-                ) AS _dedupe_rank
-            FROM read_parquet('{sql_path(datasets_path)}')
-            WHERE id IS NOT NULL AND trim(id) <> ''
-        )
-        WHERE _dedupe_rank = 1
-        {dataset_limit}
-        """
-    )
-    connection.execute(
-        """
-        CREATE VIEW base_model_edges AS
-        SELECT DISTINCT
-            base.id AS parent_id,
-            child.id AS child_id,
-            COALESCE(child.baseModels.relation, 'derived') AS relation_name
-        FROM source_models AS child,
-             UNNEST(child.baseModels.models) AS nested(base)
-        WHERE child.baseModels IS NOT NULL
-          AND base.id IS NOT NULL
-          AND trim(base.id) <> ''
-          AND child.id IS NOT NULL
-        """
-    )
-    connection.execute(
-        """
-        CREATE VIEW model_dataset_edges AS
-        SELECT DISTINCT
-            substr(tag, 9) AS dataset_id,
-            model.id AS model_id
-        FROM source_models AS model,
-             UNNEST(model.tags) AS nested(tag)
-        WHERE starts_with(tag, 'dataset:')
-          AND length(trim(substr(tag, 9))) > 0
-          AND model.id IS NOT NULL
-        """
-    )
-
-
-def export_csv(
-    connection: duckdb.DuckDBPyConnection,
-    output_dir: Path,
-    filename: str,
-    header: str,
-    query: str,
-) -> Path:
-    path = output_dir / filename
-    header_path = output_dir / filename.replace(".csv", "-header.csv")
-    header_path.write_text(header + "\n", encoding="utf-8")
-    connection.execute(
-        f"""
-        COPY ({query})
-        TO '{sql_path(path)}'
-        (FORMAT CSV, HEADER false, DELIMITER ',', QUOTE '"', ESCAPE '"')
-        """
-    )
-    log(f"Created {filename}")
-    return path
-
-
-def prepare_csv_files(
-    models_path: Path,
-    datasets_path: Path,
-    output_dir: Path,
-    max_models: int | None = None,
-    max_datasets: int | None = None,
-) -> dict[str, Path]:
-    output_dir.mkdir(parents=True, exist_ok=True)
-    database_path = output_dir / "refresh.duckdb"
-    connection = duckdb.connect(str(database_path))
-    connection.execute("SET preserve_insertion_order = false")
-    connection.execute("SET threads = 2")
-    create_views(connection, models_path, datasets_path, max_models, max_datasets)
-
-    files: dict[str, Path] = {}
-    files["models"] = export_csv(
-        connection,
-        output_dir,
-        "models.csv",
-        "modelId:ID(Model),name,downloads:long,task,createdAt,parameters,likes:long,license",
-        """
-        WITH actual_models AS (
-            SELECT
-                id,
-                id AS name,
-                downloadsAllTime AS downloads,
-                pipeline_tag AS task,
-                CAST(createdAt AS VARCHAR) AS created_at,
-                CASE
-                    WHEN safetensors.total >= 1000000000
-                        THEN printf('%.1fB', safetensors.total / 1000000000.0)
-                    WHEN safetensors.total >= 1000000
-                        THEN printf('%.1fM', safetensors.total / 1000000.0)
-                    WHEN safetensors.total >= 1000
-                        THEN printf('%.1fK', safetensors.total / 1000.0)
-                    WHEN safetensors.total IS NOT NULL
-                        THEN CAST(safetensors.total AS VARCHAR)
-                END AS parameters,
-                likes,
-                json_extract_string(cardData, '$.license') AS license
-            FROM source_models
-            WHERE id IS NOT NULL AND trim(id) <> ''
-        ),
-        missing_parents AS (
-            SELECT DISTINCT parent_id AS id
-            FROM base_model_edges
-            WHERE parent_id NOT IN (SELECT id FROM actual_models)
-        )
-        SELECT id, name, downloads, task, created_at, parameters, likes, license
-        FROM actual_models
-        UNION ALL
-        SELECT id, id, NULL, NULL, NULL, NULL, NULL, NULL
-        FROM missing_parents
-        """,
-    )
-    files["datasets"] = export_csv(
-        connection,
-        output_dir,
-        "datasets.csv",
-        "datasetId:ID(Dataset),name,downloads:long,createdAt_dataset",
-        """
-        WITH actual_datasets AS (
-            SELECT
-                id,
-                id AS name,
-                downloadsAllTime AS downloads,
-                CAST(createdAt AS VARCHAR) AS created_at
-            FROM source_datasets
-            WHERE id IS NOT NULL AND trim(id) <> ''
-        ),
-        missing_datasets AS (
-            SELECT DISTINCT dataset_id AS id
-            FROM model_dataset_edges
-            WHERE dataset_id NOT IN (SELECT id FROM actual_datasets)
-        )
-        SELECT id, name, downloads, created_at
-        FROM actual_datasets
-        UNION ALL
-        SELECT id, id, NULL, NULL
-        FROM missing_datasets
-        """,
-    )
-    files["authors"] = export_csv(
-        connection,
-        output_dir,
-        "authors.csv",
-        "authorId:ID(Author),name,type,followers:long",
-        """
-        SELECT author, author, 'unknown', NULL
-        FROM (
-            SELECT author FROM source_models
-            UNION
-            SELECT author FROM source_datasets
-        )
-        WHERE author IS NOT NULL AND trim(author) <> ''
-        """,
-    )
-    files["base_model_edges"] = export_csv(
-        connection,
-        output_dir,
-        "base-model-edges.csv",
-        ":START_ID(Model),:END_ID(Model),name",
-        "SELECT parent_id, child_id, relation_name FROM base_model_edges",
-    )
-    files["model_dataset_edges"] = export_csv(
-        connection,
-        output_dir,
-        "model-dataset-edges.csv",
-        ":START_ID(Dataset),:END_ID(Model),name",
-        """
-        SELECT dataset_id, model_id, 'A été utilisé dans ce modèle'
-        FROM model_dataset_edges
-        """,
-    )
-    files["author_model_edges"] = export_csv(
-        connection,
-        output_dir,
-        "author-model-edges.csv",
-        ":START_ID(Author),:END_ID(Model),name",
-        """
-        SELECT DISTINCT author, id, 'A publié'
-        FROM source_models
-        WHERE author IS NOT NULL AND trim(author) <> '' AND id IS NOT NULL
-        """,
-    )
-    files["author_dataset_edges"] = export_csv(
-        connection,
-        output_dir,
-        "author-dataset-edges.csv",
-        ":START_ID(Author),:END_ID(Dataset),name",
-        """
-        SELECT DISTINCT author, id, 'A publié'
-        FROM source_datasets
-        WHERE author IS NOT NULL AND trim(author) <> '' AND id IS NOT NULL
-        """,
-    )
-    connection.close()
-    database_path.unlink(missing_ok=True)
-    return files
-
-
-def header_for(path: Path) -> Path:
-    return path.with_name(path.name.replace(".csv", "-header.csv"))
-
-
-def build_dump(files: dict[str, Path], output_dir: Path, neo4j_admin: str) -> Path:
-    def group(name: str) -> str:
-        return f"{header_for(files[name])},{files[name]}"
-
-    command = [
-        neo4j_admin,
-        "database",
-        "import",
-        "full",
-        "neo4j",
-        "--overwrite-destination=true",
-        "--id-type=string",
-        "--threads=2",
-        "--verbose",
-        f"--nodes=Model={group('models')}",
-        f"--nodes=Dataset={group('datasets')}",
-        f"--nodes=Author={group('authors')}",
-        f"--relationships=USED_IN={group('base_model_edges')}",
-        f"--relationships=USED_IN={group('model_dataset_edges')}",
-        f"--relationships=POSTED={group('author_model_edges')}",
-        f"--relationships=POSTED={group('author_dataset_edges')}",
-    ]
-    log("Building the offline Neo4j database")
-    subprocess.run(command, check=True)
-
-    dump_dir = output_dir / "dump"
-    dump_dir.mkdir(exist_ok=True)
-    log("Creating neo4j.dump")
-    subprocess.run(
-        [
-            neo4j_admin,
-            "database",
-            "dump",
-            "neo4j",
-            f"--to-path={dump_dir}",
-            "--overwrite-destination=true",
-        ],
-        check=True,
-    )
-    return dump_dir / "neo4j.dump"
-
-
-def write_metadata(
-    output_dir: Path,
-    source_revision: str,
-    model_count: int,
-    dataset_count: int,
-) -> Path:
-    metadata = {
-        "built_at": datetime.now(timezone.utc).isoformat(),
-        "source_repo": SOURCE_REPO,
-        "source_revision": source_revision,
-        "model_count": model_count,
-        "dataset_count": dataset_count,
-    }
-    path = output_dir / "database_metadata.json"
-    path.write_text(json.dumps(metadata, indent=2) + "\n", encoding="utf-8")
-    return path
-
-
-def parquet_unique_id_count(path: Path) -> int:
-    connection = duckdb.connect()
-    count = connection.execute(
-        f"""
-        SELECT count(DISTINCT id)
-        FROM read_parquet('{sql_path(path)}')
-        WHERE id IS NOT NULL AND trim(id) <> ''
-        """
-    ).fetchone()[0]
-    connection.close()
-    return int(count)
-
-
-def publish_dump(
-    api: HfApi,
-    dump_path: Path,
-    metadata_path: Path,
-    repo_id: str,
-    revision: str,
-) -> None:
-    if revision != "main":
-        api.create_branch(
-            repo_id=repo_id,
-            repo_type="dataset",
-            branch=revision,
-            exist_ok=True,
-        )
-    log(f"Publishing the dump to {repo_id}@{revision}")
-    api.create_commit(
-        repo_id=repo_id,
-        repo_type="dataset",
-        revision=revision,
-        operations=[
-            CommitOperationAdd(
-                path_in_repo="neo4j.dump",
-                path_or_fileobj=str(dump_path),
-            ),
-            CommitOperationAdd(
-                path_in_repo="database_metadata.json",
-                path_or_fileobj=str(metadata_path),
-            ),
-        ],
-        commit_message="Refresh Neo4j graph from cfahlgren1/hub-stats",
-    )
-
-
-def restart_spaces(api: HfApi, space_ids: list[str]) -> None:
-    for space_id in space_ids:
-        log(f"Restarting Space {space_id}")
-        api.restart_space(repo_id=space_id)
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--work-dir", type=Path, default=Path("/tmp/genmod-refresh"))
-    parser.add_argument("--dump-repo", default=os.getenv("NEO4J_DUMP_REPO", DEFAULT_DUMP_REPO))
-    parser.add_argument("--dump-revision", default=os.getenv("NEO4J_DUMP_REVISION", "main"))
-    parser.add_argument("--neo4j-admin", default=os.getenv("NEO4J_ADMIN", "neo4j-admin"))
-    parser.add_argument("--models-parquet", type=Path)
-    parser.add_argument("--datasets-parquet", type=Path)
-    parser.add_argument("--max-models", type=int)
-    parser.add_argument("--max-datasets", type=int)
-    parser.add_argument("--prepare-only", action="store_true")
-    parser.add_argument("--no-upload", action="store_true")
-    parser.add_argument("--keep-work-dir", action="store_true")
-    parser.add_argument("--restart-space", action="append", default=[])
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    if args.work_dir.exists() and not args.keep_work_dir:
-        shutil.rmtree(args.work_dir)
-    args.work_dir.mkdir(parents=True, exist_ok=True)
-
-    api = HfApi()
-    source_revision = api.dataset_info(SOURCE_REPO).sha
-    if bool(args.models_parquet) != bool(args.datasets_parquet):
-        raise SystemExit("Provide both --models-parquet and --datasets-parquet.")
-    if args.models_parquet:
-        models_path, datasets_path = args.models_parquet, args.datasets_parquet
-    else:
-        models_path, datasets_path = download_sources(args.work_dir)
-
-    csv_dir = args.work_dir / "csv"
-    files = prepare_csv_files(
-        models_path,
-        datasets_path,
-        csv_dir,
-        max_models=args.max_models,
-        max_datasets=args.max_datasets,
-    )
-    if args.prepare_only:
-        log(f"CSV preparation completed in {csv_dir}")
-        return 0
-
-    dump_path = build_dump(files, args.work_dir, args.neo4j_admin)
-    model_count = args.max_models or parquet_unique_id_count(models_path)
-    dataset_count = args.max_datasets or parquet_unique_id_count(datasets_path)
-    metadata_path = write_metadata(
-        args.work_dir,
-        source_revision,
-        model_count,
-        dataset_count,
-    )
-    if not args.no_upload:
-        if not os.getenv("HF_TOKEN"):
-            raise SystemExit("HF_TOKEN is required to upload the refreshed dump.")
-        publish_dump(
-            api,
-            dump_path,
-            metadata_path,
-            args.dump_repo,
-            args.dump_revision,
-        )
-        configured_spaces = [
-            value.strip()
-            for value in os.getenv("SPACES_TO_RESTART", "").split(",")
-            if value.strip()
-        ]
-        restart_spaces(api, list(dict.fromkeys(configured_spaces + args.restart_space)))
-    log("Refresh completed successfully")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

database_refresh/run_weekly_refresh.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -e
-apt-get update
-apt-get install -y python3-pip wget
-pip3 install duckdb==1.3.2 huggingface-hub==0.31.4
-wget -qO /tmp/r.py https://huggingface.co/spaces/cnil/genmod/resolve/refresh-hub-database/database_refresh/refresh_database.py
-exec python3 /tmp/r.py

opengds/README.md

@@ -1,46 +0,0 @@
-# OpenGDS personnalisé pour GenMod
-
-Cette image utilise un fork minimal d’OpenGDS afin que
-`gds.bfs.stream` renvoie la profondeur minimale de chaque nœud pendant
-le parcours, dans une nouvelle colonne `depths` alignée avec `nodeIds`.
-
-## Source et version
-
-- dépôt amont : https://github.com/neo4j/graph-data-science
-- tag amont : `2.22.0`
-- licence amont : GNU General Public License v3.0
-- patch maintenu ici : `gds-2.22.0-bfs-depth.patch`
-- JAR construit : `open-gds-2.22.0-genmod.jar`
-- SHA-256 :
-  `940c1f0c0cb6a9adbee84c9f15207740262e7c7c83464ad61b31000e4b7caf5e`
-
-Le patch modifie uniquement le mode `stream` du BFS. Les modes `stats` et
-`mutate` conservent leur résultat historique.
-
-Il ajoute aussi une procédure de compatibilité `gds.debug.arrow` indiquant
-qu’Arrow est désactivé. Le client Python GDS appelle cette procédure lors de
-sa connexion, alors que le build OpenGDS ne fournit pas le serveur Arrow.
-
-## Reproduire le JAR
-
-Utiliser un JDK 21 :
-
-```bash
-git clone https://github.com/neo4j/graph-data-science.git
-cd graph-data-science
-git checkout 2.22.0
-git apply /chemin/vers/gds-2.22.0-bfs-depth.patch
-./gradlew :algo:test \
-  --tests org.neo4j.gds.paths.traverse.BFSTest
-./gradlew :proc-path-finding:test \
-  --tests org.neo4j.gds.paths.traverse.BfsStreamProcTest
-./gradlew :proc-sysinfo:test \
-  --tests org.neo4j.gds.SysInfoProcTest
-./gradlew :open-packaging:shadowCopy
-```
-
-Le résultat est créé dans
-`build/distributions/open-gds-2.22.0.jar`.
-
-Le `Dockerfile` copie ce JAR dans le répertoire des plugins Neo4j et
-n’utilise donc pas le téléchargement automatique du plugin GDS officiel.

opengds/gds-2.22.0-bfs-depth.patch

@@ -1,391 +0,0 @@
-diff --git a/algo/src/main/java/org/neo4j/gds/paths/traverse/BFS.java b/algo/src/main/java/org/neo4j/gds/paths/traverse/BFS.java
-index 1ef036b..7394194 100644
---- a/algo/src/main/java/org/neo4j/gds/paths/traverse/BFS.java
-+++ b/algo/src/main/java/org/neo4j/gds/paths/traverse/BFS.java
-@@ -181,6 +181,10 @@ public final class BFS extends Algorithm<HugeLongArray> {
- 
-     @Override
-     public HugeLongArray compute() {
-+        return computeWithDepths().nodeIds();
-+    }
-+
-+    public BfsResult computeWithDepths() {
-         progressTracker.beginSubTask(graph.relationshipCount());
- 
-         // This is used to read from `traversedNodes` in chunks, updated in `BFSTask`.
-@@ -259,7 +263,10 @@ public final class BFS extends Algorithm<HugeLongArray> {
-             nodesLengthToRetain = targetFoundIndex.longValue() + 1;
-         }
- 
--        var result = traversedNodes.copyOf(nodesLengthToRetain);
-+        var result = new BfsResult(
-+            traversedNodes.copyOf(nodesLengthToRetain),
-+            weights.copyOf(nodesLengthToRetain)
-+        );
- 
-         progressTracker.endSubTask();
-         return result;
-diff --git a/algo/src/main/java/org/neo4j/gds/paths/traverse/BFSTask.java b/algo/src/main/java/org/neo4j/gds/paths/traverse/BFSTask.java
-index 268dc92..dc24735 100644
---- a/algo/src/main/java/org/neo4j/gds/paths/traverse/BFSTask.java
-+++ b/algo/src/main/java/org/neo4j/gds/paths/traverse/BFSTask.java
-@@ -164,7 +164,15 @@ class BFSTask implements Runnable {
-                 // In case `nodeId` is encountered in a later chunk,
-                 // the if check will be false and not added to traversedNodes again.
-                 if (!visited.getAndSet(nodeId)) {
-+                    long predecessorIndex = minimumChunk.get(nodeId);
-+                    long predecessorNodeId = traversedNodes.get(predecessorIndex);
-+                    double depth = aggregatorFunction.apply(
-+                        predecessorNodeId,
-+                        nodeId,
-+                        weights.get(predecessorIndex)
-+                    );
-                     traversedNodes.set(index, nodeId);
-+                    weights.set(index, depth);
-                     index++;
-                     nodesTraversed++;
-                 }
-diff --git a/algo/src/main/java/org/neo4j/gds/paths/traverse/BfsResult.java b/algo/src/main/java/org/neo4j/gds/paths/traverse/BfsResult.java
-new file mode 100644
-index 0000000..f200329
---- /dev/null
-+++ b/algo/src/main/java/org/neo4j/gds/paths/traverse/BfsResult.java
-@@ -0,0 +1,20 @@
-+/*
-+ * Copyright (c) "Neo4j"
-+ * Neo4j Sweden AB [http://neo4j.com]
-+ *
-+ * This file is part of Neo4j.
-+ *
-+ * Neo4j is free software: you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License as published by
-+ * the Free Software Foundation, either version 3 of the License, or
-+ * (at your option) any later version.
-+ */
-+package org.neo4j.gds.paths.traverse;
-+
-+import org.neo4j.gds.collections.ha.HugeDoubleArray;
-+import org.neo4j.gds.collections.ha.HugeLongArray;
-+
-+/**
-+ * Nodes visited by BFS and their minimum depth, aligned by array index.
-+ */
-+public record BfsResult(HugeLongArray nodeIds, HugeDoubleArray depths) {}
-diff --git a/algo/src/test/java/org/neo4j/gds/paths/traverse/BFSTest.java b/algo/src/test/java/org/neo4j/gds/paths/traverse/BFSTest.java
-index 89b9074..6b4816a 100644
---- a/algo/src/test/java/org/neo4j/gds/paths/traverse/BFSTest.java
-+++ b/algo/src/test/java/org/neo4j/gds/paths/traverse/BFSTest.java
-@@ -174,6 +174,30 @@ class BFSTest {
-         );
-     }
- 
-+    @ParameterizedTest
-+    @ValueSource(ints = {1, 4})
-+    void shouldReturnMinimumDepthAlongsideEveryVisitedNode(int concurrency) {
-+        long source = naturalGraph.toMappedNodeId("a");
-+        var result = BFS.create(
-+            naturalGraph,
-+            source,
-+            (s, t, w) -> Result.FOLLOW,
-+            new OneHopAggregator(),
-+            TraversalParameters.NO_MAX_DEPTH,
-+            DefaultPool.INSTANCE,
-+            new Concurrency(concurrency),
-+            ProgressTracker.NULL_TRACKER,
-+            TerminationFlag.RUNNING_TRUE
-+        ).computeWithDepths();
-+
-+        assertThat(result.nodeIds().toArray()).isEqualTo(
-+            Stream.of("a", "b", "c", "d", "e", "f", "g")
-+                .mapToLong(naturalGraph::toMappedNodeId)
-+                .toArray()
-+        );
-+        assertThat(result.depths().toArray()).containsExactly(0, 1, 1, 2, 3, 3, 4);
-+    }
-+
-     @ParameterizedTest
-     @ValueSource(ints = {1, 4})
-     void testBfsOnLoopGraph(int concurrency) {
-diff --git a/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithms.java b/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithms.java
-index 6313df2..edf59a3 100644
---- a/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithms.java
-+++ b/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithms.java
-@@ -44,8 +44,10 @@ import org.neo4j.gds.paths.dijkstra.DijkstraFactory;
- import org.neo4j.gds.paths.dijkstra.DijkstraSourceTargetParameters;
- import org.neo4j.gds.paths.dijkstra.PathFindingResult;
- import org.neo4j.gds.paths.traverse.BFS;
-+import org.neo4j.gds.paths.traverse.BfsResult;
- import org.neo4j.gds.paths.traverse.DFS;
- import org.neo4j.gds.paths.traverse.ExitAndAggregation;
-+import org.neo4j.gds.paths.traverse.OneHopAggregator;
- import org.neo4j.gds.paths.yens.Yens;
- import org.neo4j.gds.paths.yens.YensParameters;
- import org.neo4j.gds.pcst.PCSTParameters;
-@@ -137,6 +139,30 @@ public class PathFindingAlgorithms {
-         return bfs.compute();
-     }
- 
-+    BfsResult breadthFirstSearchWithDepths(
-+        Graph graph,
-+        TraversalParameters parameters,
-+        ProgressTracker progressTracker,
-+        TerminationFlag terminationFlag
-+    ) {
-+        var exitAndAggregationConditions = ExitAndAggregation.create(graph, parameters);
-+        var mappedStartNodeId = graph.toMappedNodeId(parameters.sourceNode());
-+
-+        var bfs = BFS.create(
-+            graph,
-+            mappedStartNodeId,
-+            exitAndAggregationConditions.exitFunction(),
-+            new OneHopAggregator(),
-+            parameters.maxDepth(),
-+            DefaultPool.INSTANCE,
-+            parameters.concurrency(),
-+            progressTracker,
-+            terminationFlag
-+        );
-+
-+        return bfs.computeWithDepths();
-+    }
-+
-     public PathFindingResult deltaStepping(
-         Graph graph,
-         DeltaSteppingParameters parameters,
-diff --git a/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsBusinessFacade.java b/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsBusinessFacade.java
-index 0753c65..ebcb9cc 100644
---- a/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsBusinessFacade.java
-+++ b/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsBusinessFacade.java
-@@ -51,6 +51,7 @@ import org.neo4j.gds.paths.dijkstra.config.DijkstraBaseConfig;
- import org.neo4j.gds.paths.dijkstra.config.DijkstraSourceTargetsBaseConfig;
- import org.neo4j.gds.paths.traverse.BFSProgressTask;
- import org.neo4j.gds.paths.traverse.BfsBaseConfig;
-+import org.neo4j.gds.paths.traverse.BfsResult;
- import org.neo4j.gds.paths.traverse.DFSProgressTask;
- import org.neo4j.gds.paths.traverse.DfsBaseConfig;
- import org.neo4j.gds.paths.yens.YensProgressTask;
-@@ -141,6 +142,21 @@ public class PathFindingAlgorithmsBusinessFacade {
-         );
-     }
- 
-+    BfsResult breadthFirstSearchWithDepths(Graph graph, BfsBaseConfig configuration) {
-+        var progressTracker = createProgressTracker(BFSProgressTask.create(), configuration);
-+
-+        return algorithmMachinery.getResult(
-+            () -> algorithms.breadthFirstSearchWithDepths(
-+                graph,
-+                configuration.toParameters(),
-+                progressTracker,
-+                requestScopedDependencies.terminationFlag()
-+            ),
-+            progressTracker,
-+            configuration.concurrency()
-+        );
-+    }
-+
-     public PathFindingResult deltaStepping(Graph graph, AllShortestPathsDeltaBaseConfig configuration) {
-         var progressTracker = createProgressTracker(DeltaSteppingProgressTask.create(), configuration);
- 
-diff --git a/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsStreamModeBusinessFacade.java b/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsStreamModeBusinessFacade.java
-index b14fde5..28f9141 100644
---- a/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsStreamModeBusinessFacade.java
-+++ b/applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsStreamModeBusinessFacade.java
-@@ -37,6 +37,7 @@ import org.neo4j.gds.paths.dijkstra.PathFindingResult;
- import org.neo4j.gds.paths.dijkstra.config.AllShortestPathsDijkstraStreamConfig;
- import org.neo4j.gds.paths.dijkstra.config.ShortestPathDijkstraStreamConfig;
- import org.neo4j.gds.paths.traverse.BfsStreamConfig;
-+import org.neo4j.gds.paths.traverse.BfsResult;
- import org.neo4j.gds.paths.traverse.DfsStreamConfig;
- import org.neo4j.gds.paths.yens.config.ShortestPathYensStreamConfig;
- import org.neo4j.gds.pcst.PCSTStreamConfig;
-@@ -117,14 +118,14 @@ public class PathFindingAlgorithmsStreamModeBusinessFacade {
-     public <RESULT> Stream<RESULT> breadthFirstSearch(
-         GraphName graphName,
-         BfsStreamConfig configuration,
--        StreamResultBuilder<HugeLongArray, RESULT> resultBuilder
-+        StreamResultBuilder<BfsResult, RESULT> resultBuilder
-     ) {
-         return convenience.processRegularAlgorithmInStreamMode(
-             graphName,
-             configuration,
-             BFS,
-             estimation::breadthFirstSearch,
--            (graph, __) -> algorithms.breadthFirstSearch(graph, configuration),
-+            (graph, __) -> algorithms.breadthFirstSearchWithDepths(graph, configuration),
-             resultBuilder
-         );
-     }
-diff --git a/proc/path-finding/src/test/java/org/neo4j/gds/paths/traverse/BfsStreamProcTest.java b/proc/path-finding/src/test/java/org/neo4j/gds/paths/traverse/BfsStreamProcTest.java
-index 8c3d35a..4c641a6 100644
---- a/proc/path-finding/src/test/java/org/neo4j/gds/paths/traverse/BfsStreamProcTest.java
-+++ b/proc/path-finding/src/test/java/org/neo4j/gds/paths/traverse/BfsStreamProcTest.java
-@@ -125,7 +125,7 @@ class BfsStreamProcTest extends BaseProcTest {
-             .streamMode()
-             .addParameter("sourceNode", source)
-             .addParameter("maxDepth", 2)
--            .yields("sourceNode", "nodeIds");
-+            .yields("sourceNode", "nodeIds", "depths");
- 
-         runQueryWithRowConsumer(query, row -> {
-             assertEquals(row.getNumber("sourceNode").longValue(), source);
-@@ -133,6 +133,7 @@ class BfsStreamProcTest extends BaseProcTest {
-             assertThat(nodeIds).isEqualTo(
-                 Stream.of("a", "b", "c", "d").map(idFunction::of).collect(Collectors.toList())
-             );
-+            assertThat(row.get("depths")).isEqualTo(List.of(0L, 1L, 1L, 2L));
-         });
-     }
- 
-@@ -175,7 +176,7 @@ class BfsStreamProcTest extends BaseProcTest {
-             .algo("bfs")
-             .streamMode()
-             .addParameter("sourceNode", source)
--            .yields("sourceNode", "nodeIds");
-+            .yields("sourceNode", "nodeIds", "depths");
-         runQueryWithRowConsumer(query, row -> {
-             assertThat(row.getNumber("sourceNode").longValue()).isEqualTo(source);
- 
-@@ -188,6 +189,7 @@ class BfsStreamProcTest extends BaseProcTest {
-                         .map(idFunction::of)
-                         .collect(Collectors.toList())
-                 );
-+            assertThat(row.get("depths")).isEqualTo(List.of(0L, 1L, 1L, 2L, 3L, 3L, 4L));
-         });
-     }
- 
-diff --git a/proc/sysinfo/src/main/java/org/neo4j/gds/SysInfoProc.java b/proc/sysinfo/src/main/java/org/neo4j/gds/SysInfoProc.java
-index 9b729b5..bd0ca5f 100644
---- a/proc/sysinfo/src/main/java/org/neo4j/gds/SysInfoProc.java
-+++ b/proc/sysinfo/src/main/java/org/neo4j/gds/SysInfoProc.java
-@@ -69,6 +69,27 @@ public class SysInfoProc {
-         return debugValues(properties, Runtime.getRuntime(), config);
-     }
- 
-+    @Procedure("gds.debug.arrow")
-+    @SystemProcedure
-+    @Description("Returns the status of the unavailable Arrow server in OpenGDS")
-+    public Stream<ArrowInfo> arrow() {
-+        return Stream.of(new ArrowInfo("", false, false, java.util.List.of()));
-+    }
-+
-+    public static final class ArrowInfo {
-+        public final String listenAddress;
-+        public final boolean enabled;
-+        public final boolean running;
-+        public final java.util.List<String> versions;
-+
-+        private ArrowInfo(String listenAddress, boolean enabled, boolean running, java.util.List<String> versions) {
-+            this.listenAddress = listenAddress;
-+            this.enabled = enabled;
-+            this.running = running;
-+            this.versions = versions;
-+        }
-+    }
-+
-     public static final class DebugValue {
-         public final String key;
-         public final Object value;
-diff --git a/proc/sysinfo/src/test/java/org/neo4j/gds/SysInfoProcTest.java b/proc/sysinfo/src/test/java/org/neo4j/gds/SysInfoProcTest.java
-index f1a3ddb..a9f44c5 100644
---- a/proc/sysinfo/src/test/java/org/neo4j/gds/SysInfoProcTest.java
-+++ b/proc/sysinfo/src/test/java/org/neo4j/gds/SysInfoProcTest.java
-@@ -138,4 +138,19 @@ class SysInfoProcTest extends BaseProcTest {
-         );
-         assertThat(result).containsExactly(BuildInfoProperties.get().gdsVersion());
-     }
-+
-+    @Test
-+    void shouldReportArrowAsDisabledForClientCompatibility() {
-+        var result = runQuery(
-+            "CALL gds.debug.arrow() YIELD listenAddress, enabled, running, versions "
-+                + "RETURN listenAddress, enabled, running, versions",
-+            cypherResult -> cypherResult.stream().findFirst().orElseThrow()
-+        );
-+
-+        assertThat(result)
-+            .containsEntry("listenAddress", "")
-+            .containsEntry("enabled", false)
-+            .containsEntry("running", false)
-+            .containsEntry("versions", List.of());
-+    }
- }
-diff --git a/procedures/algorithms-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/BfsStreamResultBuilder.java b/procedures/algorithms-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/BfsStreamResultBuilder.java
-index 06e5426..b8e48f8 100644
---- a/procedures/algorithms-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/BfsStreamResultBuilder.java
-+++ b/procedures/algorithms-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/BfsStreamResultBuilder.java
-@@ -23,16 +23,17 @@ import org.neo4j.gds.api.Graph;
- import org.neo4j.gds.api.GraphStore;
- import org.neo4j.gds.api.NodeLookup;
- import org.neo4j.gds.applications.algorithms.machinery.StreamResultBuilder;
--import org.neo4j.gds.collections.ha.HugeLongArray;
-+import org.neo4j.gds.paths.traverse.BfsResult;
- import org.neo4j.gds.paths.traverse.BfsStreamConfig;
- import org.neo4j.graphdb.RelationshipType;
- 
-+import java.util.Arrays;
- import java.util.Optional;
- import java.util.stream.Stream;
- 
- import static org.neo4j.gds.procedures.algorithms.pathfinding.TraversalStreamResult.RELATIONSHIP_TYPE_NAME;
- 
--class BfsStreamResultBuilder implements StreamResultBuilder<HugeLongArray, TraversalStreamResult> {
-+class BfsStreamResultBuilder implements StreamResultBuilder<BfsResult, TraversalStreamResult> {
-     private final NodeLookup nodeLookup;
-     private final boolean pathRequested;
-     private final BfsStreamConfig configuration;
-@@ -47,18 +48,30 @@ class BfsStreamResultBuilder implements StreamResultBuilder<HugeLongArray, Trave
-     public Stream<TraversalStreamResult> build(
-         Graph graph,
-         GraphStore graphStore,
--        Optional<HugeLongArray> result
-+        Optional<BfsResult> result
-     ) {
-         //noinspection OptionalIsPresent
-         if (result.isEmpty()) return Stream.empty();
- 
--        return TraverseStreamComputationResultConsumer.consume(
--            configuration.sourceNode(),
--            result.get(),
--            graph::toOriginalNodeId,
--            TraversalStreamResult::new,
--            PathFactoryFacade.create(pathRequested, nodeLookup, graphStore.capabilities().canWriteToLocalDatabase()),
--            RelationshipType.withName(RELATIONSHIP_TYPE_NAME)
-+        var bfsResult = result.get();
-+        var nodeList = Arrays.stream(bfsResult.nodeIds().toArray())
-+            .map(graph::toOriginalNodeId)
-+            .boxed()
-+            .toList();
-+        var depthList = Arrays.stream(bfsResult.depths().toArray())
-+            .mapToObj(depth -> (long) depth)
-+            .toList();
-+        var path = PathFactoryFacade
-+            .create(pathRequested, nodeLookup, graphStore.capabilities().canWriteToLocalDatabase())
-+            .createPath(nodeList, RelationshipType.withName(RELATIONSHIP_TYPE_NAME));
-+
-+        return Stream.of(
-+            new TraversalStreamResult(
-+                configuration.sourceNode(),
-+                nodeList,
-+                depthList,
-+                path
-+            )
-         );
-     }
- }
-diff --git a/procedures/facade-api/path-finding-facade-api/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/TraversalStreamResult.java b/procedures/facade-api/path-finding-facade-api/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/TraversalStreamResult.java
-index 35a4c21..8a64fd8 100644
---- a/procedures/facade-api/path-finding-facade-api/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/TraversalStreamResult.java
-+++ b/procedures/facade-api/path-finding-facade-api/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/TraversalStreamResult.java
-@@ -23,6 +23,10 @@ import org.neo4j.graphdb.Path;
- 
- import java.util.List;
- 
--public record TraversalStreamResult(long sourceNode, List<Long> nodeIds, Path path) {
-+public record TraversalStreamResult(long sourceNode, List<Long> nodeIds, List<Long> depths, Path path) {
-     public static final String RELATIONSHIP_TYPE_NAME = "NEXT";
-+
-+    public TraversalStreamResult(long sourceNode, List<Long> nodeIds, Path path) {
-+        this(sourceNode, nodeIds, List.of(), path);
-+    }
- }
-

opengds/open-gds-2.22.0-genmod.jar

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:940c1f0c0cb6a9adbee84c9f15207740262e7c7c83464ad61b31000e4b7caf5e
-size 32584145

start.sh

@@ -1,37 +1,11 @@
-set -euo pipefail
-
-DUMP_REPO="${GENMOD_DUMP_REPO:-cnil/genmod-dump-neo4j}"
-DUMP_REVISION="${GENMOD_DUMP_REVISION:-main}"
-DUMP_BASE_URL="https://huggingface.co/datasets/${DUMP_REPO}/resolve/${DUMP_REVISION}"
-AUTH_HEADER="Authorization: Bearer ${HF_TOKEN}"
-
-# Load the database backup. Metadata is optional for compatibility with the
-# original dump; the application then falls back to its historical date.
-wget --header="${AUTH_HEADER}" "${DUMP_BASE_URL}/system.dump" -O /backups/system.dump
-wget --header="${AUTH_HEADER}" "${DUMP_BASE_URL}/neo4j.dump" -O /backups/neo4j.dump
-if ! wget --header="${AUTH_HEADER}" "${DUMP_BASE_URL}/database_metadata.json" \
-    -O /backups/database_metadata.json; then
-  rm -f /backups/database_metadata.json
-fi
+# load database backup
+wget --no-clobber --header="Authorization: Bearer $HF_TOKEN" https://huggingface.co/datasets/cnil/genmod-dump-neo4j/resolve/main/system.dump -P /backups/
+wget --no-clobber --header="Authorization: Bearer $HF_TOKEN" https://huggingface.co/datasets/cnil/genmod-dump-neo4j/resolve/main/neo4j.dump -P /backups/
 neo4j-admin database load --expand-commands system --from-path=/backups --overwrite-destination=true
 neo4j-admin database load --expand-commands neo4j --from-path=/backups --overwrite-destination=true
 
 # start database
 /startup/docker-entrypoint.sh neo4j &
-
-# The Community importer cannot create indexes through --schema. Ensure that
-# dumps produced by the refresh Job receive the required indexes before the
-# application starts serving searches.
-until cypher-shell -u neo4j -p genealogiemodeles \
-  "RETURN 1;" >/dev/null 2>&1; do
-  sleep 2
-done
-cypher-shell -u neo4j -p genealogiemodeles \
-  "CREATE INDEX IF NOT EXISTS FOR (m:Model) ON (m.name);
-   CREATE INDEX IF NOT EXISTS FOR (a:Author) ON (a.name);
-   CREATE INDEX IF NOT EXISTS FOR (d:Dataset) ON (d.name);
-   CALL db.awaitIndexes(600);"
-
 # start tool
 python3 /application_neo4j/app.py neo4j genealogiemodeles &
 # wait for any process to exit