add app

Dockerfile

@@ -0,0 +1,19 @@
+FROM neo4j:2025.09.0-community
+
+# neo4j
+ENV NEO4J_PLUGINS='["graph-data-science"]'
+RUN chmod 400 /var/lib/neo4j/conf/neo4j.conf
+RUN chmod 400 /var/lib/neo4j/conf/neo4j-admin.conf
+
+# python
+RUN apt-get update \
+  && apt-get install -y python3 python3-pip \  
+  && rm -rf /var/lib/apt/lists/*
+
+# app
+ADD application_neo4j /application_neo4j
+RUN pip install -r /application_neo4j/requirements.txt
+
+COPY start.sh start.sh
+ENTRYPOINT ["/bin/bash"]
+CMD ["./start.sh"]

application_neo4j/README.md

@@ -0,0 +1,122 @@
+
+## Dossier application_neo4j :
+Cette application est une interface web construite avec **Flask** qui permet d'explorer un graphe de modèles et de datasets stocké dans **Neo4j** et exploité avec **Graph Data Science (GDS)**.
+
+## Prérequis
+
+1. **Python 3.10** 
+2. Créer une instance Neo4j avec le plug-in GDS :
+   - suivre les instructions et télécharger la version de neo4j community adaptée à votre enironnement : https://neo4j.com/deployment-center/
+     
+  <img width="1138" height="614" alt="Capture d’écran du 2025-09-09 16-33-46" src="https://github.com/user-attachments/assets/fcc6f82b-63eb-476c-af46-85e57cce3d97" />
+
+
+   - Configurer l'utilisation du plugin GDS en suivant les instructions pour la "Community Edition" : https://neo4j.com/docs/graph-data-science/current/installation/neo4j-server/
+4. **pip** pour installer les dépendances Python
+5. Clonez ce projet puis installez les dépendances :
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+6. Récupérer les données formattés
+
+   Si la base n'a pas encore été chargée, il faut récupérer le fichier "model_with_all_information.csv" généré préalablement dans le dossier pre-processing/base_de_donnees.
+
+7. Le fichier `load_data.py` configuré avec les bons identifiants de connexion (URI, utilisateur, mot de passe de l'instance Neo4j).
+   
+8. **Chargement des données dans Neo4j**
+
+   Ce script (`load_data.py`) est essentiel car il sert de pont entre votre fichier CSV et la base de données Neo4j. Le chargement de 1.8 M de modèles prend environ 30 min lorqu'il est effectué sur 8 threads parallèles.
+   Ouvrez un terminal et exécutez le script en choisissant l'une des deux options suivantes :
+
+   Les arguments **name_neo4j** et **password_neo4J** sont respectivement le nom et le mot de passe que vous avez donné à votre instance Neo4J lors de sa création.
+
+   *(Dans mon cas, name_neo4j = neo4j et password_neo4J = genealogiemodeles)*
+
+    **1. Pour une nouvelle installation ou une réinitialisation complète :**
+
+   Cette commande efface toutes les données existantes avant de tout importer.
+   ```bash
+   python load_data.py true name_neo4j password_neo4j
+   ```
+
+   **2. Pour une mise à jour (ajout de nouvelles données sans effacer les anciennes) :**
+
+   Cette commande ne charge que les modèles du CSV qui ne sont pas déjà dans la base.
+   ```bash
+   python load_data.py false name_neo4j password_neo4j
+   ```
+
+   À la fin de l'exécution, votre base de données Neo4j est peuplée et prête à être utilisée par l'application. Un fichier processed_ids.txt est mis à jour avec l'id de tous les modèles déjà chargés dans la base. 
+
+### Utilisation : Lancement de l'application Flask
+
+Une fois la base de données prête, vous pouvez lancer le serveur web.
+Exécutez la commande suivante dans votre terminal :
+```bash
+python app.py name_neo4j password_neo4j
+```
+Les arguments **name_neo4j** et **password_neo4J** sont respectivement le nom et le mot de passe que vous avez donné à votre instance Neo4J lors de sa création.
+
+*(Dans mon cas, name_neo4j = neo4j et password_neo4J =genealogiemodeles)*
+
+Le terminal affichera un message indiquant que le serveur est en cours d'exécution, généralement sur `http://127.0.0.1:5000`. Vous pouvez maintenant ouvrir cette adresse dans votre navigateur web pour utiliser l'application.
+
+---
+
+<img width="1864" height="912" alt="Capture d'écran 2025-09-09 155319" src="https://github.com/user-attachments/assets/6b92d363-9227-4331-912c-bcb524a592b1" />
+
+
+## Détails de l'Architecture de l'Application
+
+*   `app.py`
+    *   **Rôle** : Fichier principal et point d'entrée de l'application.
+    *   **Fonctionnalités** :
+        *   Initialise l'application Flask.
+        *   Établit la connexion au driver Neo4j et à la bibliothèque GDS.
+        *   Définit les **routes** (URL) de l'application.
+
+
+*   `app_algorithms.py` 
+    *   **Rôle** : Module  dédié à l'exécution des algorithmes d'analyse de graphe via la bibliothèque Neo4j Graph Data Science (GDS).
+    *   **Fonctionnalités** :
+        *   **Recherche exhaustive de la généalogie (`run_gds_bfs`)** : Exécute l'algorithme de parcours en largeur (BFS) pour trouver tous les nœuds accessibles
+            depuis un nœud de départ, à la fois en aval (descendants) et en amont (ascendants). Les résultats sont destinés aux tableaux de données détaillés et à la visualisation du graphe complet.
+        *   **Identification des points clés (`get_genealogy_highlights`)** : Exécute des requêtes Cypher ciblées pour identifier les modèles plus importants dans l'ascendance et la descendance (ex: les plus téléchargés, les plus cités, les modèles "racines"). Les résultats sont enrichis avec des "badges".
+        *   **`create_node_data`** : Fonction utilitaire de formatage. Traduit un dictionnaire de propriétés brutes venant de Neo4j en un dictionnaire structuré et propre pour le front-end.
+            La structure de sortie dépend du type (label) du nœud.
+          *   **`project_gds_bfs_results`** :  Elle prend les résultats bruts de l'algorithme BFS (une simple liste d'ID de nœuds) et reconstruit le sous-graphe complet avec toutes
+            les propriétés et les relations  stockées dans Neo4j.
+          
+*   Dossier `templates/`
+    *   **Rôle** : Contient tous les fichiers HTML qui constituent les pages de l'application.
+    *   **Fichiers principaux** :
+        *   `search.html` : Il s'agit de la page principale de l'application. Elle sert à la fois de page d'accueil pour la recherche et de page d'affichage des résultats après une requête, SI le noeud cherché est un modèle.
+            *   **Contenu principal :**
+                *   **Formulaire de recherche :** Permet à l'utilisateur de rechercher un nœud (modèle, dataset) par son nom. Il inclut l'auto-complétion, le réglage de la profondeur de la recherche (illimitée ou limitée) et des filtres.
+                *   **Vue "Highlights" :** Après une recherche réussie, cette section affiche une synthèse visuelle en trois colonnes : les modèles ascendants les plus importants, le modèle recherché au centre avec ses statistiques clés, et les modèles descendants les plus importants.
+                *   **Tableaux détaillés :** Deux tableaux interactifs (motorisés par *DataTables*) listent de manière exhaustive tous les modèles de l'ascendance et de la descendance.
+                *   **Visualisation du Graphe :** Une section, initialement masquée, contient un graphe interactif (généré avec *Sigma.js*) qui représente visuellement l'arbre généalogique complet.
+
+        *   `search_dataset.html` : Page d'affichage des résultats après une requête, SI le noeud cherché est un dataset.
+            *   **Contenu principal :**
+                *   **Formulaire de recherche :** Permet à l'utilisateur de rechercher un nœud (modèle, dataset) par son nom. Il inclut l'auto-complétion, le réglage de la profondeur de la recherche (illimitée ou limitée) et des filtres.
+                *   **Tableau détaillé :** Tableau interactif (motorisé par *DataTables*) liste de manière exhaustive tous les modèles entraînés sur le dataset recherché.
+                *   **Visualisation du Graphe :** Une section, initialement masquée, contient un graphe interactif (généré avec *Sigma.js*) qui représente visuellement l'arbre généalogique complet.
+ 
+        *   `expert.html` : Permet de chercher un noeud et afficher le graphe en choissisant les types de liens et de noeuds visibles + bouton pour télécharger le graphe au format HTML.
+      
+        *   `index.html` : Page d'accueil et porte d'entrée de l'application.
+        *   `infos.html` : lien vers des slides avec plus d'informations.
+            
+
+*   Dossier `static/`
+    *   **Rôle** : Sert les fichiers statiques qui ne changent pas, comme le CSS, le JavaScript et les images.
+    *   **Contenu** :
+        *   `css/style.css` : Styles personnalisés qui complètent le framework Bootstrap pour affiner l'apparence de l'application.
+        *   `js/script.js` : Pour l'interactivité de  `search.html`.
+        *   `js/script_expert.js` : Pour l'interactivité de  `expert.html`.
+        *   `js/script_dataset.js` : Pour l'interactivité de  `search_dataset.html`.
+        *   `js/utils.js` : regroupe les fonctions utilisées dans plusieurs scripts.
+        *   `graph_export.html` : fichier pour créer l'export du graphe lorsque l'utilisateur souhaite télécharger le graphe dans le mode expert.

application_neo4j/app.py

@@ -0,0 +1,431 @@
+# --- Import et initialisation Flask ---
+import os
+from flask import Flask, request, render_template, jsonify
+from neo4j import GraphDatabase, basic_auth
+from graphdatascience import GraphDataScience
+import app_algorithms as algo
+import pandas as pd
+from typing import Dict
+from collections import defaultdict
+import argparse
+
+app = Flask(__name__, static_url_path="/static/")  # Application Flask
+
+# --- Connexion à Neo4j et GDS ---
+NEO4J_URI = "bolt://localhost:7687"
+GDS_GRAPH_NAME = "genealogie_gds"
+
+# --- Configuration des arguments du script ---
+parser = argparse.ArgumentParser(description="Script pour lancer la web application.")
+
+parser.add_argument(
+    'neo4j_user',                                     # Le nom de l'argument (positionnel, car sans tirets)
+    type=str,                                    # On attend une chaîne de caractères
+    help="Nom de votre instance Neo4J"
+)
+
+parser.add_argument(
+    'neo4j_password',                                     # Le nom de l'argument (positionnel, car sans tirets)
+    type=str,                                    # On attend une chaîne de caractères
+    help="Mot de passe de votre instance Neo4J"
+)
+
+args = parser.parse_args()
+
+NEO4J_PASSWORD = args.neo4j_password
+NEO4J_USER = args.neo4j_user 
+
+try:
+    driver = GraphDatabase.driver(NEO4J_URI, auth=basic_auth(NEO4J_USER, NEO4J_PASSWORD))
+    gds = GraphDataScience(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
+except Exception as e:
+    print(f"FATAL: Could not connect to Neo4j/GDS at startup. Error: {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):
+    """
+    Projette deux graphes dans :
+    - Graphe "naturel" : relations descendant (source -> target)
+    - Graphe "inverse" : relations ascendant (target -> source)
+    Les projections sont nécessaires pour lancer des algorithmes GDS comme BFS
+    """
+
+    natural_graph_name = f"{graph_name}_natural"
+    reverse_graph_name = f"{graph_name}_reverse"
+
+    # 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.route("/")  # Page d'accueil
+def home():
+    return render_template("index.html")
+
+@app.route("/info")  # Page d'informations
+def info_page():
+    return render_template("infos.html")
+
+# Suggestions pour l'autocomplétion
+@app.route("/autocomplete")
+def autocomplete():
+    query = request.args.get("q", "")
+    node_filter = request.args.get("filter") 
+    if not query:
+        return jsonify([])
+    
+    # Filtrage optionnel par label (Model ou Dataset)
+    label_cypher = ""
+    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
+    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
+        ORDER BY size(n.name) ASC
+        LIMIT 10
+    """
+    try:
+        results_df = gds.run_cypher(cypher, {"prefix": query})
+        suggestions = results_df.to_dict('records')
+        return jsonify(suggestions)
+
+    except Exception as e:
+        print(f"Autocomplete error: {e}")
+        return jsonify([])
+
+
+@app.route("/search", methods=["GET", "POST"])  # Recherche d'un noeud
+def findnode():
+    """
+    1. Récupère le nom à chercher et la profondeur
+    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
+    """  
+
+    message = None
+    highlights = {}
+    graph_data = {"nodes": [], "edges": [], "models_count": []}
+    current_filters = []
+    if request.method == "GET":
+        # Pour les liens depuis la page d'accueil 
+        filter_from_url = request.args.get('filter')
+        if filter_from_url:
+            current_filters.append(filter_from_url)
+    else: # POST
+        # Pour le formulaire soumis avec les checkboxes
+        current_filters = request.form.getlist('filters')
+
+    search_info = {
+        "name": request.form.get("name", ""), 
+        "depth": int(request.form.get("depth", 3)), 
+        "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 = '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}
+
+        if not name:
+            message = "Veuillez entrer un nom à rechercher."
+            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"
+
+            # 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 = f"Le modèle/dataset '{name}' n'a pas été trouvé."
+                return render_template("search.html", message=message, search=search_info, graph_data=graph_data,highlights=highlights)
+
+            process_gds_bfs_results(gds_result, graph_data, name)
+            if gds_result["source_label"] == "Model" :
+                highlights = algo.get_genealogy_highlights(gds, name)
+                return render_template("search.html", message=message, search=search_info, graph_data=graph_data,highlights=highlights)
+            
+            if gds_result["source_label"] == "Dataset" :
+                return render_template("search_dataset.html", message=message, search=search_info, graph_data=graph_data)
+            
+            if not graph_data["nodes"] and not graph_data["edges"]:
+                message = f"Le nœud '{name}' a été trouvé, mais il n'a pas de voisins dans la profondeur spécifiée."
+                return render_template("search.html", message=message, search=search_info, graph_data=graph_data,highlights=highlights)
+        
+        except Exception as e:
+            # Gérer le cas où le nœud source n'existe pas du tout
+            if "Failed to find a node" in str(e):
+                 message = f"Le nœud '{name}' n'a pas été trouvé dans le graphe."
+            else:
+                print(f"GDS BFS Error: {e}")
+                message = f"Erreur lors de la recherche GDS: {str(e)}"
+    return render_template("search.html", message=message, search=search_info, graph_data=graph_data,highlights=highlights)
+
+
+@app.route("/expert", methods=["GET", "POST"])  # Recherche d'un noeud
+def findnode_expert():
+    """
+    1. Récupère le nom à chercher et la profondeur
+    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
+    """  
+    message = None
+    graph_data = {"nodes": [], "edges": [], "models_count": []}
+    current_filters = []
+    if request.method == "GET":
+        # Pour les liens depuis la page d'accueil 
+        filter_from_url = request.args.get('filter')
+        if filter_from_url:
+            current_filters.append(filter_from_url)
+    else: # POST
+        # Pour le formulaire soumis avec les checkboxes
+        current_filters = request.form.getlist('filters')
+
+    search_info = {
+        "name": request.form.get("name", ""), 
+        "depth": int(request.form.get("depth", 3)), 
+        "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 = '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 }
+
+        if not name:
+            message = "Veuillez entrer un nom à rechercher."
+            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"
+
+            # 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 = f"Le noeud '{name}' n'a pas été trouvé."
+                return render_template("expert.html", message=message, search=search_info, graph_data=graph_data)
+
+
+            process_gds_bfs_results(gds_result, graph_data, name)
+
+            if not graph_data["nodes"] and not graph_data["edges"]:
+                message = f"Le nœud '{name}' a été trouvé, mais il n'a pas de voisins dans la profondeur spécifiée."                
+
+        except Exception as e:
+            # Gérer le cas où le nœud source n'existe pas du tout
+            if "Failed to find a node" in str(e):
+                 message = f"Le nœud '{name}' n'a pas été trouvé dans le graphe."
+            else:
+                print(f"GDS BFS Error: {e}")
+                message = f"Erreur lors de la recherche GDS: {str(e)}"
+    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, origin_name: str):
+    """
+    Transforme les résultats d'un BFS GDS en un sous-graphe utilisable pour le front-end.
+    
+    Étapes principales :
+    1. Collecte des IDs de tous les nœuds parcourus par le BFS (ascendants et descendants).
+    2. Récupération des nœuds et relations réels dans Neo4j via une requête Cypher.
+    3. Formatage des nœuds et arêtes pour construire le dictionnaire `graph_data`.
+    """
+
+    # --- 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:
+        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]
+        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]
+        all_discovered_node_ids.update(node_ids)
+
+    if not all_discovered_node_ids:
+        return  # Aucun nœud découvert → rien à faire
+
+    # --- PHASE 2 : Récupération du sous-graphe réel dans Neo4j ---
+    with driver.session() as session:
+        # 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 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({
+            "ascendantsCount": node_obj["ascendantsCount"],
+            "descendantsCount": node_obj["descendantsCount"],
+            "citationCount": node_obj["citationCount"],
+            "task": node_obj.get("task"),
+            "license": node_obj.get("license"),
+            "createdAt": node_obj.get("createdAt"),
+            "likes": node_obj.get("likes"),
+            "distance": node_obj.get("distance")
+        })
+        if node_obj.get("author"):
+            node_properties["author"] = node_obj["author"].get("name")
+        if node_obj.get("dataset"):
+            node_properties["dataset"] = node_obj["dataset"].get("name")
+        
+        node_label = list(node_obj["labels"])[0]
+
+        if node_label == "Model" :
+            count = count +1
+
+        node_data = algo.create_node_data(node_properties, node_label)
+        graph_data["nodes"].append(node_data)
+    
+    graph_data["models_count"].append(count)
+
+    # Construction des arêtes, en évitant les doublons
+    added_edges_canonical_keys = set()
+    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
+
+        canonical_key = tuple(sorted((source_name, target_name)))
+        if canonical_key not in added_edges_canonical_keys:
+            added_edges_canonical_keys.add(canonical_key)
+            edge_id = f"{source_name}_{target_name}_{type(rel_obj).__name__}"
+            rel_props = dict(rel_obj.items())
+            graph_data["edges"].append({
+                "id": edge_id,
+                "source": source_name,
+                "target": target_name,
+                "relation": rel_props.get("name")
+            })
+
+
+if __name__ == '__main__':
+    # 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=80 if os.getenv("SPACE_ID") else 5500, 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

@@ -0,0 +1,304 @@
+# Importation des bibliothèques nécessaires
+from graphdatascience import GraphDataScience
+from typing import Dict, List, Any
+import pandas as pd
+
+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]:
+    """
+    Exécute un parcours en largeur (BFS) directionnel à l'aide de GDS pour trouver les descendants et les ascendants.
+
+    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:
+        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.
+    """
+    # 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}) 
+            RETURN id(n) AS id , labels(n) as label      
+            LIMIT 1                       
+            """,
+            {"source_name": source_name}
+        )
+        
+        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 # 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 {"source_label": source_id_result["label"][0][0],"descendant": pd.DataFrame(), "ascendant": pd.DataFrame()}
+
+    # 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
+
+    # --- 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_id_result["label"][0][0],
+        "descendant": desc_df,
+        "ascendant": asc_df
+    }
+
+
+
+
+
+def get_genealogy_highlights(gds: "GraphDataScience", model_name: str, num_highlights: int = 2) -> Dict:
+    """
+    Trouve les modèles clés dans l'ascendance et la descendance (1er/2e plus cités/téléchargés).
+    
+    Args:
+        gds: L'instance de GraphDataScience.
+        model_name: Le nom du modèle de départ.
+        num_highlights: Le nombre de modèles à récupérer pour chaque catégorie (par défaut 2).
+
+    Returns:
+        Un dictionnaire contenant les listes de modèles unifiés pour l'affichage.
+    """
+    highlights = {
+        "desc_unique_models": [],
+        "asc_unique_models": []
+    }
+
+    # --- DÉFINITION CENTRALE DES BADGES ---
+    # Centraliser les badges ici rend le code beaucoup plus facile à modifier.
+    # Les classes CSS sont directement des classes Bootstrap 5 pour simplifier le rendu dans le template HTML.
+    badges_info = {
+    'desc_cited_1': {
+        'text': '1er + cité', 
+        'class': 'bg-success',
+        'title': "Ce modèle est le plus cité parmi les modèles de la descendance."
+    },
+    'desc_cited_2': {
+        'text': '2e + cité', 
+        'class': 'bg-success bg-opacity-75',
+        'title': "Ce modèle est le deuxième plus cité parmi les modèles de la descendance."
+    },
+    'desc_downloaded_1': {
+        'text': '1er + téléchargé', 
+        'class': 'beta',
+        'title': "Ce modèle est le plus téléchargé parmi les modèles de la descendance."
+    },
+    'desc_downloaded_2': {
+        'text': '2e + téléchargé', 
+        'class': 'alpha',
+        'title': "Ce modèle est le deuxième plus téléchargé parmi les modèles de la descendance."
+    },
+    
+    'asc_foundation': {
+        'text': 'Modèle racine', 
+        'class': 'bg-warning text-dark',
+        'title': "Ce modèle n'a pas de parent connu."
+    },
+    'asc_cited_1': {
+        'text': '1er + cité', 
+        'class': 'bg-success',
+        'title': "Ce modèle est le plus cité parmi les modèles de l'ascendance."
+    },
+    'asc_cited_2': {
+        'text': '2e + cité', 
+        'class': 'bg-success bg-opacity-75',
+        'title': "Ce modèle est le deuxième plus cité parmi les modèles de l'ascendance."
+    },
+    'asc_downloaded_1': {
+        'text': '1er + téléchargé', 
+        'class': 'beta',
+        'title': "Ce modèle est le plus téléchargé parmi les modèles de l'ascendance."
+    },
+    'asc_downloaded_2': {
+        'text': '2e + téléchargé', 
+        'class': 'alpha',
+        'title': "Ce modèle est le deuxième plus téléchargé parmi les modèles de l'ascendance."
+    },
+    }
+    
+
+    def process_and_assign_badges(
+        unified_dict: Dict, 
+        model_list: List[Dict], 
+        badge_keys: List[str]
+    ):
+        """
+        Fonction utilitaire pour ajouter des modèles et leurs badges à un dictionnaire unifié.
+        Cela évite la duplication de code pour chaque catégorie (cité, téléchargé, etc.).
+        """
+        for i, model in enumerate(model_list):
+            if i < len(badge_keys): # S'assurer qu'on a un badge défini pour ce rang
+                model_name_key = model['name']
+                badge_key = badge_keys[i]
+                
+                # Ajouter le modèle au dictionnaire s'il n'y est pas déjà
+                if model_name_key not in unified_dict:
+                    unified_dict[model_name_key] = model.copy()
+                    unified_dict[model_name_key]['badges'] = []
+                
+                # Ajouter le badge correspondant
+                badge_to_add = badges_info[badge_key]
+                if badge_to_add not in unified_dict[model_name_key]['badges']:
+                    unified_dict[model_name_key]['badges'].append(badge_to_add)
+
+    # ==========================================================================
+    # 1. GESTION DE LA DESCENDANCE
+    # ==========================================================================
+    desc_downloads_query = """
+        MATCH (start:Model {name: $model_name})-[:USED_IN*1..]->(descendant:Model)
+        WHERE start <> descendant
+        WITH descendant, size([(m:Model)<-[:USED_IN]-(descendant) | m]) AS citation_count
+        RETURN descendant.name AS name, citation_count, descendant.downloads AS downloads, descendant.task AS task, descendant.license AS license, descendant.likes AS likes, descendant.createdAt AS createdAt
+        ORDER BY descendant.downloads DESC, descendant.name ASC
+        LIMIT $limit
+    """
+    desc_cited_query = """
+        MATCH (start:Model {name: $model_name})-[:USED_IN*1..]->(descendant:Model)
+        WHERE start <> descendant
+        WITH descendant, size([(m:Model)<-[:USED_IN]-(descendant) | m]) AS citation_count
+        RETURN descendant.name AS name, citation_count, descendant.task AS task, descendant.downloads AS downloads, descendant.license AS license, descendant.likes AS likes, descendant.createdAt AS createdAt
+        ORDER BY citation_count DESC, descendant.name ASC
+        LIMIT $limit
+    """
+    try:
+        params = {"model_name": model_name, "limit": num_highlights}
+        desc_downloaded_list = gds.run_cypher(desc_downloads_query, params).to_dict('records')
+        desc_cited_list = gds.run_cypher(desc_cited_query, params).to_dict('records')
+
+        desc_unified_models = {}
+        process_and_assign_badges(desc_unified_models, desc_cited_list, ['desc_cited_1', 'desc_cited_2'])
+        process_and_assign_badges(desc_unified_models, desc_downloaded_list, ['desc_downloaded_1', 'desc_downloaded_2'])
+        
+        highlights["desc_unique_models"] = list(desc_unified_models.values())
+
+    except Exception as e:
+        print(f"Erreur lors de la recherche des descendants: {e}")
+
+    # ==========================================================================
+    # 2. GESTION DE L'ASCENDANCE
+    # ==========================================================================
+    asc_downloads_query = """
+        MATCH (ascendant:Model)-[:USED_IN*1..]->(start:Model {name: $model_name})
+        WHERE start <> ascendant
+        WITH ascendant, size([(m:Model)<-[:USED_IN]-(ascendant) | m]) AS citation_count
+        RETURN ascendant.name AS name, citation_count, ascendant.downloads AS downloads, ascendant.task AS task, 
+        ascendant.license AS license, ascendant.likes AS likes, ascendant.createdAt AS createdAt
+        ORDER BY ascendant.downloads DESC
+        LIMIT 1 // On ne veut que LE plus téléchargé
+    """
+    asc_cited_query = """
+        MATCH (ascendant:Model)-[:USED_IN*1..]->(start:Model {name: $model_name})
+        WHERE start <> ascendant
+        WITH ascendant, size([(m:Model)<-[:USED_IN]-(ascendant) | m]) AS citation_count
+        RETURN ascendant.name AS name, citation_count, ascendant.downloads AS downloads, ascendant.task AS task, 
+        ascendant.license AS license, ascendant.likes AS likes, ascendant.createdAt AS createdAt
+        ORDER BY citation_count DESC
+        LIMIT 1 // On ne veut que LE plus cité
+    """
+
+    foundation_query = """
+        MATCH (foundation:Model)-[:USED_IN*1..]->(start:Model {name: $model_name})
+        WHERE NOT EXISTS( (:Model)-[:USED_IN]->(foundation) )
+        WITH foundation, size([(m:Model)<-[:USED_IN]-(foundation) | m]) AS citation_count
+        RETURN DISTINCT foundation.name AS name, citation_count, foundation.downloads AS downloads, foundation.task AS task, 
+        foundation.license AS license, foundation.likes AS likes, foundation.createdAt AS createdAt
+        LIMIT $limit
+    """
+
+    try:
+        params = {"model_name": model_name, "limit": num_highlights}
+        asc_foundation_list = gds.run_cypher(foundation_query, params).to_dict('records')
+        asc_downloaded_list = gds.run_cypher(asc_downloads_query, params).to_dict('records')
+        asc_cited_list = gds.run_cypher(asc_cited_query, params).to_dict('records')
+
+        asc_unified_models = {}
+        # Ordre de priorité : Racine > Cité > Téléchargé
+        process_and_assign_badges(asc_unified_models, asc_foundation_list, ['asc_foundation'] * num_highlights) # Le badge racine s'applique à tous
+        process_and_assign_badges(asc_unified_models, asc_cited_list, ['asc_cited_1', 'asc_cited_2'])
+        process_and_assign_badges(asc_unified_models, asc_downloaded_list, ['asc_downloaded_1', 'asc_downloaded_2'])
+
+        highlights["asc_unique_models"] = list(asc_unified_models.values())
+
+    except Exception as e:
+        print(f"Erreur lors de la recherche des ascendants: {e}")
+
+    return highlights
+
+
+def create_node_data(node_props, label):
+    """
+    Construit un dictionnaire de données pour chaque noeud
+    à afficher dans le graphe front-end.
+    """
+    base_data = {
+        "id": node_props.get("name", "")
+    }
+    
+    if label == "Author":
+        return {
+            **base_data,
+            "label": node_props.get("type", "Unknown"),
+            "followers": node_props.get("followers", 1)
+        }
+    elif label == "Model":
+        licens_ =str(node_props.get("license", "Inconnue")).strip("[]")
+        if licens_ =="\'other\'" or pd.isna(licens_) or licens_ =="nan":
+            licens_ = "Autre"
+        
+        tache = node_props.get("task", "")
+        if tache =="unknown": 
+            tache = "Inconnue"
+        return {
+            **base_data,
+            "label": "Modèle",
+            "downloads": node_props.get("downloads", 1),
+            "likes": node_props.get("likes", 0),
+            "license": licens_,
+            "createdAt": node_props.get("createdAt", "inconnue"),
+            "createdAt_dataset": node_props.get("createdAt_dataset", "inconnue"),
+            "task": tache,
+            "author": node_props.get("author", ""),"dataset": node_props.get("dataset", ""),
+                "ascendantsCount": node_props.get("ascendantsCount", 0),"descendantsCount": node_props.get("descendantsCount", 0),
+                "citationCount": node_props.get("citationCount", 0), "distance":node_props.get("distance", 0)
+        }
+    else:  # Dataset or other
+        return {
+            **base_data,
+            "label": "Dataset",
+            "downloads": node_props.get("downloads", 1),
+            "createdAt_dataset": node_props.get("createdAt_dataset", "inconnue")
+        }
+
+    return { "id": node_props['name'], "label": label, **node_props }
+

application_neo4j/extract_dump.md

@@ -0,0 +1,21 @@
+Pour faire tourner le space il faut extraire le fichier .dump, créé par l'instance Neo4j qui contient la base de données graphe.
+
+Pour cela il faut s'assurer que neo4j ne tourne plus sur le serveur :
+```bash
+ps aux | grep neo4j
+```
+On note les PID correspondant au processus de neo4J, puis, on les arrête :
+```bash
+sudo kill -SIGTERM <PID>
+```
+
+Ensuite on peut récupérer le dump, en ayant préalablement créé un dossier  vide `backups` : 
+```bash
+sudo neo4j-admin database dump '*' --to-path=/home/acs/genealogie/backups/ --verbose
+```
+On récupère ainsi 2 fichiers .dump, celui qui nous intéresse est neo4J.dump. 
+
+Ne pas oublier de relancer neo4j, pour pouvoir faire tourner l'app sur le serveur : 
+```bash
+sudo neo4j start
+```

application_neo4j/load_data.py

@@ -0,0 +1,64 @@
+from neo4j import GraphDatabase, basic_auth
+from graphdatascience import GraphDataScience
+import utils as u
+import argparse
+# --- Configuration ---
+SOURCE_CSV = 'models_with_all_information.csv'
+NEO4J_URI = "bolt://localhost:7687"
+
+# --- Configuration des arguments du script ---
+parser = argparse.ArgumentParser(description="Script pour peupler une base de données Neo4j avec des données sur des modèles.")
+parser.add_argument(
+    'reset',                                     # Le nom de l'argument (positionnel, car sans tirets)
+    type=str,                                    # On attend une chaîne de caractères
+    choices=['true', 'false'],                   # L'utilisateur DOIT choisir entre 'true' et 'false'
+    help="Spécifiez 'true' pour réinitialiser la base de données, 'false' pour continuer."
+)
+
+parser.add_argument(
+    'neo4j_user',                                     # Le nom de l'argument (positionnel, car sans tirets)
+    type=str,                                    # On attend une chaîne de caractères
+    help="Nom de votre instance Neo4J"
+)
+
+parser.add_argument(
+    'neo4j_password',                                     # Le nom de l'argument (positionnel, car sans tirets)
+    type=str,                                    # On attend une chaîne de caractères
+    help="Mot de passe de votre instance Neo4J"
+)
+
+args = parser.parse_args()
+
+# Conversion de l'argument string 'true'/'false' en un vrai booléen Python True/False
+RESET = args.reset.lower() == 'true'
+NEO4J_PASSWORD = args.neo4j_password
+NEO4J_USER = args.neo4j_user 
+
+# --- Initialisation et chargement de la base Neo4j ---
+# Connexion au serveur Neo4j via le driver natif
+# C'est une bonne pratique de garder le driver et de ne pas créer la session tout de suite
+driver = GraphDatabase.driver(NEO4J_URI, auth=basic_auth(NEO4J_USER, NEO4J_PASSWORD))
+
+# Réinitialisation de la base si activé
+if RESET:
+    u.reset_database(driver) # Cette fonction supprime maintenant la DB + le fichier
+    processed_ids = set() # On part d'un set vide
+    print("Reset done")
+else:
+    # Si on ne réinitialise pas, ALORS on charge les IDs existants pour continuer
+    processed_ids = u.load_processed_ids()
+    
+# Création des index pour améliorer les performances des requêtes
+with driver.session() as session:
+    session.run("CREATE INDEX IF NOT EXISTS FOR (m:Model) ON (m.name);")
+    session.run("CREATE INDEX IF NOT EXISTS FOR (a:Author) ON (a.name);")
+    session.run("CREATE INDEX IF NOT EXISTS FOR (d:Dataset) ON (d.name);")
+    print("Indexes created.")
+
+# Insertion des données dans la base Neo4j depuis le fichier CSV en parallèle
+u.insert_parallel('models_with_all_information.csv', driver, processed_ids)
+
+# --- Finalisation ---
+# Fermer la connexion du driver à la toute fin du script
+driver.close()
+print("\nScript finished. Neo4j driver connection closed.")

application_neo4j/requirements.txt

@@ -0,0 +1,5 @@
+Flask==3.1.0
+neo4j==5.28.1
+graphdatascience==1.15.1
+pandas==2.2.3
+Jinja2 ==3.1.6

application_neo4j/static/css/style.css

@@ -0,0 +1,271 @@
+/* ===================================================================
+ *  STYLE GLOBAL & GRAPHIQUE SIGMA
+ * =================================================================== */
+
+ #sigma-container {
+  width: 100%;
+  height: 600px; /* Un peu plus de hauteur pour un meilleur confort */
+  border: 1px solid var(--bs-border-color); /* Variable Bootstrap */
+  margin-top: 1rem;
+  border-radius: var(--bs-border-radius); /* Variable Bootstrap */
+  background-color: var(--bs-light-bg-subtle); /* Fond légèrement teinté */
+}
+
+/* ===================================================================
+ *  STYLE DES CARTES "HIGHLIGHTS"
+ * =================================================================== */
+
+/* Applique une hauteur de 100% aux cartes dans les colonnes pour un alignement parfait */
+.genealogy-column .card {
+  height: 100%;
+}
+
+/* Style spécifique pour la carte centrale du modèle recherché */
+.card-searched {
+  border: 2px solid var(--bs-primary); /* Bordure primaire de Bootstrap */
+  box-shadow: 0 4px 12px rgba(0,0,0,0.1); /* Ombre plus prononcée */
+  background-color: var(--bs-light); /* Fond clair Bootstrap */
+}
+
+
+
+/* ===================================================================
+ *  STYLE DES TABLES (DATATABLES)
+ * =================================================================== */
+/* Permet au texte de revenir à la ligne naturellement */
+#descendance-table th, #descendance-table td,
+#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 */
+}
+
+/* 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 */
+}
+
+/* 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;
+}
+
+/* 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 {
+  border: 1px solid var(--bs-border-color);
+  border-radius: var(--bs-border-radius);
+  padding: 0.375rem 0.75rem;
+  margin-left: 0.5em;
+}
+
+/* Amélioration de la visibilité des flèches de tri de DataTables */
+div.dataTables_wrapper .table thead th.sorting::before,
+div.dataTables_wrapper .table thead th.sorting::after {
+    opacity: 0.4;
+    color: var(--bs-body-color);
+}
+
+div.dataTables_wrapper .table thead th.sorting_asc::after,
+div.dataTables_wrapper .table thead th.sorting_desc::before {
+    opacity: 1;
+    color: var(--bs-primary); /* Couleur primaire de Bootstrap */
+}
+
+div.dataTables_wrapper .table thead th.sorting_asc::before,
+div.dataTables_wrapper .table thead th.sorting_desc::after {
+    opacity: 0.2;
+}
+
+
+/* ===================================================================
+ *  STYLE DES COMPOSANTS D'INTERFACE
+ * =================================================================== */
+
+/* NOTE: La plupart des classes de layout comme .search-controls-container, .depth-controls
+ * ont été supprimées car la mise en page est maintenant gérée par la grille et
+ * les utilitaires Flexbox de Bootstrap directement dans le HTML (row, col, d-flex, gap-3).
+ */
+
+/* Style pour la liste de suggestions de l'autocomplétion */
+/* Le HTML utilise maintenant <ul class="list-group">, ce CSS est donc obsolète. */
+/* Si vous n'utilisez pas list-group, ce style peut être adapté. */
+#suggestions-list {
+  /* 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);
+  border-radius: var(--bs-border-radius);
+  background-color: var(--bs-light);
+}
+#suggestions-list li:hover {
+  background-color:  #94bfeb; ;
+}
+
+
+/* Légendes du graphe */
+
+.legend-item {
+  /* Cette classe est maintenant principalement utilisée pour le JS (clic) */
+  cursor: pointer;
+  transition: background-color 0.2s;
+}
+.legend-item:hover {
+  background-color: var(--bs-light-bg-subtle);
+}
+.legend-item.active {
+  font-weight: bold;
+  background-color: var(--bs-primary-bg-subtle);
+}
+
+/* Le style de la puce colorée reste le même */
+.legend-color {
+  width: 15px;
+  height: 15px;
+  border-radius: 50%;
+  margin-right: 0.75rem;
+  flex-shrink: 0;
+}
+.legend-color.edge {
+  height: 4px;
+  width: 20px;
+  border-radius: 2px;
+}
+
+
+/* ===================================================================
+ *  CONNECTEURS VISUELS POUR LA VUE GÉNÉALOGIQUE
+ *  (Cette logique est indépendante du framework et n'a besoin que de la mise à jour des couleurs)
+ * =================================================================== */
+
+.genealogy-row {
+  position: relative;
+}
+
+/* On utilise la classe de la colonne centrale pour attacher les connecteurs */
+#center-column {
+  position: static; /* Important pour que les connecteurs ne soient pas piégés dedans */
+}
+
+/* Média query pour n'afficher les connecteurs que sur les grands écrans (lg et plus) */
+@media (min-width: 992px) {
+  /* Connecteur vers l'ascendance (gauche) */
+  #center-column::before {
+      content: '';
+      position: absolute;
+      z-index: -1;
+      top: 100px; /* Ajustez cette hauteur pour aligner avec vos cartes */
+      
+      left: 20%;  /* Commence à 20% de la largeur */
+      right: 60%; /* S'arrête à 40% de la largeur */
+
+      height: 3px;
+      background-color: var(--bs-secondary-border-subtle); /* Couleur Bootstrap subtile */
+      border-radius: 3px;
+  }
+
+  /* Connecteur vers la descendance (droite) */
+  #center-column::after {
+      content: '';
+      position: absolute;
+      z-index: -1;
+      top: 100px; /* Même hauteur */
+      
+      left: 60%;
+      right: 20%;
+      
+      height: 3px;
+      background-color: var(--bs-secondary-border-subtle);
+      border-radius: 3px;
+  }
+}
+
+/* Style de base pour la carte interactive */
+.card-interactive {
+  /* Ajoute une transition douce pour tous les changements de style (couleur, ombre...) */
+  transition: background-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out;
+}
+
+
+.form-check-input:checked {
+  background-color: #6a11cb; /* Bleu primaire par défaut */
+  border-color:#6a11cb;     /* Bleu primaire par défaut */
+}
+
+/* Change la couleur de fond des cases à cocher lorsqu'elles sont cochées */
+.btn {
+  background-color: #6a11cb; 
+  border-color:#6a11cb;    
+}
+
+.stretched-link{
+color: #6a11cb; 
+}
+/* Style appliqué LORSQUE LA SOURIS SURVOLE la carte */
+.card-interactive:hover {
+  cursor: pointer; /* Le curseur change en main, indiquant un clic possible */
+  background-color: #94bfeb; /* Une couleur de fond légèrement grise (standard Bootstrap) */
+  
+  /* Optionnel : ajoute une ombre subtile pour faire "ressortir" la carte */
+  box-shadow: 0 4px 8px rgba(0,0,0,0.1); 
+}
+
+.card-recherche p:not(.text-muted) {
+  color: #212529 !important; /* Couleur noire standard de Bootstrap */
+
+}
+
+.card-recherche{
+  border-color:#6a11cb;
+}
+
+.card-recherche-header{
+  border-color:#6a11cb;
+  background-color: #6a11cb; 
+
+}
+.on-top {
+  position: relative;
+  z-index: 2; /* Doit être supérieur à 1 (le z-index du stretched-link) */
+}
+
+.beta {
+  background-color: #6a11cb;
+}
+
+.alpha {
+  background-color: #b476f7;
+  color : #000000;
+}
+
+main {
+  margin-bottom: 5rem; /* ajuste la valeur selon tes besoins */
+}
+
+#floating-legend .legend-color { width: 1em; height: 1em; display: inline-block; border-radius: 2px; }
+#floating-legend .legend-color.edge { border-radius: 0; height: 0.25em; transform: translateY(-0.35em); }
+
+.btn-modern {
+  min-width: 200px;
+  padding: 14px 24px;
+  font-weight: bold;
+  color: white;
+  background: linear-gradient(135deg, #6a11cb, #f8a5f8);
+  border: none;
+  border-radius: 50px;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  box-shadow: 0 3px 8px rgba(0,0,0,0.15);
+  text-align: center;
+  text-decoration: none;
+}
+
+.btn-modern:hover {
+  background: linear-gradient(135deg, #5a0fbf, #1d63e1);
+  transform: translateY(-3px);
+}

application_neo4j/static/graph_export.html

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Export Graphe Sigma</title>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz" crossorigin="anonymous"></script>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css">
+<script src="https://unpkg.com/graphology@0.25.1/dist/graphology.umd.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/sigma.js/2.4.0/sigma.min.js"></script>
+<style>
+  body { margin:0; font-family: Arial, sans-serif; }
+  #sigma-container { width: 100%; height: 70vh; border: 1px solid #ccc; border-radius: 5px; margin-bottom: 1rem; }
+  .legend-card { margin-bottom: 1rem; }
+  .legend-card .card-body { max-height: 40vh; overflow-y: auto; }
+  .legend-color { display:inline-block; width:20px; height:20px; border-radius:3px; }
+</style>
+</head>
+<body>
+<div class="container-fluid p-3">
+  <div class="row mb-2">
+    <div class="col">
+      <h3 class="text-center" id="node_name"></h3>
+    </div>
+  </div>
+
+  <div class="row">
+    <!-- Colonne des légendes -->
+    <div class="col-lg-3">
+      <div class="card legend-card">
+        <div class="card-header"><strong>Légende - Nœuds</strong></div>
+        <div class="card-body" id="legend-nodes"></div>
+      </div>
+      <div class="card legend-card">
+        <div class="card-header"><strong>Légende - Relations</strong></div>
+        <div class="card-body" id="legend-edges"></div>
+      </div>
+    </div>
+
+    <!-- Colonne du graphe -->
+    <div class="col-lg-9">
+      <div id="sigma-container"></div>
+    </div>
+  </div>
+</div>
+<script>
+  // Ces variables seront remplacées dynamiquement
+  const GRAPH_DATA = `{{GRAPH_DATA}}`;
+  const graphData = JSON.parse(GRAPH_DATA);
+  const LEGEND_HTML_NODES = `{{LEGEND_HTML_NODES}}`;
+  const LEGEND_HTML_EDGES = `{{LEGEND_HTML_EDGES}}`;
+  const NODE_NAME = `{{NODE_NAME}}`;
+
+  // On injecte les légendes
+  document.getElementById("legend-nodes").innerHTML = LEGEND_HTML_NODES;
+  document.getElementById("legend-edges").innerHTML = LEGEND_HTML_EDGES;
+  document.getElementById("node_name").textContent = NODE_NAME ? ("Composante connexe du noeud : " + NODE_NAME) : "";
+  // Reconstruction du graphe Sigma
+  const Graph = window.graphology.Graph;
+  const graph = new Graph();
+
+  graphData.nodes.forEach(n => graph.addNode(n.id, n));
+  graphData.edges.forEach(e => graph.addEdge(e.source, e.target, e));
+
+  new Sigma(graph, document.getElementById("sigma-container"));
+</script>
+</body>
+</html>

application_neo4j/static/js/script.js

@@ -0,0 +1,351 @@
+
+/**
+ * Fonction principale pour créer et afficher le graphe Sigma.
+ * Appelée une seule fois lorsque l'utilisateur clique sur "Voir l'arbre".
+ * @param {object} graphData - Les données des nœuds et arêtes.
+ * @returns {Sigma} L'instance du renderer Sigma.
+ */
+function initializeSigmaGraph(graphData) {
+    const container = document.getElementById("sigma-container");
+    if (!container) {
+        console.error("Conteneur Sigma non trouvé. Initialisation annulée.");
+        return null;
+    }
+    
+    console.log("Initialisation du graphe Sigma...");
+    
+    const Graph = window.graphology.Graph;
+    const graph = new Graph();
+    const TYPE_COLORS = {
+        personne: '#007bff',
+        organisation: '#007',
+        Modèle: '#b1b1b1',
+        Dataset: '#ffc107',
+        Author: '#007bff',
+        Model: '#b1b1b1',
+        Unknown: '#999',
+        Défaut: '#999'
+      };
+    const addedNodeIds = new Set();
+    graphData.nodes.forEach(node => {
+        if (addedNodeIds.has(node.id)) return;
+        const rawSize = Math.log10(node.downloads || node.followers || 1) * 2 + (depth === 0 ? 5 : 0);
+        graph.addNode(node.id, {
+            id: node.id, label: node.id, size: Math.max(5, rawSize), color: TYPE_COLORS[node.label] || '#999',
+            dataCat: node.label, x: Math.random(), y: Math.random(),
+            followers: node.followers, downloads: node.downloads, createdAt: node.createdAt,
+            createdAt_dataset: node.createdAt_dataset, task: node.task, bfsDepth: node.distance
+        });
+        addedNodeIds.add(node.id);
+    });
+       
+    graphData.edges.forEach(edge => {
+        console.log(edge.relation);
+        const edgeColor = edgeInfos[edge.relation]["color"] || "#ccc";
+        
+        if (graph.hasNode(edge.source) && graph.hasNode(edge.target)) {
+          graph.addEdge(edge.source, edge.target, {
+            label: edge.relation || '',
+            color: edgeColor || '#ccc',
+            size: 3,
+            type: 'arrow'
+          });
+        } else {
+          console.warn(`Arête ignorée: ${edge.source} -> ${edge.target} (nœuds manquants)`);
+        }
+      });
+    
+      graphologyLibrary.layoutForceAtlas2.assign(graph, {
+        iterations: 100,
+        settings: {
+            gravity: 0.01,        // attraction faible vers le centre
+            scalingRatio: 10,     // augmente fortement la répulsion
+            slowDown: 1,          // vitesse normale
+            strongGravityMode: false,
+            barnesHutOptimize: true,
+            barnesHutTheta: 0.5 // précision de l’approximation
+        }
+      });
+    const renderer = new Sigma(graph, container);
+    // Juste après l'initialisation du renderer
+    const state = {
+        hoveredNode: null,
+        hoveredNeighbors: null
+    };
+    renderer.setSetting("nodeReducer", (node, data) => {
+        const res = { ...data };
+      
+        if (state.hoveredNode && state.hoveredPredecessors) {
+          // Garder seulement le nœud survolé et ses prédécesseurs visibles en couleur
+          if (!state.hoveredPredecessors.has(node)) {
+            res.color = "#f1f1f1";  // gris
+            res.label = "";         // masquer le label
+          }
+        }
+      
+        return res;
+      });
+      
+      renderer.setSetting("edgeReducer", (edge, data) => {
+        const res = { ...data };
+      
+        if (state.hoveredNode && state.hoveredPredecessors) {
+          const [source, target] = graph.extremities(edge);
+          // Montrer seulement les arêtes dans le chemin des prédécesseurs
+          if (!state.hoveredPredecessors.has(source) || !state.hoveredPredecessors.has(target)) {
+            res.hidden = true;
+          }
+        }
+      
+        return res;
+      });
+      
+    buildEdgeLegend();
+
+    // Mettre en place les interactions
+    const filtersContainer = document.getElementById('graph-filters-container');
+    if (filtersContainer) {
+        filtersContainer.addEventListener('change', (event) => {
+            if (event.target.type === 'checkbox') {
+                updateGraphVisibility(graph, renderer);
+            }
+        });
+    }
+    
+    renderer.on('clickNode', ({ node }) => {
+        showNodeInfo(graph.getNodeAttributes(node));
+    });
+    // Quand on survole un nœud
+    renderer.on("enterNode", ({ node }) => {
+    state.hoveredNode = node;
+    state.hoveredPredecessors = getAllPredecessors(graph, node);
+    renderer.refresh({ skipIndexation: true });
+    });
+
+    // Quand on sort du nœud
+    renderer.on("leaveNode", () => {
+    state.hoveredNode = null;
+    state.hoveredPredecessors = null;
+    renderer.refresh({ skipIndexation: true });
+    });
+
+    setupTableRowClickListeners(renderer, graph);
+
+    return renderer;
+}
+
+/**
+ * Met en place l'écouteur de clic sur les lignes des tableaux pour interagir avec le graphe.
+ * @param {Sigma} renderer - L'instance du renderer Sigma.
+ * @param {Graph} graph - L'instance du graphe Graphology.
+ */
+function setupTableRowClickListeners(renderer, graph) {
+    $('#descendance-table tbody, #ascendance-table tbody').on('click', 'tr', function() {
+        const nodeId = $(this).attr('data-node-id');
+        if (!nodeId || !renderer || !graph.hasNode(nodeId)) return;
+        // Effet de "highlight" temporaire sur le nœud dans le graphe
+        const originalSize = graph.getNodeAttribute(nodeId, "size");
+        const highlightSize = originalSize * 1.6;
+
+        graph.setNodeAttribute(nodeId, "size", highlightSize);
+        renderer.refresh(); // Nécessaire pour forcer le rendu
+
+        setTimeout(() => {
+            graph.setNodeAttribute(nodeId, "size", originalSize);
+            renderer.refresh();
+        }, 1000);
+        // Supprime la classe active des autres lignes
+        $('#descendance-table tbody tr, #ascendance-table tbody tr').removeClass('active');
+        $(this).addClass('active');
+    
+        showNodeInfo(graph.getNodeAttributes(nodeId));
+       
+    
+        const pos = renderer.getNodeDisplayData(nodeId);
+        if (pos) {
+            renderer.getCamera().animate({ x: pos.x, y: pos.y, ratio: 0.2 }, { duration: 600 });
+        }
+    });
+    
+}
+
+// ===================================================================
+// POINT D'ENTRÉE PRINCIPAL - EXÉCUTÉ AU CHARGEMENT DE LA PAGE
+// ===================================================================
+document.addEventListener("DOMContentLoaded", () => {
+    
+        // --- ÉTAPE 1: LECTURE DES DONNÉES ET INITIALISATION DES TABLEAUX ---
+    
+        const sigmaContainer = document.getElementById("sigma-container");
+        let graphData;
+    
+        if (sigmaContainer && sigmaContainer.dataset.graph) {
+            try {
+                graphData = JSON.parse(sigmaContainer.dataset.graph);
+            } catch (e) {
+                console.error("Erreur d'analyse JSON:", e);
+                return;
+            }
+    
+            const common_dt_options = {
+                "language": { "url": "https://cdn.datatables.net/plug-ins/1.13.4/i18n/fr-FR.json" },
+                "pageLength": 10,
+                "responsive": true,"scrollX": true , "scrollY":true,
+                "columnDefs": [
+                {
+                    // Appliquer notre plugin 'numeric-string' aux colonnes cibles
+                    "type": "numeric-string", 
+                    "targets": [2, 4, 6, 7, 8, 9] // Indices des colonnes: Downloads, Likes, Distance, etc.
+                }
+            ]
+                // "searching" est activé par défaut, on peut le customiser
+            };
+            const tableDescendance = $('#descendance-table').DataTable(common_dt_options);
+            const tableAscendance = $('#ascendance-table').DataTable(common_dt_options);
+    
+            // Gérer la barre de recherche personnalisée
+            const customSearch = document.getElementById('custom-table-search');
+            if (customSearch) {
+                customSearch.addEventListener('keyup', function() {
+                    const query = this.value;
+                    tableDescendance.search(query).draw();
+                    tableAscendance.search(query).draw();
+                });
+            }
+    
+            tableAscendance.clear();
+            tableDescendance.clear();
+    
+            graphData.nodes.forEach(node => {
+                // Filtrer pour n'inclure que les modèles dans ces tableaux
+                if (node.label !== 'Modèle' && node.label !== 'Model') return;
+                const distance = node.distance;
+                if (distance === 0) return;
+    
+                // Construction de la ligne avec les nouvelles données
+                const rowData = [
+                    node.id || "N/A",
+                    node.author || "Inconnu",
+                    // La conversion en string via la condition est parfaite ici
+                    String(node.downloads ?? "Inconnu"),
+                    node.task || "Inconnue",
+                    String(node.likes ?? "0"),
+                    String(node.createdAt ?? "Inconnue"),
+                    node.dataset || "Inconnu",
+                    node.license || "Inconnue",
+                    distance > 0 ? `+${distance}` : String(distance ?? 0),
+                    String(node.ascendantsCount ?? "0"),
+                    String(node.descendantsCount ?? "0"),
+                    String(node.citationCount ?? "0")
+                ];
+                
+                const tableToUpdate = distance > 0 ? tableDescendance : tableAscendance;
+                tableToUpdate.row.add(rowData).node().setAttribute("data-node-id", node.id);
+            });
+    
+            tableAscendance.draw();
+            tableDescendance.draw();
+
+        }
+    
+    // --- ÉTAPE 2: GESTION DES INTERACTIONS DE L'UTILISATEUR ---
+
+    // Logique du bouton "Voir l'arbre généalogique"
+    const showGraphBtn = document.getElementById('show-graph-btn');
+    const graphSection = document.getElementById('genealogy-graph-section');
+    let sigmaInstance = null; // Garde en mémoire l'instance du graphe
+
+    if (showGraphBtn && graphSection && graphData) {
+        showGraphBtn.addEventListener('click', () => {
+            if (graphSection.style.display === 'none') {
+                graphSection.style.display = 'block';
+                
+                if (!sigmaInstance) {
+                    sigmaInstance = initializeSigmaGraph(graphData);
+                }
+                graphSection.scrollIntoView({ behavior: 'smooth', block: 'start' });
+            } else {
+                graphSection.style.display = 'none';
+                document.getElementById("node-info-card").style.display = "none";
+            }
+        });
+    }
+
+    const input = document.getElementById('search-input');
+    const suggestionsList = document.getElementById('suggestions-list');
+    const modelCheckbox = document.getElementById('filter-model');
+    const datasetCheckbox = document.getElementById('filter-dataset');
+
+    // Cette fonction sera notre point central pour l'autocomplétion
+    function fetchAutocomplete() {
+        const query = input.value.trim();
+
+        // 1. Déterminer quel filtre est actif
+        let activeFilter = '';
+        if (modelCheckbox.checked) {
+            activeFilter = 'Model';
+        } else if (datasetCheckbox.checked) {
+            activeFilter = 'Dataset';
+        }
+
+        // Si le champ est vide, on cache les suggestions
+        if (query.length < 2) {
+            suggestionsList.style.display = 'none';
+            return;
+        }
+
+        // 2. Construire l'URL avec le filtre
+        // On commence avec la requête de base
+        let fetchUrl = `/autocomplete?q=${encodeURIComponent(query)}`;
+        // On ajoute le paramètre 'filter' SEULEMENT s'il y en a un d'actif
+        if (activeFilter) {
+            fetchUrl += `&filter=${activeFilter}`;
+        }
+        
+        // 3. Lancer la requête fetch avec la bonne URL
+        fetch(fetchUrl)
+            .then(response => response.json())
+            .then(data => {
+                suggestionsList.innerHTML = '';
+                if (data.length > 0) {
+                    data.forEach(item => {
+                        const li = document.createElement('li');
+                        li.textContent = item.name;
+                        li.addEventListener('click', () => {
+                            input.value = item.name;
+                            suggestionsList.style.display = 'none';
+                        });
+                        suggestionsList.appendChild(li);
+                    });
+                    suggestionsList.style.display = 'block';
+                } else {
+                    suggestionsList.style.display = 'none';
+                }
+            });
+    }
+
+    // On écoute les événements sur le champ de saisie
+    input.addEventListener('input', fetchAutocomplete);
+
+    // AMÉLIORATION : On écoute aussi les changements sur les checkboxes !
+    // Si l'utilisateur change de filtre, on relance immédiatement une recherche.
+    modelCheckbox.addEventListener('change', fetchAutocomplete);
+    datasetCheckbox.addEventListener('change', fetchAutocomplete);
+    
+    // Logique pour cacher les suggestions si on clique ailleurs (inchangée)
+    document.addEventListener('click', (e) => {
+        if (!input.contains(e.target) && !suggestionsList.contains(e.target)) {
+            suggestionsList.style.display = 'none';
+        }
+    });
+    
+
+    // Logique de la checkbox de profondeur (inchangée)
+    const checkbox = document.getElementById('depth-unlimited');
+    if (checkbox) {
+        const depthInput = document.getElementById('depth');
+        function toggleDepthInput() { if(depthInput) depthInput.disabled = checkbox.checked; }
+        checkbox.addEventListener('change', toggleDepthInput);
+        toggleDepthInput();
+    }
+});

application_neo4j/static/js/script_dataset.js

@@ -0,0 +1,357 @@
+const edgeInfos_dataset = {
+    "Fait partie de cette organisation": {
+      color: "#a05195",name : "Fait partie de cette organisation",
+      tooltip: "Cette personne est membre de cette organisation"
+    },
+    "A publié": {
+      color: "#003f5c",name : "A publié",
+      tooltip: "Un auteur (personne ou organistaion) a publié un modèle"
+    },
+    "A été utilisé dans ce modèle": {
+      color: "#f50f0f",name : "A été utilisé dans ce modèle",
+      tooltip: "Ce dataset a servi pour l'entraînement de ce modèle"
+
+    },
+    "A généré": {
+      color: "#8f7340",name : "A permis de générer",
+      tooltip: "Le modèle source a été téléchargé et modifié afin de créer le modèle cible (type de transformation inconnu)"
+
+    },
+    "finetune": {
+      color: "#d9c00d",name : "Finetune",
+      tooltip: "Ajustement : le modèle source est ré-entraîné sur un jeu de données spécifique afin de pouvoir être performant pour une tâche précise."
+
+    },
+    "adapter": {
+      color: "#9af17c",name : "Adapter",
+
+      tooltip: "Adaptation : méthode d’ajustement qui peut être utilisée avec peu de ressources de calcul."
+    },
+    "quantized": {
+      color: "#1bc3c6",name : "Quantized",
+      tooltip:"Quantisation : la précision des poids du modèle source est réduite afin de diminuer son empreinte en mémoire."
+    },
+    "merge": {
+      color: "#e407e4",name : "Merge",
+      tooltip:"Fusion : méthode visant à mélanger des couches de différents modèles pour améliorer leur performance."
+    }
+  };
+
+
+  function buildEdgeLegend() {
+    const legendContainer = document.getElementById("legend-edges");
+    legendContainer.innerHTML = ""; // reset
+  
+    Object.entries(edgeInfos_dataset).forEach(([relation, {color, name,tooltip}]) => {
+      const li = document.createElement("li");
+      li.className = "list-group-item d-flex align-items-center";
+      
+      // ajout Bootstrap tooltip
+      li.setAttribute("data-bs-toggle", "tooltip");
+      li.setAttribute("data-bs-placement", "top");
+      li.setAttribute("data-bs-html", "true");
+      li.setAttribute("title", tooltip);
+  
+      const span = document.createElement("span");
+      span.className = "legend-color edge me-2";
+      span.style.backgroundColor = color;
+  
+      li.appendChild(span);
+      li.appendChild(document.createTextNode(name));
+  
+      legendContainer.appendChild(li);
+    });
+  
+    // nécessaire pour activer les tooltips Bootstrap dynamiques
+    const tooltipTriggerList = [].slice.call(legendContainer.querySelectorAll('[data-bs-toggle="tooltip"]'))
+    tooltipTriggerList.map(el => new bootstrap.Tooltip(el));
+  }
+
+/**
+ * Fonction principale pour créer et afficher le graphe Sigma.
+ * Appelée une seule fois lorsque l'utilisateur clique sur "Voir l'arbre".
+ * @param {object} graphData - Les données des nœuds et arêtes.
+ * @returns {Sigma} L'instance du renderer Sigma.
+ */
+function initializeSigmaGraph(graphData) {
+    const container = document.getElementById("sigma-container");
+    if (!container) {
+        console.error("Conteneur Sigma non trouvé. Initialisation annulée.");
+        return null;
+    }
+    
+    console.log("Initialisation du graphe Sigma...");
+    
+    const Graph = window.graphology.Graph;
+    const graph = new Graph();
+    const TYPE_COLORS = {
+        personne: '#007bff',
+        organisation: '#007',
+        Modèle: '#b1b1b1',
+        Dataset: '#ffc107',
+        Author: '#007bff',
+        Model: '#b1b1b1',
+        Unknown: '#999',
+        Défaut: '#999'
+      };
+    const addedNodeIds = new Set();
+    graphData.nodes.forEach(node => {
+        if (addedNodeIds.has(node.id)) return;
+        const rawSize = Math.log10(node.downloads || node.followers || 1) * 2 + (depth === 0 ? 5 : 0);
+        graph.addNode(node.id, {
+            id: node.id, label: node.id, size: Math.max(5, rawSize), color: TYPE_COLORS[node.label] || '#999',
+            dataCat: node.label, x: Math.random(), y: Math.random(),
+            followers: node.followers, downloads: node.downloads, createdAt: node.createdAt,
+            createdAt_dataset: node.createdAt_dataset, task: node.task, bfsDepth: node.distance
+        });
+        addedNodeIds.add(node.id);
+    });
+       
+    graphData.edges.forEach(edge => {
+        console.log(edge.relation);
+        const edgeColor = edgeInfos_dataset[edge.relation]["color"] || "#ccc";
+        
+        if (graph.hasNode(edge.source) && graph.hasNode(edge.target)) {
+          graph.addEdge(edge.source, edge.target, {
+            label: edge.relation || '',
+            color: edgeColor || '#ccc',
+            size: 3,
+            type: 'arrow'
+          });
+        } else {
+          console.warn(`Arête ignorée: ${edge.source} -> ${edge.target} (nœuds manquants)`);
+        }
+      });
+    
+    graphologyLibrary.layoutForceAtlas2.assign(graph, { iterations: 100 });
+    const renderer = new Sigma(graph, container);
+    buildEdgeLegend();
+
+    // Mettre en place les interactions
+    const filtersContainer = document.getElementById('graph-filters-container');
+    if (filtersContainer) {
+        filtersContainer.addEventListener('change', (event) => {
+            if (event.target.type === 'checkbox') {
+                updateGraphVisibility(graph, renderer);
+            }
+        });
+    }
+    
+    renderer.on('clickNode', ({ node }) => {
+        showNodeInfo(graph.getNodeAttributes(node));
+    });
+
+    setupTableRowClickListeners(renderer, graph);
+
+    return renderer;
+}
+
+/**
+ * Met en place l'écouteur de clic sur les lignes des tableaux pour interagir avec le graphe.
+ * @param {Sigma} renderer - L'instance du renderer Sigma.
+ * @param {Graph} graph - L'instance du graphe Graphology.
+ */
+function setupTableRowClickListeners(renderer, graph) {
+    $('#train-table tbody').on('click', 'tr', function() {
+        const nodeId = $(this).attr('data-node-id');
+        if (!nodeId || !renderer || !graph.hasNode(nodeId)) return;
+        // Effet de "highlight" temporaire sur le nœud dans le graphe
+        const originalSize = graph.getNodeAttribute(nodeId, "size");
+        const highlightSize = originalSize * 1.6;
+
+        graph.setNodeAttribute(nodeId, "size", highlightSize);
+        renderer.refresh(); // Nécessaire pour forcer le rendu
+
+        setTimeout(() => {
+            graph.setNodeAttribute(nodeId, "size", originalSize);
+            renderer.refresh();
+        }, 1000);
+        // Supprime la classe active des autres lignes
+        $('#train-table tbody tr').removeClass('active');
+        $(this).addClass('active');
+    
+        showNodeInfo(graph.getNodeAttributes(nodeId));
+       
+    
+        const pos = renderer.getNodeDisplayData(nodeId);
+        if (pos) {
+            renderer.getCamera().animate({ x: pos.x, y: pos.y, ratio: 0.2 }, { duration: 600 });
+        }
+    });
+    
+}
+
+// ===================================================================
+// POINT D'ENTRÉE PRINCIPAL - EXÉCUTÉ AU CHARGEMENT DE LA PAGE
+// ===================================================================
+document.addEventListener("DOMContentLoaded", () => {
+    
+        // --- ÉTAPE 1: LECTURE DES DONNÉES ET INITIALISATION DES TABLEAUX ---
+    
+        const sigmaContainer = document.getElementById("sigma-container");
+        let graphData;
+    
+        if (sigmaContainer && sigmaContainer.dataset.graph) {
+            try {
+                graphData = JSON.parse(sigmaContainer.dataset.graph);
+            } catch (e) {
+                console.error("Erreur d'analyse JSON:", e);
+                return;
+            }
+    
+            const common_dt_options = {
+                "language": { "url": "https://cdn.datatables.net/plug-ins/1.13.4/i18n/fr-FR.json" },
+                "pageLength": 10,
+                "responsive": true,"scrollX": true , "scrollY":true,
+                "columnDefs": [
+                {
+                    // Appliquer notre plugin 'numeric-string' aux colonnes cibles
+                    "type": "numeric-string", 
+                    "targets": [2, 4, 6, 7, 8, 9] // Indices des colonnes: Downloads, Likes, Distance, etc.
+                }
+            ]
+                // "searching" est activé par défaut, on peut le customiser
+            };
+            const tableTrain = $('#train-table').DataTable(common_dt_options);
+    
+            // Gérer la barre de recherche personnalisée
+            const customSearch = document.getElementById('custom-table-search');
+            if (customSearch) {
+                customSearch.addEventListener('keyup', function() {
+                    const query = this.value;
+                    tableTrain.search(query).draw();
+                });
+            }
+    
+            tableTrain.clear();
+            console.log("GraphData nodes:", graphData.nodes);
+
+            graphData.nodes.forEach(node => {
+                // Filtrer pour n'inclure que les modèles dans ces tableaux
+                if (node.label !== 'Modèle' && node.label !== 'Model') return;
+                const distance = node.distance;
+    
+                // Construction de la ligne avec les nouvelles données
+                const rowData = [
+                    node.id || "N/A",
+                    node.author || "Inconnu",
+                    // La conversion en string via la condition est parfaite ici
+                    String(node.downloads ?? "Inconnu"),
+                    node.task || "Inconnue",
+                    String(node.likes ?? "0"),
+                    String(node.createdAt ?? "Inconnue"),
+                    node.dataset || "Inconnu",
+                    node.license || "Inconnue",
+                    String(node.ascendantsCount ?? "0"),
+                    String(node.descendantsCount ?? "0"),
+                    String(node.citationCount ?? "0")
+                ];
+                
+                tableTrain.row.add(rowData).node().setAttribute("data-node-id", node.id);
+            });
+    
+            tableTrain.draw();
+
+        }
+    
+    // --- ÉTAPE 2: GESTION DES INTERACTIONS DE L'UTILISATEUR ---
+
+    // Logique du bouton "Voir l'arbre généalogique"
+    const showGraphBtn = document.getElementById('show-graph-btn');
+    const graphSection = document.getElementById('genealogy-graph-section');
+    let sigmaInstance = null; // Garde en mémoire l'instance du graphe
+
+    if (showGraphBtn && graphSection && graphData) {
+        showGraphBtn.addEventListener('click', () => {
+            if (graphSection.style.display === 'none') {
+                graphSection.style.display = 'block';
+                
+                if (!sigmaInstance) {
+                    sigmaInstance = initializeSigmaGraph(graphData);
+                }
+                graphSection.scrollIntoView({ behavior: 'smooth', block: 'start' });
+            } else {
+                graphSection.style.display = 'none';
+                document.getElementById("node-info-card").style.display = "none";
+            }
+        });
+    }
+
+    const input = document.getElementById('search-input');
+    const suggestionsList = document.getElementById('suggestions-list');
+    const modelCheckbox = document.getElementById('filter-model');
+    const datasetCheckbox = document.getElementById('filter-dataset');
+
+    // Cette fonction sera notre point central pour l'autocomplétion
+    function fetchAutocomplete() {
+        const query = input.value.trim();
+
+        // 1. Déterminer quel filtre est actif
+        let activeFilter = '';
+        if (modelCheckbox.checked) {
+            activeFilter = 'Model';
+        } else if (datasetCheckbox.checked) {
+            activeFilter = 'Dataset';
+        }
+
+        // Si le champ est vide, on cache les suggestions
+        if (query.length < 2) {
+            suggestionsList.style.display = 'none';
+            return;
+        }
+
+        // 2. Construire l'URL avec le filtre
+        // On commence avec la requête de base
+        let fetchUrl = `/autocomplete?q=${encodeURIComponent(query)}`;
+        // On ajoute le paramètre 'filter' SEULEMENT s'il y en a un d'actif
+        if (activeFilter) {
+            fetchUrl += `&filter=${activeFilter}`;
+        }
+        
+        // 3. Lancer la requête fetch avec la bonne URL
+        fetch(fetchUrl)
+            .then(response => response.json())
+            .then(data => {
+                suggestionsList.innerHTML = '';
+                if (data.length > 0) {
+                    data.forEach(item => {
+                        const li = document.createElement('li');
+                        li.textContent = item.name;
+                        li.addEventListener('click', () => {
+                            input.value = item.name;
+                            suggestionsList.style.display = 'none';
+                        });
+                        suggestionsList.appendChild(li);
+                    });
+                    suggestionsList.style.display = 'block';
+                } else {
+                    suggestionsList.style.display = 'none';
+                }
+            });
+    }
+
+    // On écoute les événements sur le champ de saisie
+    input.addEventListener('input', fetchAutocomplete);
+
+    // AMÉLIORATION : On écoute aussi les changements sur les checkboxes !
+    // Si l'utilisateur change de filtre, on relance immédiatement une recherche.
+    modelCheckbox.addEventListener('change', fetchAutocomplete);
+    datasetCheckbox.addEventListener('change', fetchAutocomplete);
+    
+    // Logique pour cacher les suggestions si on clique ailleurs (inchangée)
+    document.addEventListener('click', (e) => {
+        if (!input.contains(e.target) && !suggestionsList.contains(e.target)) {
+            suggestionsList.style.display = 'none';
+        }
+    });
+    
+
+    // Logique de la checkbox de profondeur (inchangée)
+    const checkbox = document.getElementById('depth-unlimited');
+    if (checkbox) {
+        const depthInput = document.getElementById('depth');
+        function toggleDepthInput() { if(depthInput) depthInput.disabled = checkbox.checked; }
+        checkbox.addEventListener('change', toggleDepthInput);
+        toggleDepthInput();
+    }
+});

application_neo4j/static/js/script_expert.js

@@ -0,0 +1,377 @@
+
+/**
+ * Construit les cases à cocher pour les filtres d'arêtes dynamiquement.
+ */
+function buildEdgeFilters() {
+    const container = document.getElementById('edge-filters-container');
+    if (!container) return;
+    container.innerHTML = '';
+    Object.entries(edgeInfos).forEach(([key, { name }]) => {
+        const div = document.createElement('div');
+        div.className = 'form-check form-switch';
+        const input = document.createElement('input');
+        input.className = 'form-check-input';
+        input.type = 'checkbox';
+        input.id = `filter-edge-${key.replace(/\s+/g, '-')}`;
+        input.value = key;
+        input.checked = true;
+        const label = document.createElement('label');
+        label.className = 'form-check-label';
+        label.htmlFor = input.id;
+        label.textContent = name;
+        div.appendChild(input);
+        div.appendChild(label);
+        container.appendChild(div);
+    });
+}
+
+function populateGraphModelsTable(graphData, table) {
+    table.clear();
+    graphData.nodes.forEach(node => {
+        // Filtrer pour n'inclure que les modèles dans ces tableaux
+        if (node.label !== 'Modèle' && node.label !== 'Model') return;
+        const distance = node.distance;
+        
+
+        // Construction de la ligne avec les nouvelles données
+        const rowData = [
+            node.id || "N/A",
+            node.author || "Inconnu",
+            // La conversion en string via la condition est parfaite ici
+            String(node.downloads ?? "Inconnu"),
+            node.task || "Inconnue",
+            String(node.likes ?? "0"),
+            String(node.createdAt ?? "Inconnue"),
+            node.dataset || "Inconnu",
+            node.license || "Inconnue",
+            distance > 0 ? `+${distance}` : String(distance ?? 0),
+            String(node.ascendantsCount ?? "0"),
+            String(node.descendantsCount ?? "0"),
+            String(node.citationCount ?? "0")
+        ];
+            table.row.add(rowData);
+    });
+    table.draw();
+}
+
+/**
+ * Met à jour la visibilité des nœuds et des arêtes dans le graphe.
+ * Cache les nœuds dont les liens sont tous cachés et met à jour la table des modèles.
+ * @param {Graph} graph - L'instance du graphe Graphology.
+ * @param {Sigma} renderer - L'instance du renderer Sigma.
+ * @param {DataTable} table - L'instance de la DataTable des modèles à mettre à jour.
+ */
+function updateGraphVisibility(graphData,graph, renderer, table) {
+    const filtersContainer = document.getElementById('graph-filters-container');
+    if (!filtersContainer) return;
+
+    const visibleNodeTypes = new Set();
+    filtersContainer.querySelectorAll('input[id^="filter-node-"]:checked').forEach(c => {
+        visibleNodeTypes.add(c.value);
+        if (c.value === 'Modèle') visibleNodeTypes.add('Model');
+       // if (c.value === 'personne') visibleNodeTypes.add('Author');
+    });
+
+    const visibleEdgeTypes = new Set();
+    filtersContainer.querySelectorAll('input[id^="filter-edge-"]:checked').forEach(c => visibleEdgeTypes.add(c.value));
+    
+    graph.forEachNode((node, attr) => graph.setNodeAttribute(node, 'hidden', !visibleNodeTypes.has(attr.dataCat)));
+    graph.forEachEdge((edge, attr, source, target) => {
+        const sourceHidden = graph.getNodeAttribute(source, 'hidden');
+        const targetHidden = graph.getNodeAttribute(target, 'hidden');
+        const typeHidden = !visibleEdgeTypes.has(attr.label);
+        graph.setEdgeAttribute(edge, 'hidden', sourceHidden || targetHidden || typeHidden);
+    });
+
+    // On repeuple la table en se basant sur la nouvelle visibilité des nœuds
+    populateGraphModelsTable(graphData, table);
+
+    renderer.refresh();
+}
+/**
+ * Met en place l'écouteur de clic sur les lignes des tableaux pour interagir avec le graphe.
+ * @param {Sigma} renderer - L'instance du renderer Sigma.
+ * @param {Graph} graph - L'instance du graphe Graphology.
+ */
+function setupTableRowClickListeners(renderer, graph) {
+    $('#graph-models-table tbody').on('click', 'tr', function() {
+        const nodeId = $(this).attr('data-node-id');
+        if (!nodeId || !renderer || !graph.hasNode(nodeId)) return;
+        // Effet de "highlight" temporaire sur le nœud dans le graphe
+        const originalSize = graph.getNodeAttribute(nodeId, "size");
+        const highlightSize = originalSize * 1.6;
+
+        graph.setNodeAttribute(nodeId, "size", highlightSize);
+        renderer.refresh(); // Nécessaire pour forcer le rendu
+
+        setTimeout(() => {
+            graph.setNodeAttribute(nodeId, "size", originalSize);
+            renderer.refresh();
+        }, 1000);
+        // Supprime la classe active des autres lignes
+        $('#graph-models-table tbody tr').removeClass('active');
+        $(this).addClass('active');
+    
+        showNodeInfo(graph.getNodeAttributes(nodeId));
+       
+    
+        const pos = renderer.getNodeDisplayData(nodeId);
+        if (pos) {
+            renderer.getCamera().animate({ x: pos.x, y: pos.y, ratio: 0.2 }, { duration: 600 });
+        }
+    });
+    
+}
+
+/**
+ * Fonction principale pour créer et afficher le graphe Sigma.
+ * Appelée une seule fois lorsque l'utilisateur clique sur "Voir l'arbre".
+ * @param {object} graphData - Les données des nœuds et arêtes.
+ * @returns {Sigma} L'instance du renderer Sigma.
+ */
+function initializeSigmaGraph(graphData) {
+    const container = document.getElementById("sigma-container");
+    const nodeName = document.getElementById("node_name")?.textContent?.trim() || "";
+    if (!container) return null;
+
+    console.log("Initialisation du graphe Sigma...");
+    
+    const Graph = window.graphology.Graph;
+    const graph = new Graph();
+    const TYPE_COLORS = {
+        personne: '#007bff', organisation: '#007', Modèle: '#b1b1b1', Dataset: '#ffc107',
+        Author: '#007bff', Model: '#b1b1b1', Unknown: '#999'
+    };
+    const addedNodeIds = new Set();
+
+    graphData.nodes.forEach(node => {
+        if (addedNodeIds.has(node.id)) return;
+        const rawSize = Math.log10(node.downloads || node.followers || 1) * 2 + (depth === 0 ? 5 : 0);
+        graph.addNode(node.id, {
+            id: node.id, label: node.id, size: Math.max(5, rawSize), color: TYPE_COLORS[node.label] || '#999',
+            dataCat: node.label, x: Math.random(), y: Math.random(),
+            followers: node.followers, downloads: node.downloads, createdAt: node.createdAt,
+            createdAt_dataset: node.createdAt_dataset, task: node.task, bfsDepth: node.distance
+        });
+        addedNodeIds.add(node.id);
+
+    });
+
+    graphData.edges.forEach(edge => {
+        const info = edgeInfos[edge.relation];
+        const edgeColor = info ? info.color : '#ccc';
+
+        if (graph.hasNode(edge.source) && graph.hasNode(edge.target)) {
+            graph.addEdge(edge.source, edge.target, {
+                label: edge.relation || '', color: edgeColor, size: 3, type: 'arrow'
+            });
+        }
+    });
+    
+    graphologyLibrary.layoutForceAtlas2.assign(graph, { iterations: 100 });
+    const renderer = new Sigma(graph, container);
+    const state = {
+        hoveredNode: null,
+        hoveredNeighbors: null
+    };
+    renderer.setSetting("nodeReducer", (node, data) => {
+        const res = { ...data };
+      
+        if (state.hoveredNode && state.hoveredPredecessors) {
+          // Garder seulement le nœud survolé et ses prédécesseurs visibles en couleur
+          if (!state.hoveredPredecessors.has(node)) {
+            res.color = "#f1f1f1";  // gris
+            res.label = "";         // masquer le label
+          }
+        }
+      
+        return res;
+      });
+      
+      renderer.setSetting("edgeReducer", (edge, data) => {
+        const res = { ...data };
+      
+        if (state.hoveredNode && state.hoveredPredecessors) {
+          const [source, target] = graph.extremities(edge);
+          // Montrer seulement les arêtes dans le chemin des prédécesseurs
+          if (!state.hoveredPredecessors.has(source) || !state.hoveredPredecessors.has(target)) {
+            res.hidden = true;
+          }
+        }
+      
+        return res;
+      });
+    buildEdgeLegend();
+    buildEdgeFilters(); 
+    
+    const graphModelsTable = $('#graph-models-table').DataTable({
+        language: { "url": "https://cdn.datatables.net/plug-ins/1.13.4/i18n/fr-FR.json" },
+        pageLength: 5, responsive: true, scrollX: true
+    });
+    
+    // Remplir la table une première fois avec tous les modèles
+    populateGraphModelsTable(graphData, graphModelsTable); 
+    
+    const filtersContainer = document.getElementById('graph-filters-container');
+    if (filtersContainer) {
+        // L'écouteur appelle maintenant la fonction updateGraphVisibility qui est bien définie
+        filtersContainer.addEventListener('change', () => updateGraphVisibility(graphData,graph, renderer, graphModelsTable));
+    }
+    
+    renderer.on('clickNode', ({ node }) => showNodeInfo(graph.getNodeAttributes(node)));
+    setupTableRowClickListeners(renderer, graph);
+    renderer.on('clickNode', ({ node }) => {
+        showNodeInfo(graph.getNodeAttributes(node));
+    });
+    // Quand on survole un nœud
+    renderer.on("enterNode", ({ node }) => {
+    state.hoveredNode = node;
+    state.hoveredPredecessors = getAllPredecessors(graph, node);
+    renderer.refresh({ skipIndexation: true });
+    });
+
+    // Quand on sort du nœud
+    renderer.on("leaveNode", () => {
+    state.hoveredNode = null;
+    state.hoveredPredecessors = null;
+    renderer.refresh({ skipIndexation: true });
+    });
+    document.getElementById("export-btn").addEventListener("click", () => {
+        const graph = renderer.getGraph(); // Graph actuel de Sigma
+        const graphData = {
+          nodes: graph.nodes().map(n => graph.getNodeAttributes(n)),
+          edges: graph.edges().map(e => ({
+            ...graph.getEdgeAttributes(e),
+            source: graph.source(e),
+            target: graph.target(e),
+          })),
+        };
+        console.log(graphData)
+        // Récupération du HTML des légendes
+        const legendHtmlnodes = document.getElementById("legend-nodes")?.innerHTML || "";
+        const legendHtmledges = document.getElementById("legend-edges")?.innerHTML || "";
+        fetch("/static/graph_export.html")
+          .then(res => res.text())
+          .then(template => {
+            // Remplacement des placeholders
+            const finalHtml = template
+              .replace("{{GRAPH_DATA}}", JSON.stringify(graphData))
+              .replaceAll("{{NODE_NAME}}", JSON.stringify(nodeName))
+              .replace("{{LEGEND_HTML_NODES}}", legendHtmlnodes)
+              .replace("{{LEGEND_HTML_EDGES}}", legendHtmledges);
+    
+            const blob = new Blob([finalHtml], { type: "text/html" });
+            const url = URL.createObjectURL(blob);
+    
+            const a = document.createElement("a");
+            a.href = url;
+            a.download = "graph_export.html";
+            a.click();
+    
+            URL.revokeObjectURL(url);
+          });
+    });
+    
+
+    return renderer;
+}
+
+                  
+// ===================================================================
+// POINT D'ENTRÉE PRINCIPAL - EXÉCUTÉ AU CHARGEMENT DE LA PAGE
+// ===================================================================
+document.addEventListener("DOMContentLoaded", () => {
+    
+    const sigmaContainer = document.getElementById("sigma-container");
+    
+    if (sigmaContainer && sigmaContainer.dataset.graph) {
+        let graphData;
+        try {
+            graphData = JSON.parse(sigmaContainer.dataset.graph);
+            if (graphData && graphData.nodes && graphData.nodes.length > 0) {
+                initializeSigmaGraph(graphData);
+            }
+        } catch (e) {
+            console.error("Erreur d'analyse JSON des données du graphe:", e);
+        }
+    }
+    
+    // --- Logique du formulaire (autocomplétion, etc.) ---
+    const input = document.getElementById('search-input');
+    const suggestionsList = document.getElementById('suggestions-list');
+    
+    if(input && suggestionsList) {
+        const modelCheckbox = document.getElementById('filter-model');
+        const datasetCheckbox = document.getElementById('filter-dataset');
+        const authorCheckbox = document.getElementById('filter-author'); // Assurez-vous d'avoir cet ID
+
+        function fetchAutocomplete() {
+            const query = input.value.trim();
+    
+            // 1. Déterminer quel filtre est actif
+            let activeFilter = '';
+            if (modelCheckbox.checked) {
+                activeFilter = 'Model';
+            } else if (datasetCheckbox.checked) {
+                activeFilter = 'Dataset';
+            }
+    
+            // Si le champ est vide, on cache les suggestions
+            if (query.length < 2) {
+                suggestionsList.style.display = 'none';
+                return;
+            }
+    
+            // 2. Construire l'URL avec le filtre
+            // On commence avec la requête de base
+            let fetchUrl = `/autocomplete?q=${encodeURIComponent(query)}`;
+            // On ajoute le paramètre 'filter' SEULEMENT s'il y en a un d'actif
+            if (activeFilter) {
+                fetchUrl += `&filter=${activeFilter}`;
+            }
+            
+            // 3. Lancer la requête fetch avec la bonne URL
+            fetch(fetchUrl)
+                .then(response => response.json())
+                .then(data => {
+                    suggestionsList.innerHTML = '';
+                    if (data.length > 0) {
+                        data.forEach(item => {
+                            const li = document.createElement('li');
+                            li.textContent = item.name;
+                            li.addEventListener('click', () => {
+                                input.value = item.name;
+                                suggestionsList.style.display = 'none';
+                            });
+                            suggestionsList.appendChild(li);
+                        });
+                        suggestionsList.style.display = 'block';
+                    } else {
+                        suggestionsList.style.display = 'none';
+                    }
+                });
+        }
+
+        input.addEventListener('input', fetchAutocomplete);
+        if (modelCheckbox) modelCheckbox.addEventListener('change', fetchAutocomplete);
+        if (datasetCheckbox) datasetCheckbox.addEventListener('change', fetchAutocomplete);
+        if (authorCheckbox) authorCheckbox.addEventListener('change', fetchAutocomplete);
+        
+        document.addEventListener('click', (e) => {
+            if (!input.contains(e.target) && !suggestionsList.contains(e.target)) {
+                suggestionsList.style.display = 'none';
+            }
+        });
+    }
+    const checkbox = document.getElementById('depth-unlimited');
+    if (checkbox) {
+        const depthInput = document.getElementById('depth');
+        function toggleDepthInput() { if (depthInput) depthInput.disabled = checkbox.checked; }
+        checkbox.addEventListener('change', toggleDepthInput);
+        toggleDepthInput();
+    }
+
+
+      
+});
+

application_neo4j/static/js/utils.js

@@ -0,0 +1,233 @@
+// --- FONCTIONS UTILITAIRES GLOBALES ---
+// Ces fonctions sont utilisées à plusieurs endroits et sont donc définies en premier.
+// Mapping relations → {couleur, tooltip}
+const edgeInfos = {
+    "Fait partie de cette organisation": {
+      color: "#a05195",name : "Fait partie de cette organisation",
+      tooltip: "Cette personne est membre de cette organisation"
+    },
+    "A publié": {
+      color: "#003f5c",name : "A publié",
+      tooltip: "Un auteur (personne ou organistaion) a publié un modèle"
+    },
+    "A généré": {
+      color: "#f50f0f",name : "A permis de générer",
+      tooltip: "Le modèle source a été téléchargé et modifié afin de créer le modèle cible (type de transformation inconnu)"
+
+    },
+    "finetune": {
+      color: "#cd6700",name : "Finetune",
+      tooltip: "Ajustement : le modèle source est ré-entraîné sur un jeu de données spécifique afin de pouvoir être performant pour une tâche précise."
+
+    },
+    "adapter": {
+      color: "#238a00",name : "Adapter",
+
+      tooltip: "Adaptation : méthode d’ajustement qui peut être utilisée avec peu de ressources de calcul."
+    },
+    "quantized": {
+      color: "#009194",name : "Quantized",
+      tooltip:"Quantisation : la précision des poids du modèle source est réduite afin de diminuer son empreinte en mémoire."
+    },
+    "merge": {
+      color: "#c29bc2",name : "Merge",
+      tooltip:"Fusion : méthode visant à mélanger des couches de différents modèles pour améliorer leur performance."
+    },
+    "other": {
+      color: "#8f7340",name : "Autre",
+      tooltip: "Autre type de relation"
+    }
+    , "unknown": {
+      color: "#8f7340",name : "Autre",
+      tooltip: "Autre type de relation"
+    }
+  };
+
+  
+
+
+  function buildEdgeLegend() {
+    const legendContainer = document.getElementById("legend-edges");
+    legendContainer.innerHTML = ""; // reset
+  
+    Object.entries(edgeInfos).forEach(([relation, {color, name,tooltip}]) => {
+      if (relation == "unknown") return;
+      const li = document.createElement("li");
+      li.className = "list-group-item d-flex align-items-center";
+      
+      // ajout Bootstrap tooltip
+      li.setAttribute("data-bs-toggle", "tooltip");
+      li.setAttribute("data-bs-placement", "top");
+      li.setAttribute("data-bs-html", "true");
+      li.setAttribute("title", tooltip);
+  
+      const span = document.createElement("span");
+      span.className = "legend-color edge me-2";
+      span.style.backgroundColor = color;
+  
+      li.appendChild(span);
+      li.appendChild(document.createTextNode(name));
+  
+      legendContainer.appendChild(li);
+    });
+  
+    // nécessaire pour activer les tooltips Bootstrap dynamiques
+    const tooltipTriggerList = [].slice.call(legendContainer.querySelectorAll('[data-bs-toggle="tooltip"]'))
+    tooltipTriggerList.map(el => new bootstrap.Tooltip(el));
+  }
+
+  /**
+* Affiche la carte d'information pour un nœud donné.
+* @param {object} attr - Les attributs du nœud à afficher.
+*/
+function showNodeInfo(attr) {
+    const infoCard = document.getElementById("node-info-card");
+    const cardBody = infoCard.querySelector('.card-body'); 
+    const detailsContainer = document.getElementById("node-details");
+ 
+    if (!infoCard || !detailsContainer || !cardBody) return;
+ 
+    // --- ÉTAPE 1: Nettoyage ---
+    const existingLink = cardBody.querySelector('.stretched-link');
+    if (existingLink) {
+        existingLink.remove();
+    }
+    
+    // On stocke l'ID du nœud pour l'animation au survol
+    infoCard.dataset.nodeId = attr.id;
+ 
+    // --- ÉTAPE 2: Construction des détails ---
+    let infosHtml = `<p><strong>Nom :</strong> ${attr.id || "Non défini"}</p><p><strong>Type :</strong> ${attr.dataCat}</p>`;
+    
+    // ... (Le reste de la construction de infosHtml ne change pas) ...
+    if (["personne", "organisation", "Author"].includes(attr.dataCat)) {
+        if (attr.followers) infosHtml += `<p><strong>Abonnés :</strong> ${formatNumberShort(attr.followers)}</p>`;
+    } else if (["Modèle", "Model"].includes(attr.dataCat)) {
+        if (attr.downloads) infosHtml += `<p><strong>Téléchargements :</strong> ${formatNumberShort(attr.downloads)}</p>`;
+        if (attr.createdAt) infosHtml += `<p><strong>Créé le :</strong> ${formatDateFr(attr.createdAt)}</p>`;
+        if (attr.task) infosHtml += `<p><strong>Tâche :</strong> ${attr.task}</p>`;
+        if (attr.dataset) infosHtml += `<p><strong>Dataset utilisé :</strong> ${attr.dataset}</p>`;
+    } else if (attr.dataCat === "Dataset") {
+        if (attr.downloads) infosHtml += `<p><strong>Téléchargements :</strong> ${formatNumberShort(attr.downloads)}</p>`;
+        if (attr.createdAt_dataset) infosHtml += `<p><strong>Créé le :</strong> ${formatDateFr(attr.createdAt_dataset)}</p>`;
+    }
+ 
+    // --- ÉTAPE 3: Création du lien ---
+    let huggingFaceUrl = null;
+    if (["Modèle", "Model","personne", "organisation", "Author"].includes(attr.dataCat)) {
+        huggingFaceUrl = `https://huggingface.co/${attr.id}`;
+    } else if (attr.dataCat === "Dataset") {
+        huggingFaceUrl = `https://huggingface.co/datasets/${attr.id}`;
+    }
+ 
+    if (huggingFaceUrl) {
+        const link = document.createElement('a');
+        link.href = huggingFaceUrl;
+        link.target = '_blank';
+        link.rel = 'noopener noreferrer';
+        link.className = 'stretched-link'; 
+        link.setAttribute('aria-label', `Voir ${attr.id} sur Hugging Face`);
+        cardBody.appendChild(link);
+    }
+ 
+    detailsContainer.innerHTML = infosHtml;
+    
+    // Affichage et défilement de la carte
+    infoCard.style.display = 'block';
+    infoCard.scrollIntoView({ behavior: 'smooth', block: 'center' });
+ }
+
+
+
+
+
+
+/**
+ * Formate une chaîne de date ISO en format français (ex: 1 janvier 2024).
+ * @param {string} dateString - La date à formater.
+ * @returns {string} La date formatée ou "Date inconnue".
+ */
+function formatDateFr(dateString) {
+    if (!dateString || dateString === "inconnue") return "Date inconnue";
+    try {
+        const options = { year: 'numeric', month: 'long', day: 'numeric' };
+        return new Date(dateString).toLocaleDateString('fr-FR', options);
+    } catch (e) {
+        return "Date inconnue";
+    }
+}
+
+// --- PLUGIN DE TRI PERSONNALISÉ POUR DATATABLES ---
+// Gère les colonnes avec des nombres et des chaînes de caractères (ex: "Inconnu")
+// Place toujours les chaînes après les nombres lors d'un tri ascendant.
+
+// Fonction pour parser la valeur : enlève les espaces et convertit en nombre si possible
+function parseNumericValue(value) {
+    if (typeof value === 'string') {
+        // Enlève les espaces (pour les nombres comme "12 345") et les virgules
+        const cleanedValue = value.replace(/[\s,]/g, '');
+        const num = parseInt(cleanedValue, 10);
+        if (!isNaN(num)) {
+            return { isNumber: true, value: num };
+        }
+    }
+    // Si ce n'est pas une chaîne numérique, on le traite comme du texte
+    return { isNumber: false, value: value };
+}
+
+// Définition du tri ascendant
+jQuery.fn.dataTable.ext.order['numeric-string-asc'] = function (a, b) {
+    const valA = parseNumericValue(a);
+    const valB = parseNumericValue(b);
+
+    if (valA.isNumber && valB.isNumber) {
+        return valA.value - valB.value; // Tri numérique standard
+    } else if (valA.isNumber && !valB.isNumber) {
+        return -1; // Les nombres viennent AVANT les chaînes
+    } else if (!valA.isNumber && valB.isNumber) {
+        return 1; // Les chaînes viennent APRÈS les nombres
+    } else {
+        // Les deux sont des chaînes, on fait un tri alphabétique
+        return String(valA.value).localeCompare(String(valB.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;
+};
+
+/**
+ * Formate un grand nombre en une version courte (ex: 1.2M, 50k).
+ * @param {number} n - Le nombre à formater.
+ * @returns {string} Le nombre formaté.
+ */
+function formatNumberShort(n) {
+    if (!n || n === 0) return "";
+    if (n >= 1000000000) return (n / 1000000000).toFixed(1) + 'B';
+    if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+    if (n >= 1000) return (n / 1000).toFixed(0) + 'k';
+    return n.toString();
+}
+
+
+function getAllPredecessors(graph, nodeId) {
+  const visited = new Set();
+  const stack = [nodeId];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!visited.has(current)) {
+      visited.add(current);
+
+      // On parcourt les prédécesseurs directs
+      graph.forEachInNeighbor(current, (pred) => {
+        if (!visited.has(pred)) {
+          stack.push(pred);
+        }
+      });
+    }
+  }
+
+  return visited;
+}

application_neo4j/templates/expert.html

@@ -0,0 +1,253 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Généalogie des Modèles - Vue Experte</title>
+  
+  <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 rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.css">
+  <link rel="stylesheet" href="https://cdn.datatables.net/1.13.4/css/jquery.dataTables.min.css" />
+  <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+
+  <style>
+    body { font-size: 1.05rem; }
+    .legend-color { width: 1em; height: 1em; display: inline-block; border-radius: 2px; }
+    .legend-color.edge { border-radius: 0; height: 0.25em; transform: translateY(-0.35em); }
+  </style>
+</head>
+
+<body class="d-flex flex-column min-vh-100">
+    <header class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
+    <div class="container">
+      <a class="navbar-brand" href="/">
+        <span class="fw-bold">Généalogie des Modèles</span>
+        <small class="d-block text-muted">Exploration des relations entre modèles et datasets</small>
+      </a>
+    </div>
+  </header>
+
+  <main class="container mt-4 flex-grow-1">
+    <div class="row">
+      <div class="col-12">
+        <h1 class="display-5">Recherche Experte</h1>
+        <p class="lead">Explorez et filtrez la généalogie des modèles</p>
+      </div>
+    </div>   
+    <div class="row g-3 mb-4">
+      <div class="col-12">
+        <form method="POST" action="{{ url_for('findnode_expert') }}" autocomplete="off">
+          <input type="hidden" name="filter" value="{{ search.filter or '' }}">
+      
+          <div class="row g-3 align-items-end">
+            <!-- Champ de recherche -->
+            <div class="col-12 col-md-5">
+              <label for="search-input" class="form-label fw-bold">Nom à rechercher</label>
+              <div class="position-relative">
+                <input type="text" name="name" id="search-input" class="form-control"
+                          placeholder="Taper le nom du modèle suspecté."
+                          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>
+            <!-- Filtres -->
+            <div class="col-12 col-md-3">
+              <label class="form-label fw-bold">Filtres</label>
+              <div class="d-flex gap-3">
+                <div class="form-check">
+                  <input class="form-check-input" type="checkbox" name="filters" value="Model" id="filter-model"
+                          {% if 'Model' in search.filters %}checked{% endif %}>
+                  <label class="form-check-label" for="filter-model">Modèle</label>
+                </div>
+                <div class="form-check">
+                  <input class="form-check-input" type="checkbox" name="filters" value="Dataset" id="filter-dataset"
+                          {% if 'Dataset' in search.filters %}checked{% endif %}>
+                  <label class="form-check-label" for="filter-dataset">Dataset</label>
+                </div>
+                <div class="form-check">
+                  <input class="form-check-input" type="checkbox" name="filters" value="Author" id="filter-author" {% if 'Author' in search.filters %}checked{% endif %}>
+                  <label class="form-check-label" for="filter-author">Auteur</label>
+                </div>
+              </div>
+            </div>
+            <!-- Profondeur de recherche -->
+            <div class="col-12 col-md-4">
+              <label class="form-label fw-bold">Profondeur de recherche</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" checked>
+                  <label class="form-check-label" for="depth-unlimited">Illimitée</label>
+                </div>
+                <div class="input-group input-group-sm">
+                  <span class="input-group-text">Limité à:</span>
+                  <input class="form-control" type="number" name="depth" id="depth"
+                          value="{{ request.form.depth }}" min="1" max="5" disabled>
+                </div>
+              </div>
+            </div>
+          </div>
+          <div class="row mt-4">
+            <div class="col-12">
+              <button type="submit" name="submit" value="findnode_expert" class="btn btn-primary w-100">
+                <i class="bi bi-search me-1"></i>Rechercher
+              </button>
+            </div>
+          </div>
+        </form>
+      </div>
+    </div>
+                
+  
+    {% if message %}
+    <div class="alert alert-info mt-3"><p class="mb-0">{{ message }}</p></div>
+    {% endif %}
+
+    <!-- CORRECTION : Cette section s'affiche seulement s'il y a des données -->
+    {% if graph_data and graph_data.nodes %}    
+    <div id="genealogy-graph-section"  class="mt-4">
+      <div class="row g-4">
+        <div class="card-header"><h5 class="card-title mb-0">Composante connexe du noeud recherché</h5></div>
+        <!-- Colonne de gauche pour le graphe et la carte d'info -->
+        <div class="col-12 col-lg-8">
+          <div class="card position-relative">
+            <!-- Graphe Sigma -->
+            
+            <div id="sigma-container" data-graph='{{ graph_data | tojson | safe }}' style="width: 100%; height: 600px;">
+              <!-- Légende flottante -->
+              <div id="floating-legend" 
+                  class="card p-2 position-absolute top-0 start-0 shadow-sm" 
+                  style="width: 220px; background-color: rgba(255,255,255,0.95);">
+                <div class="d-flex justify-content-between align-items-center mb-2">
+                  <strong>Légendes</strong>
+                  <button class="btn btn-sm btn-light p-0" 
+                          type="button" 
+                          data-bs-toggle="collapse" 
+                          data-bs-target="#legend-content" 
+                          aria-expanded="true" 
+                          aria-controls="legend-content">
+                    <i class="bi bi-chevron-up"></i>
+                  </button>
+                </div>
+                <!-- Contenu de la légende -->
+                <div id="legend-content" class="collapse show">
+                  <div class="card mb-2">
+                    <div class="card-header py-1"><h6 class="card-title mb-0">Nœuds</h6></div>
+                    <div class="card-body p-2">
+                      <ul id="legend-nodes" class="list-group list-group-flush small">
+                        <li class="list-group-item d-flex align-items-center py-1">
+                          <span class="legend-color me-2" style="background-color: hsl(45, 65%, 52%);"></span>Dataset
+                        </li>
+                        <li class="list-group-item d-flex align-items-center py-1">
+                          <span class="legend-color me-2" style="background-color: #007bff;"></span>Personne
+                        </li>
+                        <li class="list-group-item d-flex align-items-center py-1">
+                          <span class="legend-color me-2" style="background-color: #092d53;"></span>Organisation
+                        </li>
+                        <li class="list-group-item d-flex align-items-center py-1">
+                          <span class="legend-color me-2" style="background-color:#7D7D7D;"></span>Modèle
+                        </li>
+                      </ul>
+                    </div>
+                  </div>
+
+                  <div class="card">
+                    <div class="card-header py-1"><h6 class="card-title mb-0">Relations</h6></div>
+                    <div class="card-body p-2">
+                      <ul id="legend-edges" class="list-group list-group-flush small">
+                      </ul>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+          <div id="node-info-card" class="card mt-3 card-interactive" style="display: none;">                  
+            <div class="card-body">
+                  <h5 class="card-title">Informations du nœud sélectionné</h5>
+                  <div id="node-details" class="mt-2"></div>
+            </div>
+          </div>
+        </div>
+        <div class="col-12 col-lg-4">
+          <!-- CORRECTION : Chaque section est dans sa propre carte -->
+          <div class="card mb-3">
+              <div class="card-header"><h5 class="card-title mb-0">Filtres du Graphe</h5></div>
+              <div class="card-body" id="graph-filters-container">
+                  <h6>Types de Nœuds</h6>
+                  <div class="form-check form-switch">
+                      <input class="form-check-input" type="checkbox" id="filter-node-model" value="Modèle" checked>
+                      <label class="form-check-label" for="filter-node-model">Modèle</label>
+                  </div>
+                  <div class="form-check form-switch">
+                      <input class="form-check-input" type="checkbox" id="filter-node-person" value="personne" checked>
+                      <label class="form-check-label" for="filter-node-person">Personne</label>
+                  </div>
+                  <div class="form-check form-switch">
+                      <input class="form-check-input" type="checkbox" id="filter-node-org" value="organisation" checked>
+                      <label class="form-check-label" for="filter-node-org">Organisation</label>
+                  </div>
+                  <hr>
+                  <h6>Types de Relations</h6>
+                  <div id="edge-filters-container"></div>
+              </div>
+            </div>
+            <button id="export-btn" class="btn-modern">Télécharger le graphe</button>
+        </div>
+      </div>
+      <hr class="my-5">
+
+      <!-- CORRECTION : Tableau des modèles présents dans le graphe -->
+      <div class="row mt-4">
+          <div class="col-12">
+              <h4 class="h4">Modèles présents dans le graphe</h4>
+              <div class="table-responsive">
+                  <table id="graph-models-table" class="table table-bordered table-striped table-hover" style="width:100%">
+                      <thead>
+                          <tr>
+                              <th scope="col">Modèle</th>
+                        <th scope="col">Auteur</th>
+                        <th scope="col">Téléchargements</th>
+                        <th scope="col">Tâche</th>
+                        <th scope="col">J'aime</th>
+                        <th scope="col">Date de publication</th>
+                        <th scope="col">Dataset utilisé</th>
+                        <th scope="col">Licence</th>
+                        <th scope="col">Distance au modèle recherché</th>
+                        <th scope="col">Ascendants</th>
+                        <th scope="col">Descendants</th>
+                        <th scope="col">Citations</th>
+                          </tr>
+                      </thead>
+                      <tbody>
+                          <!-- Le contenu sera rempli par JavaScript -->
+                      </tbody>
+                  </table>
+              </div>
+          </div>
+      </div>
+    </div>
+    {% endif %}
+  </main>
+
+  <footer class="bg-dark text-white text-center p-4 mt-auto">
+    <div class="container">
+      <p class="mb-0">Application de recherche et visualisation... © 2025</p>
+    </div>
+  </footer>
+
+  <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+  <script src="https://cdn.datatables.net/1.13.4/js/jquery.dataTables.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz" crossorigin="anonymous"></script>
+  <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 src="{{ url_for('static', filename='js/script_expert.js') }}"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function () {
+      const tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]');
+      const tooltipList = [...tooltipTriggerList].map(tooltipTriggerEl => new bootstrap.Tooltip(tooltipTriggerEl));
+    });
+  </script>
+</body>
+</html>

application_neo4j/templates/index.html

@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Accueil - Généalogie des Modèles</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <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 {
+      font-family: sans-serif;
+      background-color: #f4f4f9;
+      color: #333;
+      margin: 0;
+      padding: 0;
+    }
+
+    /* En-tête avec titre + bouton */
+    .welcome-container {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      text-align: center;
+      gap: 15px;
+      padding: 40px 20px;
+    }
+
+    .welcome-container h1 {
+      color: #2c3e50;
+      font-size: 2rem;
+      font-weight: 700;
+      margin: 0;
+    }
+
+    .info-btn {
+      background: linear-gradient(135deg, #3498db, #5dade2);
+      color: white;
+      padding: 12px 30px;
+      border-radius: 50px;
+      text-decoration: none;
+      font-weight: bold;
+      transition: all 0.3s ease;
+      box-shadow: 0 3px 8px rgba(0,0,0,0.15);
+    }
+
+    .info-btn:hover {
+      background: linear-gradient(135deg, #2980b9, #3498db);
+      transform: scale(1.05);
+    }
+
+    /* Section et cartes */
+    .content-section {
+      padding: 40px 20px;
+    }
+
+    .content-card {
+      background: white;
+      padding: 30px;
+      border-radius: 12px;
+      box-shadow: 0 4px 10px rgba(0,0,0,0.08);
+      transition: transform 0.2s ease-in-out;
+      height: 100%;
+      text-align: justify;
+    }
+
+    .content-card:hover {
+      transform: translateY(-5px);
+    }
+
+    .content-card h4, .content-card h6 {
+      color: #6a11cb;
+      margin-bottom: 15px;
+    }
+
+    /* Décalage des puces */
+    .content-card p {
+      margin-left: 15px;
+    }
+
+    /* Mise en forme spécifique pour Alice */
+    .highlight {
+      font-style: italic;
+      color: #6a11cb;
+      display: block;
+      margin-left: 15px; /* aligné avec les puces */
+    }
+
+    /* Boutons */
+    .buttons-container {
+      display: flex;
+      flex-direction: column; /* empilés verticalement */
+      align-items: center;
+      gap: 15px;
+      margin-top: 20px;
+    }
+
+    
+    </style>
+    </head>
+
+<body>
+    <div class="welcome-container">
+      <h1>Bienvenue sur l'explorateur de généalogie des modèles publiés sur HuggingFace</h1>
+      <a href="{{ url_for('info_page') }}" class="btn-modern">Plus d'infos</a>
+    </div>
+    <div class="container content-section">
+      <div class="row g-4">
+        <div class="col-md-6">
+          <div class="content-card">
+          <h4>Qu'est-ce que la généalogie d'un <strong>modèle</strong> ?</h4>
+          <p>
+            L'observation de la généalogie d’un modèle d’intelligence artificielle consiste à reconstituer l’historique de sa création et de ses transformations :<br><br>
+            • À partir de quel(s) modèle(s) il a été dérivé (<strong>ascendants</strong>) <br>
+            • Quelles <strong>modifications</strong> ont été apportées (ajustement,quantisation, adaptation, fusion…)<br>
+            • Quels nouveaux modèles ont été produits à partir de celui-ci (<strong>descendants</strong> )<br><br>
+            Cela peut être représenté sous forme d'<strong>arbre généalogique</strong>, retraçant l’ensemble des étapes qui ont conduit à un modèle open source donné.
+          </p>
+        </div>
+      </div>
+      <div class="col-md-6">
+        <div class="content-card">
+          <h4>Et dans le cas d'un <strong>dataset</strong> ?</h4>
+          <p>
+            L'observation de la généalogie d’un dataset consiste à reconstituer l’historique de sa création et de ses différentes utilisations : <br> <br>
+            • À partir de quelle(s) <strong>source(s) de données</strong> le dataset a été construit <br>
+            • Quels modèles ont été <strong>entrainés</strong> sur ce jeu de données<br>
+            • A quelles(s) organisation(s) appartient l'auteur qui a publié ce jeu de données<br> <br>
+
+            La généalogie retrace toutes les étapes et ramifications de l'utilisation d'un dataset donné.
+          </p>
+        </div>
+      </div>
+      <div class="col-md-6">
+        <div class="content-card">
+          <h4>Pour quoi faire ?</h4>
+          <p>
+           Visualiser la généalogie des modèles est une étape importante pour :<br> <br>
+            • Protéger la <strong>vie privée</strong> des personnes dont les données pourraient être mémorisées par un modèle ou contenues dans un dataset <br>
+            • Assurer la <strong>traçabilité</strong> sur les chaînes de modification des modèles<br> <br>
+          
+            <h6>Pour mieux comprendre l'utilité de cet outil, prenons le cas d'Alice Dupont:</h6>
+            <span class="highlight">
+            • Alice utilise un chatbot issu d'un modèle publié sur HuggingFace. <br>
+              Sa requête est : "Qui est Alice Dupont ?", le chatbot renvoie son adresse et son numéro de téléphone.<br><br>
+            • Alice veut connaître l'<strong>impact de la mémorisation potentielle de ses données personnelles</strong>, ainsi que l'origine de ce modèle.<br><br>
+              Avec cet outil, Alice a accès :<br>
+              • aux modèles issus du modèle interrogé et publiés sur HuggingFace<br>
+              • aux modèles parents de ce modèle.<br><br>
+            (A condition que les liens entre modèles soient déclarés par les utiliateurs sur HuggingFace)
+          </span>
+        </p>
+        </div>
+      </div>
+
+      <div class="col-md-6">
+        <div class="content-card">
+          <h4>Vous souhaitez connaître la descendance et l'acsendance de ...</h4>
+          <div class="buttons-container">
+            <!-- Ce bouton mène à la page de recherche -->
+            <a href="{{ url_for('findnode', filter='Model') }}" class="btn-modern">Un modèle</a>
+            <a href="{{ url_for('findnode', filter='Dataset') }}" class="btn-modern">Un dataset</a>
+            <a href="{{ url_for('findnode') }}" class="btn-modern">Je ne sais pas</a><br><br>
+            <h4>Vous êtes un chercheur</h4>
+          <div class="buttons-container">
+            <!-- Ce bouton mène à la page de recherche -->
+            <a href="{{ url_for('findnode_expert', filter='Model') }}" class="btn-modern">Mode expert</a>
+        </div>
+      </div>
+      </div>
+    </div>
+
+</body>
+</html>

application_neo4j/templates/infos.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <title>Plus d'informations</title>
+    <style>
+        body, html { margin: 0; padding: 0; height: 100%; overflow: hidden; }
+        .pdf-container { width: 100%; height: 100%; }
+        .pdf-container iframe { border: none; width: 100%; height: 100%; }
+    </style>
+</head>
+<body>
+    <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>

application_neo4j/templates/search.html

@@ -0,0 +1,437 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Généalogie des Modèles</title>
+  
+  <!-- CSS de Bootstrap (remplace DSFR) -->
+  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
+  <!-- Icônes Bootstrap (pour les boutons, etc.) -->
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.css">
+  
+  <!-- CSS de DataTables et votre CSS personnalisé (inchangés) -->
+  <link rel="stylesheet" href="https://cdn.datatables.net/1.13.4/css/jquery.dataTables.min.css" />
+  <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+
+  <style>
+    body {
+      font-size: 1.05rem;
+    }
+    .legend-color {
+        width: 1em;
+        height: 1em;
+        display: inline-block;
+        border-radius: 2px;
+    }
+    .legend-color.edge {
+        border-radius: 0;
+        height: 0.25em;
+        transform: translateY(-0.35em);
+    }
+  </style>
+</head>
+
+<body class="d-flex flex-column min-vh-100">
+    <header class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
+    <div class="container">
+      <a class="navbar-brand" href="/">
+        <span class="fw-bold">Généalogie des Modèles</span>
+        <small class="d-block text-muted">Exploration des relations entre modèles et datasets</small>
+      </a>
+    </div>
+  </header>
+
+  <main class="container mt-4 flex-grow-1">
+    <!-- Titre principal et Formulaire (inchangés) -->
+    <div class="row">
+      <div class="col-12">
+        <h1 class="display-5">Recherche dans la base de données HuggingFace</h1>
+        <p class="lead">Explorez la généalogie des modèles</p>
+      </div>
+    </div>
+    
+    <div class="row g-3 mb-4">
+      <div class="col-12">
+        <form method="POST" action="{{ url_for('findnode') }}" autocomplete="off">
+          <input type="hidden" name="filter" value="{{ search.filter or '' }}">
+    
+          <div class="row g-3 align-items-end">
+            <!-- Champ de recherche -->
+            <div class="col-12 col-md-5">
+              <label for="search-input" class="form-label fw-bold">Nom à rechercher</label>
+              <div class="position-relative">
+                <input type="text" name="name" id="search-input" class="form-control"
+                       placeholder="Taper le nom du modèle suspecté."
+                       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>
+    
+            <!-- Filtres -->
+            <div class="col-12 col-md-3">
+              <label class="form-label fw-bold">Filtres</label>
+              <div class="d-flex gap-3">
+                <div class="form-check">
+                  <input class="form-check-input" type="checkbox" name="filters" value="Model" id="filter-model"
+                         {% if 'Model' in search.filters %}checked{% endif %}>
+                  <label class="form-check-label" for="filter-model">Modèle</label>
+                </div>
+                <div class="form-check">
+                  <input class="form-check-input" type="checkbox" name="filters" value="Dataset" id="filter-dataset"
+                         {% if 'Dataset' in search.filters %}checked{% endif %}>
+                  <label class="form-check-label" for="filter-dataset">Dataset</label>
+                </div>
+              </div>
+            </div>
+    
+            <!-- Profondeur de recherche -->
+            <div class="col-12 col-md-4">
+              <label class="form-label fw-bold">Profondeur de recherche</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" checked>
+                  <label class="form-check-label" for="depth-unlimited">Illimitée</label>
+                </div>
+                <div class="input-group input-group-sm">
+                  <span class="input-group-text">Limité à:</span>
+                  <input class="form-control" type="number" name="depth" id="depth"
+                         value="{{ request.form.depth }}" min="1" max="5" disabled>
+                </div>
+              </div>
+            </div>
+          </div>
+    
+          <!-- Bouton rechercher -->
+          <div class="row mt-4">
+            <div class="col-12">
+              <button type="submit" name="submit" value="find_node" class="btn btn-primary w-100">
+                <i class="bi bi-search me-1"></i>Rechercher
+              </button>
+            </div>
+          </div>
+        </form>
+      </div>
+    </div>
+    
+  
+    {% if message %}
+    <div class="alert alert-info mt-3"><p class="mb-0">{{ message }}</p></div>
+    {% endif %}
+
+    <!-- SECTION 1: VUE "HIGHLIGHTS" -->
+    {% if highlights and graph_data.nodes %}
+    <div id="highlights-view" class="mt-5 bg-light border rounded-3 p-4">
+      {% set searched_node = (graph_data.nodes | selectattr('id', 'equalto', search.name) | list | first) or {} %}
+      <div class="row justify-content-center align-items-stretch g-4">        
+        <!-- COLONNE ASCENDANCE -->
+        <div class="col-12 col-lg-3">
+          <div class="d-flex justify-content-center  gap-2 mb-3">
+            <h4 class="h5 text-center mb-3">Modèles importants de l'ascendance
+          <!-- L'icône avec les attributs pour le tooltip -->
+          <i class="bi bi-info-circle-fill text-secondary align-middle ms-2" 
+                       data-bs-toggle="tooltip" 
+             data-bs-placement="right" 
+             title="Les modèles qui précèdent le modèle recherché dans la généalogie, c’est-à-dire, les modèles à partir desquels le modèle recherché a été constitué">
+          </i>
+        </h4>
+        </div>
+            <div class="card">
+                <div class="card-body p-2">
+                    {% if not highlights.asc_unique_models %}
+                        <p class="text-muted small m-2">Aucun modèle parent trouvé.</p>
+                    {% else %}
+                        {% for model in highlights.asc_unique_models %}
+                            <div class="card mb-2 position-relative ">
+                                <!-- MODIFICATION : Structure interne de la carte changée -->
+                                <div class="card-body p-2">
+                                    <!-- Zone pour les badges, maintenant au-dessus, centrée et avec retour à la ligne -->
+                                    <div class="d-flex flex-wrap justify-content-center gap-1 mb-2">
+                                      {% for badge in model.badges %}
+                                      <span class="badge {{ badge.class }} on-top" 
+                                            data-bs-toggle="tooltip" 
+                                            data-bs-placement="top" 
+                                            title="{{ badge.title }}">
+                                          {{ badge.text }}
+                                      </span>
+                                  {% endfor %}
+                                    </div>
+                                    <!-- Contenu principal de la carte -->
+                                    <div class="text-center">
+                                        <!-- MODIFICATION : Ajout de la classe "text-break" pour empêcher le débordement -->
+                                        <h6 class="card-title small mb-1 text-break card-interactive">
+                                            <a href="https://huggingface.co/{{ model.name }}" target="_blank" rel="noopener noreferrer" class="stretched-link" data-bs-toggle="tooltip" data-bs-placement="top" data-bs-html="true" 
+                                            title="<b>Informations :</b>
+                                            <br>Auteur : {{ (model.name.split('/') | first) if '/' in model.name else 'Inconnu' }}<br>
+                                            Ciations : {{ '{:,.0f}'.format((model.citation_count or 0) | int).replace(',', ' ') }}<br>
+                                            J'aime : {{ model.likes or 'Inconnu' }}<br>
+                                            Date publication : {{ model.createdAt or 'N/A' }}<br>
+                                            Tâche : {{ model.task or 'Inconnue' }}<br>
+                                            License : {{ model.license or 'Inconnue' }}"
+                                            >
+                                                {{ model.name }}
+                                            </a>
+                                        </h6>
+                                        <p class="card-text" style="font-size: 0.75em; line-height: 1.2;">
+                                            {{ "{:,.0f}".format((model.downloads or 0) | int).replace(',', ' ') }} téléchargements<br>
+                                            {{ "{:,.0f}".format((model.citation_count or 0) | int).replace(',', ' ') }} citations
+                                        </p>
+                                    </div>
+                                </div>
+                            </div>
+                        {% endfor %}
+                    {% endif %}
+                </div>
+            </div>
+        </div>
+
+        <!-- Colonne pour la première flèche -->
+        <div class="col-lg-1 d-none d-lg-flex justify-content-center">
+            <i class="bi bi-arrow-right fs-1 text-secondary"></i>
+        </div>
+
+        <!-- COLONNE MODÈLE RECHERCHÉ (CENTRE) (inchangée) -->
+        <div class="col-12 col-lg-4 " id="center-column">
+            <h3 class="h5 text-center mb-3">Modèle recherché</h3>
+            <a href="https://huggingface.co/{{ searched_node.id }}" target="_blank" rel="noopener noreferrer" class="text-white">
+            <div class="card card-recherche text-center  border-2 ">
+                <div class="card-header card-recherche-header text-white">
+                    <h5 class="card-title h6 mb-0 ">
+                            {{ searched_node.id }}
+                    </h5>
+                </div>
+                <div class="card-body p-3">
+                    <div class="row">
+                        <div class="col">
+                          <p class="fw-bold mb-0">{{ "{:,.0f}".format((searched_node.ascendantsCount or 0) | int).replace(',', ' ') }}</p>
+                            <p class="small text-muted">ascendant(s)
+                            
+                              <i class="bi bi-info-circle-fill ms-2" 
+                                         data-bs-toggle="tooltip" 
+                               data-bs-placement="right" 
+                               title="Nombre de modèles qui précèdent le modèle recherché dans la généalogie">
+                            </i>
+                            </p>
+                      
+                          </div>
+                        <div class="col">
+                            <p class="fw-bold mb-0">{{ "{:,.0f}".format((searched_node.descendantsCount or 0) | int).replace(',', ' ') }}</p>
+                            <p class="small text-muted">descendant(s)
+                              <i class="bi bi-info-circle-fill ms-2" 
+                                         data-bs-toggle="tooltip" 
+                               data-bs-placement="right" 
+                               title="Nombre de modèles directement ou indirectement constitués à partir du modèle recherché">
+                            </i>
+                            </p>
+                        </div>
+                    </div>
+                    <div class="row mt-2">
+                        <div class="col"><p class="fw-bold mb-0">{{ "{:,.0f}".format((searched_node.downloads or 0) | int).replace(',', ' ') }}</p><p class="small text-muted">téléchargement(s)</p></div>
+                        <div class="col"><p class="fw-bold mb-0">{{ "{:,.0f}".format((searched_node.citationCount or 0) | int).replace(',', ' ') }}</p>
+                          <p class="small text-muted">citation(s)
+                          <i class="bi bi-info-circle-fill ms-2" 
+                                     data-bs-toggle="tooltip" 
+                           data-bs-placement="right" 
+                           title="Nombre de descendants directs du modèle recherché : les enfants du modèle recherché">
+                        </i>
+                        </p></div>
+                        <div class="col"><p class="fw-bold mb-0">{{ "{:,.0f}".format((searched_node.likes or 0) | int).replace(',', ' ') }}</p><p class="small text-muted">J'aime</p></div>
+                    </div>
+                    <div class="mt-2"> 
+                        {% if searched_node.createdAt %}<span class="badge bg-light text-dark">Publié le: {{ searched_node.createdAt }}</span>{% endif %}
+                        {% if searched_node.task %}<span class="badge bg-light text-dark">Tâche: {{ searched_node.task }}</span>{% endif %}
+                    </div>
+                    <hr>
+                  </a>
+                    <button id="show-graph-btn" class="btn btn-secondary"><i class="bi bi-diagram-3 me-1"></i>Voir l'arbre généalogique</button>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Colonne pour la deuxième flèche -->
+        <div class="col-lg-1 d-none d-lg-flex justify-content-center">
+            <i class="bi bi-arrow-right fs-1 text-secondary"></i>
+        </div>
+
+        <!-- COLONNE DESCENDANCE (DROITE) -->
+        <div class="col-12 col-lg-3">
+          <div class="d-flex justify-content-center  gap-2 mb-3">
+            <h4 class="h5 text-center mb-3">Modèles importants de la descendance
+            <!-- L'icône avec les attributs pour le tooltip -->
+            <i class="bi bi-info-circle-fill text-secondary align-middle ms-2" 
+            data-bs-toggle="tooltip" 
+            data-bs-placement="right" 
+               title="Les modèles directement ou indirectement constitués à partir du modèle recherché">
+            </i>
+          </h4>
+          </div>
+          <div class="card">
+            <div class="card-body p-2">
+              {% if highlights.desc_unique_models %}
+                {% for model in highlights.desc_unique_models %}
+                  <div class="card mb-2 position-relative ">
+                    <div class="card-body p-2">
+                        <!-- Zone pour les badges, maintenant au-dessus, centrée et avec retour à la ligne -->
+                        <div class="d-flex flex-wrap justify-content-center gap-1 mb-2">
+                          {% for badge in model.badges %}
+                          <span class="badge {{ badge.class }} on-top" 
+                                data-bs-toggle="tooltip" 
+                                data-bs-placement="top" 
+                                title="{{ badge.title }}">
+                              {{ badge.text }}
+                          </span>
+                      {% endfor %}
+                        </div>
+                        <!-- Contenu principal de la carte -->
+                        <div class="text-center card-interactive">
+                            <!-- MODIFICATION : Ajout de la classe "text-break" pour empêcher le débordement -->
+                            <h6 class="card-title small mb-1 text-break">
+                              <a href="https://huggingface.co/{{ model.name }}" 
+                                 target="_blank" 
+                                 rel="noopener noreferrer" 
+                                 class="stretched-link"
+                                 data-bs-toggle="tooltip"
+                                 data-bs-placement="top"
+                                 data-bs-html="true"
+                                 title="<b>Informations :</b><br>
+                                        Auteur : {{ (model.name.split('/') | first) if '/' in model.name else 'Inconnu' }}<br>
+                                        Téléchargements : {{ '{:,.0f}'.format((model.downloads or 0) | int).replace(',', ' ') }}<br>
+                                        J'aime : {{ model.likes or 'Inconnu' }}<br>
+                                        Date publication : {{ model.createdAt or 'N/A' }}<br>
+                                        Tâche : {{ model.task or 'Inconnue' }}<br>
+                                        License : {{ model.license or 'Inconnue' }}">
+                                {{ model.name }}
+                              </a>
+                            </h6>
+                            <p class="card-text" style="font-size: 0.75em; line-height: 1.2;">
+                              {{ "{:,.0f}".format((model.downloads or 0) | int).replace(',', ' ') }} téléchargements<br>
+                              {{ "{:,.0f}".format((model.citation_count or 0) | int).replace(',', ' ') }} citations
+                            </p>    
+                        </div>
+                    </div>
+                  </div>
+                {% endfor %} 
+              {% else %}
+                <p class="text-muted small m-2">Aucun modèle dérivé trouvé.</p>
+              {% endif %}
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    
+    <!-- SECTION 2 ET 3 (inchangées) -->
+    <div class="row mt-5 mb-5">
+      <hr class="mb-5">
+      <div class="col-12">
+          <div class="mb-5">
+              <h4 class="h4">Descendance détaillée</h4>
+              <div class="table-responsive">
+                  <table id="descendance-table" class="table table-bordered table-striped table-hover">
+                    <thead>
+                      <tr>
+                          <th scope="col">Modèle</th>
+                          <th scope="col">Auteur</th>
+                          <th scope="col">Téléchargements</th>
+                          <th scope="col">Tâche</th>
+                          <th scope="col">J'aime</th>
+                          <th scope="col">Date de publication</th>
+                          <th scope="col">Dataset utilisé</th>
+                          <th scope="col">Licence</th>
+                          <th scope="col">Distance au modèle recherché</th>
+                          <th scope="col">Ascendants</th>
+                          <th scope="col">Descendants</th>
+                          <th scope="col">Citations</th>
+                      </tr>
+                  </thead>
+                  </table>
+              </div>
+          </div>
+          <hr class="my-5">
+          <div>
+              <h4 class="h4">Ascendance détaillée</h4>
+              <div class="table-responsive">
+                  <table id="ascendance-table" class="table table-bordered table-striped table-hover">
+                    <thead>
+                      <tr>
+                          <th scope="col">Modèle</th>
+                          <th scope="col">Auteur</th>
+                          <th scope="col">Téléchargements</th>
+                          <th scope="col">Tâche</th>
+                          <th scope="col">J'aime</th>
+                          <th scope="col">Date de publication</th>
+                          <th scope="col">Dataset utilisé</th>
+                          <th scope="col">Licence</th>
+                          <th scope="col">Distance au modèle recherché</th>
+                          <th scope="col">Ascendants</th>
+                          <th scope="col">Descendants</th>
+                          <th scope="col">Citations</th>
+                      </tr>
+                  </thead>
+                  </table>
+              </div>
+          </div>
+      </div>
+        <hr class="mt-5">
+    </div>
+    <div id="genealogy-graph-section" style="display: none;" class="mt-5">
+      <div class="row g-4">
+          <div class="col-12 col-lg-8">
+              <div class="card">
+                  <div class="card-header"><h5 class="card-title mb-0">Visualisation de l'arbre généalogique</h5></div>
+                  <div class="card-body">
+                      <div id="sigma-container" data-graph='{{ graph_data | tojson | safe }}'></div>
+                  </div>
+              </div>
+              <div id="node-info-card" class="card mt-3 card-interactive" style="display: none;">                  <div class="card-body">
+                      <h5 class="card-title">Informations du nœud sélectionné</h5>
+                      <div id="node-details" class="mt-2"></div>
+                  </div>
+              </div>
+          </div>
+          <div class="col-12 col-lg-4">
+              <div class="card mb-3">
+                  <div class="card-header"><h5 class="card-title mb-0">Légende - Nœuds</h5></div>
+                  <div class="card-body">
+                      <ul id="legend-nodes" class="list-group list-group-flush">
+                          <li class="list-group-item d-flex align-items-center"><span class="legend-color me-2" style="background-color: #007bff;"></span>Personne (taille = nombre d'abonnés)</li>
+                          <li class="list-group-item d-flex align-items-center"><span class="legend-color me-2" style="background-color: #092d53;"></span>Organisation (taille = nombre d'abonnés)</li>
+                          <li class="list-group-item d-flex align-items-center"><span class="legend-color me-2" style="background-color:#7D7D7D;"></span>Modèle (taille = nombre de téléchargements)</li>
+                      </ul>
+                  </div>
+              </div>
+              <div class="card">
+                  <div class="card-header"><h5 class="card-title mb-0">Légende - Relations</h5></div>
+                  <div class="card-body">
+                      <ul id="legend-edges" class="list-group list-group-flush"></ul>
+                  </div>
+              </div>
+          </div>
+      </div>
+    </div>
+    {% endif %}
+  </main>
+
+  <!-- Pied de page et scripts (inchangés) -->
+  <footer class="bg-dark text-white text-center p-4 mt-auto">
+    <div class="container">
+      <p class="mb-0">Application de recherche et visualisation des relations entre modèles et jeux de données publiés sur la plateforme HuggingFace. © 2025</p>
+    </div>
+  </footer>
+
+  <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+  <script src="https://cdn.datatables.net/1.13.4/js/jquery.dataTables.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz" crossorigin="anonymous"></script>
+  <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 src="{{ url_for('static', filename='js/script.js') }}"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function () {
+      const tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]');
+      const tooltipList = [...tooltipTriggerList].map(tooltipTriggerEl => new bootstrap.Tooltip(tooltipTriggerEl));
+    });
+  </script>
+</body>
+</html>

application_neo4j/templates/search_dataset.html

@@ -0,0 +1,236 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Généalogie des Modèles</title>
+  
+  <!-- CSS de Bootstrap (remplace DSFR) -->
+  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
+  <!-- Icônes Bootstrap (pour les boutons, etc.) -->
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.css">
+  
+  <!-- CSS de DataTables et votre CSS personnalisé (inchangés) -->
+  <link rel="stylesheet" href="https://cdn.datatables.net/1.13.4/css/jquery.dataTables.min.css" />
+  <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+
+  <style>
+    body {
+      font-size: 1.05rem;
+    }
+    .legend-color {
+        width: 1em;
+        height: 1em;
+        display: inline-block;
+        border-radius: 2px;
+    }
+    .legend-color.edge {
+        border-radius: 0;
+        height: 0.25em;
+        transform: translateY(-0.35em);
+    }
+  </style>
+</head>
+
+<body class="d-flex flex-column min-vh-100">
+    <header class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
+    <div class="container">
+      <a class="navbar-brand" href="/">
+        <span class="fw-bold">Généalogie des Modèles</span>
+        <small class="d-block text-muted">Exploration des relations entre modèles et datasets</small>
+      </a>
+    </div>
+  </header>
+
+  <main class="container mt-4 flex-grow-1">
+    <!-- Titre principal et Formulaire (inchangés) -->
+    <div class="row">
+      <div class="col-12">
+        <h1 class="display-5">Recherche dans la base de données HuggingFace</h1>
+        <p class="lead">Explorez la généalogie des modèles et datasets</p>
+      </div>
+    </div>
+    
+    <div class="row g-3 mb-4">
+      <div class="col-12">
+        <form method="POST" action="{{ url_for('findnode') }}" autocomplete="off">
+          <input type="hidden" name="filter" value="{{ search.filter or '' }}">
+    
+          <div class="row g-3 align-items-end">
+            <!-- Champ de recherche -->
+            <div class="col-12 col-md-5">
+              <label for="search-input" class="form-label fw-bold">Nom à rechercher</label>
+              <div class="position-relative">
+                <input type="text" name="name" id="search-input" class="form-control"
+                       placeholder="Taper le nom du dataset suspecté."
+                       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>
+    
+            <!-- Filtres -->
+            <div class="col-12 col-md-3">
+              <label class="form-label fw-bold">Filtres</label>
+              <div class="d-flex gap-3">
+                <div class="form-check">
+                  <input class="form-check-input" type="checkbox" name="filters" value="Model" id="filter-model"
+                         {% if 'Model' in search.filters %}checked{% endif %}>
+                  <label class="form-check-label" for="filter-model">Modèle</label>
+                </div>
+                <div class="form-check">
+                  <input class="form-check-input" type="checkbox" name="filters" value="Dataset" id="filter-dataset"
+                         {% if 'Dataset' in search.filters %}checked{% endif %}>
+                  <label class="form-check-label" for="filter-dataset">Dataset</label>
+                </div>
+              </div>
+            </div>
+    
+            <!-- Profondeur de recherche -->
+            <div class="col-12 col-md-4">
+              <label class="form-label fw-bold">Profondeur de recherche</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" checked>
+                  <label class="form-check-label" for="depth-unlimited">Illimitée</label>
+                </div>
+                <div class="input-group input-group-sm">
+                  <span class="input-group-text">Limité à:</span>
+                  <input class="form-control" type="number" name="depth" id="depth"
+                         value="{{ request.form.depth }}" min="1" max="5" disabled>
+                </div>
+              </div>
+            </div>
+          </div>
+    
+  
+    {% if message %}
+    <div class="alert alert-info mt-3"><p class="mb-0">{{ message }}</p></div>
+    {% endif %}
+    {% if graph_data.nodes %}
+      {% set searched_node = (graph_data.nodes | selectattr('id', 'equalto', search.name) | list | first) or {} %}
+      <div class="row justify-content-center align-items-stretch g-4">        
+        <div class="col-12 col-lg-4 " id="center-column">
+            <h4 class="h5 text-center mb-3">DATASET RECHERCHÉ</h4>
+            <a href="https://huggingface.co/datasets/{{ searched_node.id }}" target="_blank" rel="noopener noreferrer" class="text-white">
+            <div class="card card-recherche text-center border-primary border-2 ">
+                <div class="card-header bg-primary text-white">
+                    <h5 class="card-title h6 mb-0 ">
+                            {{ searched_node.id }}
+                    </h5>
+                </div>
+                <div class="card-body p-3">
+                    <div class="row">
+                        <div class="col">
+                            <p class="fw-bold mb-0">{{ "{:,.0f}".format((graph_data.models_count[0] or 0) | int).replace(',', ' ') }}</p>
+                            <p class="small text-muted">modèle(s) utilisent ce dataset
+                              <i class="bi bi-info-circle-fill ms-2"></i>
+                            </p>
+                          </div>
+                    </div>
+                    <div class="row mt-2">
+                        <div class="col"><p class="fw-bold mb-0">{{ "{:,.0f}".format((searched_node.downloads or 0) | int).replace(',', ' ') }}</p><p class="small text-muted">téléchargement(s)</p></div>
+                    </div>
+                    <div class="mt-2"> 
+                        {% if searched_node.createdAt_dataset %}<span class="badge bg-light text-dark">Publié le: {{ searched_node.createdAt_dataset }}</span>{% endif %}
+                    </div>
+                    <hr>
+                  </a>
+                    <button id="show-graph-btn" class="btn btn-secondary"><i class="bi bi-diagram-3 me-1"></i>Voir l'arbre généalogique</button>
+                </div>
+            </div>
+        </div>
+      </div>
+      {% endif %}
+    
+    <!-- SECTION 2 ET 3 (inchangées) -->
+    <div class="row mt-5 mb-5">
+      <hr class="mb-5">
+      <div class="col-12">
+          <div class="mb-5">
+              <h4 class="h4">Les modèles entraînés sur ce dataset</h4>
+              <div class="table-responsive">
+                  <table id="train-table" class="table table-bordered table-striped table-hover">
+                    <thead>
+                      <tr>
+                          <th scope="col">Modèle</th>
+                          <th scope="col">Auteur</th>
+                          <th scope="col">Téléchargements</th>
+                          <th scope="col">Tâche</th>
+                          <th scope="col">J'aime</th>
+                          <th scope="col">Date de publication</th>
+                          <th scope="col">Dataset utilisé</th>
+                          <th scope="col">Licence</th>
+                          <th scope="col">Ascendants</th>
+                          <th scope="col">Descendants</th>
+                          <th scope="col">Citations</th>
+                      </tr>
+                  </thead>
+                  <tbody>
+                    <!-- DataTables remplira ici -->
+                  </tbody>
+                  </table>
+              </div>
+          </div>
+      </div>
+    </div>
+    <div id="genealogy-graph-section" style="display: none;" class="mt-5">
+      <div class="row g-4">
+          <div class="col-12 col-lg-8">
+              <div class="card">
+                  <div class="card-header"><h5 class="card-title mb-0">Visualisation de l'arbre généalogique</h5></div>
+                  <div class="card-body">
+                      <div id="sigma-container" data-graph='{{ graph_data | tojson | safe }}'></div>
+                  </div>
+              </div>
+              <div id="node-info-card" class="card mt-3 card-interactive" style="display: none;">                  <div class="card-body">
+                      <h5 class="card-title">Informations du nœud sélectionné</h5>
+                      <div id="node-details" class="mt-2"></div>
+                  </div>
+              </div>
+          </div>
+          <div class="col-12 col-lg-4">
+              <div class="card mb-3">
+                  <div class="card-header"><h5 class="card-title mb-0">Légende - Nœuds</h5></div>
+                  <div class="card-body">
+                      <ul id="legend-nodes" class="list-group list-group-flush">
+                        <li class="list-group-item d-flex align-items-center"><span class="legend-color me-2" style="background-color: #ffc107;"></span>Dataset (taille = nombre de téléchargements)</li>
+                        <li class="list-group-item d-flex align-items-center"><span class="legend-color me-2" style="background-color: #007bff;"></span>Personne (taille = nombre d'abonnés)</li>
+                        <li class="list-group-item d-flex align-items-center"><span class="legend-color me-2" style="background-color: #092d53;"></span>Organisation (taille = nombre d'abonnés)</li>
+                        <li class="list-group-item d-flex align-items-center"><span class="legend-color me-2" style="background-color:#7D7D7D;"></span>Modèle (taille = nombre de téléchargements)</li>
+                      </ul>
+                  </div>
+              </div>
+              <div class="card">
+                  <div class="card-header"><h5 class="card-title mb-0">Légende - Relations</h5></div>
+                  <div class="card-body">
+                      <ul id="legend-edges" class="list-group list-group-flush"></ul>
+                  </div>
+              </div>
+          </div>
+      </div>
+    </div>
+  </main>
+
+  <!-- Pied de page et scripts (inchangés) -->
+  <footer class="bg-dark text-white text-center p-4 mt-auto">
+    <div class="container">
+      <p class="mb-0">Application de recherche et visualisation des relations entre modèles et jeux de données publiés sur la plateforme HuggingFace. © 2025</p>
+    </div>
+  </footer>
+
+  <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+  <script src="https://cdn.datatables.net/1.13.4/js/jquery.dataTables.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz" crossorigin="anonymous"></script>
+  <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 src="{{ url_for('static', filename='js/script_dataset.js') }}"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function () {
+      const tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]');
+      const tooltipList = [...tooltipTriggerList].map(tooltipTriggerEl => new bootstrap.Tooltip(tooltipTriggerEl));
+    });
+  </script>
+</body>
+</html>

application_neo4j/utils.py

@@ -0,0 +1,246 @@
+import time
+import pandas as pd
+from collections import namedtuple
+from tqdm import tqdm
+import ast
+from concurrent.futures import ThreadPoolExecutor
+import os
+import multiprocessing
+from neo4j.exceptions import TransientError 
+
+    
+# --- Paramètres ---
+BATCH_SIZE = 5000
+NUM_THREADS = multiprocessing.cpu_count()
+PROCESSED_IDS_FILE = "processed_ids.txt"
+
+
+def reset_database(driver):
+    """
+    Efface TOUTES les données de la base Neo4j ET le fichier de suivi des IDs traités.
+    À n'utiliser que pour une réinitialisation complète.
+    """
+    # Étape 1 : Vider la base de données
+    with driver.session() as session:
+        result = session.run("RETURN 1 AS test")
+        print("Connexion OK, test result:", result.single()["test"])
+        session.run("MATCH (n) DETACH DELETE n")
+        
+    # Étape 2 : Supprimer le fichier de suivi pour garantir une réimportation propre
+    if os.path.exists(PROCESSED_IDS_FILE):
+        os.remove(PROCESSED_IDS_FILE)
+
+
+def parse_list_field(value):
+    """
+    Parse une chaîne de caractères qui représente une liste (ex: "['model1', 'model2']")
+    en une véritable liste Python. Gère les cas où la valeur est simple ou vide.
+    """
+    if isinstance(value, str) and pd.notna(value):
+        try:
+            parsed = ast.literal_eval(value)
+            if isinstance(parsed, list):
+                return parsed
+        except Exception:
+            pass
+    return [value] if value else []
+
+def load_processed_ids():
+    """Charge l'ensemble des IDs déjà traités depuis le fichier de suivi."""
+    if os.path.exists(PROCESSED_IDS_FILE):
+        with open(PROCESSED_IDS_FILE, "r", encoding="utf-8") as f:
+            return set(line.strip() for line in f)
+    return set()
+
+def append_processed_ids(ids):
+    """Ajoute une liste d'IDs au fichier de suivi."""
+    with open(PROCESSED_IDS_FILE, "a", encoding="utf-8") as f:
+        for i in ids:
+            f.write(f"{i}\n")
+
+def run_with_retry(session, query, parameters=None, retries=3, delay=1):
+    """
+    Exécute une requête Cypher avec une logique de réessai en cas d'erreur transitoire
+    """
+    for attempt in range(retries):
+        try:
+            session.run(query, parameters)
+            return
+        except TransientError as e:
+            if attempt < retries - 1:
+                time.sleep(delay)
+                continue
+            else:
+                raise
+
+def process_batch(rows, fieldnames, driver):
+    """
+    Traite un lot (batch) de lignes du CSV et les insère dans Neo4j.
+    C'est la fonction "worker" qui sera exécutée en parallèle.
+    """
+    normalized_fields = [f.strip().replace(" ", "_").replace("-", "_") for f in fieldnames]
+    Row = namedtuple("Row", normalized_fields)
+    ids_successfully_processed = []
+
+    with driver.session() as session:
+        for row in rows:
+            obj = Row(**{k: v if v != "" else None for k, v in row.items()})
+            data = obj._asdict()
+
+            if not data.get("id") or pd.isna(data.get("id")) or pd.isna(data.get("author")) or str(data.get("id")).strip() == "":
+                continue  # Ignore si l'ID est manquant
+
+            base_models = parse_list_field(data.get("base_model"))
+            base_model_rels = parse_list_field(data.get("base_model_relation"))
+            datasets = parse_list_field(data.get("dataset"))
+            orgs_author_model = parse_list_field(data.get("organizations_author_model"))
+            orgs_author_dataset = parse_list_field(data.get("organizations_author_dataset"))
+            # Insertion du modèle et de son auteur
+            if data.get("id") and data.get("author"):
+                run_with_retry(session, """
+                    MERGE (m:Model {name: $id})
+                    SET m.downloads = $downloadsAllTime,
+                        m.task = $pipeline_tag,
+                        m.createdAt = $createdAt, 
+                        m.parameters = $total_parameters_formatted,
+                        m.likes = $likes,
+                        m.license = $license
+                    MERGE (a:Author {name: $author})
+                    SET a.type = $author_type,
+                        a.followers = $followers_count_author_model
+                    WITH a
+                    MATCH (m:Model {name: $id})
+                    MERGE (a)-[p:POSTED]->(m)
+                    SET p.name = "A publié"
+                """, data)
+
+                # Lien entre l’auteur et ses organisations
+                orgs_data = [
+                    {"org": org, "author": data["author"]}
+                    for org in orgs_author_model
+                    if pd.notna(org) and data.get("author")
+                ]
+                if orgs_data:
+                    run_with_retry(session, """
+                        UNWIND $orgs_data AS row
+                        MERGE (o:Author {name: row.org})
+                        WITH o, row
+                        MATCH (a:Author {name: row.author})
+                        MERGE (a)-[r:IS_IN]->(o)
+                        SET r.name = "Fait partie de cette organisation", a.type = "personne",o.type = "organisation"
+                    """, {"orgs_data": orgs_data})
+
+                # Lien entre modèles et base models
+                
+                if len(base_models) == len(base_model_rels)  :
+                    base_model_data = [
+                    {"bm": bm, "id": data["id"], "rel": rel}
+                    for bm, rel in zip(base_models, base_model_rels)
+                    if pd.notna(bm) and data.get("id")
+                ]
+                elif len(base_models) >len(base_model_rels) :
+                    if base_model_rels==['merge'] : 
+                        base_model_data = [
+                            {"bm": bm, "id": data["id"], "rel": "merge"}
+                            for bm in base_models
+                            if pd.notna(bm) and data.get("id")
+                        ]
+                    else : 
+                        base_model_data = [
+                    {"bm": bm, "id": data["id"], "rel": "A généré"}
+                    for bm in base_models
+                    if pd.notna(bm) and data.get("id")
+                ]
+
+                if base_model_data:
+                    run_with_retry(session, """
+                        UNWIND $base_model_data AS row
+                        MERGE (bm:Model {name: row.bm})
+                        WITH bm, row
+                        MATCH (m:Model {name: row.id})
+                        MERGE (bm)-[r:USED_IN]->(m)
+                        SET r.name = row.rel
+                    """, {"base_model_data": base_model_data})
+
+                # Lien entre modèles et datasets
+                datasets_data = [
+                    {"ds": ds, "downloads": data.get("downloads_dataset"),
+                    "createdAt_dataset": data.get("createdAt_dataset"), "id": data["id"]}
+                    for ds in datasets
+                    if pd.notna(ds) and data.get("id")
+                ]
+                if datasets_data and data.get("author_dataset") and data.get("dataset") and pd.notna(data.get("author_dataset")):
+                    run_with_retry(session, """
+                        UNWIND $datasets_data AS row
+                        MERGE (d:Dataset {name: row.ds})
+                        SET d.downloads = row.downloads,
+                            d.createdAt_dataset = row.createdAt_dataset
+                        WITH d, row
+                        MATCH (m:Model {name: row.id})
+                        MERGE (d)-[r:USED_IN]->(m)
+                        SET r.name = "A été utilisé dans ce modèle"
+                    """, {"datasets_data": datasets_data})
+
+                # Insertion de l’auteur du dataset
+                    run_with_retry(session, """
+                        MERGE (ad:Author {name: $author_dataset})
+                        SET ad.type = $author_dataset_type,
+                            ad.followers = $followers_count_author_dataset
+                        WITH ad
+                        MATCH (d:Dataset {name: $dataset})
+                        MERGE (ad)-[r:POSTED]->(d)
+                        SET r.name = "A publié"
+                    """, data)
+
+                # Lien entre l’auteur du dataset et ses organisations
+                orgs_dataset_data = [
+                    {"org": org, "author_dataset": data["author_dataset"]}
+                    for org in orgs_author_dataset
+                    if pd.notna(org) and data.get("author_dataset")
+                ]
+                if orgs_dataset_data and pd.notna(data.get("author_dataset")):
+                    run_with_retry(session, """
+                        UNWIND $orgs_data AS row
+                        MERGE (o:Author {name: row.org})
+                        WITH o, row
+                        MATCH (ad:Author {name: row.author_dataset})
+                        MERGE (ad)-[r:IS_IN]->(o)
+                        SET r.name = "Fait partie de cette organisation",  ad.type = "personne",o.type = "organisation"
+                    """, {"orgs_data": orgs_dataset_data})
+
+            ids_successfully_processed.append(data["id"])
+
+        if ids_successfully_processed:
+            append_processed_ids(ids_successfully_processed)
+
+# Insère les données depuis un CSV en parallèle, par lots
+def insert_parallel(csv_file_path, driver, processed_ids):
+    # Lecture et nettoyage via pandas
+    df = pd.read_csv(csv_file_path)
+    df = df.loc[:, ~df.columns.str.contains('^Unnamed')]
+     # Supprimer les lignes où 'id' est NaN ou vide
+    df = df[~df["id"].isnull()]
+    df = df[df["id"].astype(str).str.strip() != ""]
+
+    # Ne conserver que les lignes dont l'ID n’a pas encore été traitée
+    df = df[~df["id"].isin(processed_ids)]
+
+    records = df.to_dict(orient="records")
+    fieldnames = list(df.columns)
+
+    batch = []
+    futures = []
+
+    with ThreadPoolExecutor(max_workers=NUM_THREADS) as executor:
+        for row in tqdm(records, desc="Lecture CSV"):
+            batch.append(row)
+            if len(batch) == BATCH_SIZE:
+                futures.append(executor.submit(process_batch, batch.copy(), fieldnames, driver))
+                batch = []
+
+        if batch:
+            futures.append(executor.submit(process_batch, batch.copy(), fieldnames, driver))
+
+        for future in tqdm(futures, desc="Traitement parallélisé"):
+            future.result()
+

requirements.txt

@@ -0,0 +1,25 @@
+fastjsonschema==2.21.1
+flask==3.1.0
+graphdatascience==1.17
+httpx==0.28.1
+huggingface-hub==0.31.4
+ipysigma==0.24.5
+ipywidgets==8.1.7
+itables==2.3.0
+jinja2==3.1.6
+joblib==1.5.0
+jsonschema==4.23.0
+matplotlib==3.10.3
+multimethod==2.0
+neo4j==5.28.2
+networkx==2.8.8
+numpy==2.2.5
+pandas==2.2.3
+plotly==6.0.1
+pyarrow==20.0.0
+requests==2.32.3
+scikit-learn==1.7.0
+scipy==1.15.3
+seaborn==0.13.2
+tqdm==4.67.1
+urllib3==2.4.0

start.sh

@@ -0,0 +1,15 @@
+# load database backup
+mkdir -p /backups
+wget --no-clobber --header="Authorization: Bearer $HF_TOKEN" https://huggingface.co/datasets/lhoestq/dump-neo4j/resolve/main/system.dump -P /backups/
+wget --no-clobber --header="Authorization: Bearer $HF_TOKEN" https://huggingface.co/datasets/lhoestq/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 &
+# start tool
+python3 /application_neo4j/app.py neo4j genealogiemodeles &
+# wait for any process to exit
+wait -n
+# exit with status of process that exited first
+exit $?