Upload api.py

api.py

@@ -0,0 +1,255 @@
+import os
+import requests
+from bs4 import BeautifulSoup
+from fastapi import FastAPI, HTTPException
+from neo4j import GraphDatabase, basic_auth
+import google.generativeai as genai
+import logging # Import du module logging
+
+# --- Configuration du Logging ---
+# Configuration de base du logger pour afficher les messages INFO et supérieurs.
+# Le format inclut le timestamp, le niveau du log, et le message.
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler() # Affichage des logs dans la console (stderr par défaut)
+        # Vous pourriez ajouter ici un logging.FileHandler("app.log") pour écrire dans un fichier
+    ]
+)
+logger = logging.getLogger(__name__) # Création d'une instance de logger pour ce module
+
+# --- Configuration des variables d'environnement ---
+NEO4J_URI = os.getenv("NEO4J_URI")
+NEO4J_USER = os.getenv("NEO4J_USER")
+NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+# Validation des configurations essentielles
+if not NEO4J_URI or not NEO4J_USER or not NEO4J_PASSWORD:
+    logger.critical("ERREUR CRITIQUE: Les variables d'environnement NEO4J_URI, NEO4J_USER, et NEO4J_PASSWORD doivent être définies.")
+    # Dans une application réelle, vous pourriez vouloir quitter ou empêcher FastAPI de démarrer.
+    # Pour l'instant, nous laissons l'application essayer et échouer lors de l'exécution si elles manquent.
+
+# Initialisation de l'application FastAPI
+app = FastAPI(
+    title="Arxiv to Neo4j Importer",
+    description="API pour récupérer les données d'articles de recherche depuis Arxiv, les résumer avec Gemini, et les ajouter à Neo4j.",
+    version="1.0.0"
+)
+
+# --- Initialisation du client API Gemini ---
+gemini_model = None
+if GEMINI_API_KEY:
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)
+        gemini_model = genai.GenerativeModel(model_name="gemini-2.5-flash-preview-05-20") # Modèle spécifié
+        logger.info("Client API Gemini initialisé avec succès.")
+    except Exception as e:
+        logger.warning(f"AVERTISSEMENT: Échec de l'initialisation du client API Gemini: {e}. La génération de résumés sera affectée.")
+else:
+    logger.warning("AVERTISSEMENT: La variable d'environnement GEMINI_API_KEY n'est pas définie. La génération de résumés sera désactivée.")
+
+# --- Fonctions Utilitaires (Adaptées de votre script) ---
+
+def get_content(number: str, node_type: str) -> str:
+    """Récupère le contenu HTML brut depuis Arxiv ou d'autres sources."""
+    redirect_links = {
+        "Patent": f"https://patents.google.com/patent/{number}/en",
+        "ResearchPaper": f"https://arxiv.org/abs/{number}"
+    }
+
+    url = redirect_links.get(node_type)
+    if not url:
+        logger.warning(f"Type de noeud inconnu: {node_type} pour le numéro {number}")
+        return ""
+
+    try:
+        response = requests.get(url, timeout=10) # Ajout d'un timeout
+        response.raise_for_status() # Lève une HTTPError pour les mauvaises réponses (4XX ou 5XX)
+        return response.content.decode('utf-8', errors='replace').replace("\n", "")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Erreur de requête pour {node_type} numéro: {number} à l'URL {url}: {e}")
+        return ""
+    except Exception as e:
+        logger.error(f"Une erreur inattendue est survenue dans get_content pour {number}: {e}")
+        return ""
+
+def extract_research_paper_arxiv(rp_number: str, node_type: str) -> dict:
+    """Extrait les informations d'un article de recherche Arxiv et génère un résumé."""
+    raw_content = get_content(rp_number, node_type)
+    
+    rp_data = {
+        "document": f"Arxiv {rp_number}", # ID pour l'article
+        "arxiv_id": rp_number,
+        "title": "Erreur lors de la récupération du contenu ou contenu non trouvé",
+        "abstract": "Erreur lors de la récupération du contenu ou contenu non trouvé",
+        "summary": "Résumé non généré" # Résumé par défaut
+    }
+
+    if not raw_content:
+        logger.warning(f"Aucun contenu récupéré pour l'ID Arxiv: {rp_number}")
+        return rp_data # Retourne les données d'erreur par défaut
+
+    try:
+        soup = BeautifulSoup(raw_content, 'html.parser')
+
+        # Extraction du Titre
+        title_tag = soup.find('h1', class_='title')
+        if title_tag and title_tag.find('span', class_='descriptor'):
+            title_text_candidate = title_tag.find('span', class_='descriptor').next_sibling
+            if title_text_candidate and isinstance(title_text_candidate, str):
+                 rp_data["title"] = title_text_candidate.strip()
+            else: 
+                rp_data["title"] = title_tag.get_text(separator=" ", strip=True).replace("Title:", "").strip()
+        elif title_tag : # Fallback si le span descriptor n'est pas là mais h1.title existe
+             rp_data["title"] = title_tag.get_text(separator=" ", strip=True).replace("Title:", "").strip()
+
+
+        # Extraction de l'Abstract
+        abstract_tag = soup.find('blockquote', class_='abstract')
+        if abstract_tag:
+            abstract_text = abstract_tag.get_text(strip=True)
+            if abstract_text.lower().startswith('abstract'):
+                abstract_text = abstract_text[len('abstract'):].strip()
+            rp_data["abstract"] = abstract_text
+        
+        # Marquer si le titre ou l'abstract ne sont toujours pas trouvés
+        if rp_data["title"] == "Erreur lors de la récupération du contenu ou contenu non trouvé" and not title_tag:
+            rp_data["title"] = "Titre non trouvé sur la page"
+        if rp_data["abstract"] == "Erreur lors de la récupération du contenu ou contenu non trouvé" and not abstract_tag:
+            rp_data["abstract"] = "Abstract non trouvé sur la page"
+
+        # Génération du résumé avec l'API Gemini si disponible et si l'abstract existe
+        if gemini_model and rp_data["abstract"] and \
+           not rp_data["abstract"].startswith("Erreur lors de la récupération du contenu") and \
+           not rp_data["abstract"].startswith("Abstract non trouvé"):
+            prompt = f"""Vous êtes un expert en standardisation 3GPP. Résumez les informations clés du document fourni en anglais technique simple, pertinent pour identifier les problèmes clés potentiels.
+            Concentrez-vous sur les défis, les lacunes ou les aspects nouveaux.
+            Voici le document: <document>{rp_data['abstract']}<document>"""
+            
+            try:
+                response = gemini_model.generate_content(prompt)
+                rp_data["summary"] = response.text
+                logger.info(f"Résumé généré pour l'ID Arxiv: {rp_number}")
+            except Exception as e:
+                logger.error(f"Erreur lors de la génération du résumé avec Gemini pour l'ID Arxiv {rp_number}: {e}")
+                rp_data["summary"] = "Erreur lors de la génération du résumé (échec API)"
+        elif not gemini_model:
+            rp_data["summary"] = "Résumé non généré (client API Gemini non disponible)"
+        else:
+            rp_data["summary"] = "Résumé non généré (Abstract indisponible ou problématique)"
+
+    except Exception as e:
+        logger.error(f"Erreur lors de l'analyse du contenu pour l'ID Arxiv {rp_number}: {e}")
+    
+    return rp_data
+
+def add_nodes_to_neo4j(driver, data_list: list, node_label: str):
+    """Ajoute une liste de noeuds à Neo4j dans une seule transaction."""
+    if not data_list:
+        logger.warning("Aucune donnée fournie à add_nodes_to_neo4j.")
+        return 0
+
+    query = (
+        f"UNWIND $data as properties "
+        f"MERGE (n:{node_label} {{arxiv_id: properties.arxiv_id}}) " # Utilise MERGE pour l'idempotence
+        f"ON CREATE SET n = properties "
+        f"ON MATCH SET n += properties" # Met à jour les propriétés si le noeud existe déjà
+    )
+
+    try:
+        with driver.session(database="neo4j") as session: # Spécifier la base de données si non défaut
+            result = session.execute_write(lambda tx: tx.run(query, data=data_list).consume())
+            nodes_created = result.counters.nodes_created
+            nodes_updated = result.counters.properties_set - (nodes_created * len(data_list[0])) if data_list and nodes_created >=0 else result.counters.properties_set # Estimation
+            
+            if nodes_created > 0:
+                logger.info(f"{nodes_created} nouveau(x) noeud(s) {node_label} ajouté(s) avec succès.")
+            # properties_set compte toutes les propriétés définies, y compris sur les noeuds créés.
+            # Pour les noeuds mis à jour, il faut une logique plus fine si on veut un compte exact des noeuds *juste* mis à jour.
+            # Le plus simple est de regarder si des propriétés ont été mises à jour au-delà de la création.
+            # Note: result.counters.properties_set compte le nombre total de propriétés définies ou mises à jour.
+            # Si un noeud est créé, toutes ses propriétés sont "set". Si un noeud est matché, les propriétés sont "set" via ON MATCH.
+            # Un compte plus précis des "noeuds mis à jour (non créés)" est plus complexe avec UNWIND et MERGE.
+            # On peut se contenter de savoir combien de noeuds ont été affectés au total.
+            summary = result.summary
+            affected_nodes = summary.counters.nodes_created + summary.counters.nodes_deleted # ou autre logique selon la requête
+            logger.info(f"Opération MERGE pour {node_label}: {summary.counters.nodes_created} créé(s), {summary.counters.properties_set} propriétés affectées.")
+
+            return nodes_created # Retourne le nombre de noeuds effectivement créés
+    except Exception as e:
+        logger.error(f"Erreur Neo4j - Échec de l'ajout/mise à jour des noeuds {node_label}: {e}")
+        raise HTTPException(status_code=500, detail=f"Erreur base de données Neo4j: {e}")
+
+
+# --- Endpoint FastAPI ---
+
+@app.post("/add_research_paper/{arxiv_id}", status_code=201) # 201 Created pour la création réussie
+async def add_single_research_paper(arxiv_id: str):
+    """
+    Récupère un article de recherche d'Arxiv par son ID, extrait les informations,
+    génère un résumé, et l'ajoute/met à jour comme un noeud 'ResearchPaper' dans Neo4j.
+    """
+    node_type = "ResearchPaper"
+    logger.info(f"Traitement de la requête pour l'ID Arxiv: {arxiv_id}")
+
+    if not NEO4J_URI or not NEO4J_USER or not NEO4J_PASSWORD:
+        logger.error("Les détails de connexion à la base de données Neo4j ne sont pas configurés sur le serveur.")
+        raise HTTPException(status_code=500, detail="Les détails de connexion à la base de données Neo4j ne sont pas configurés sur le serveur.")
+
+    # Étape 1: Extraire les données de l'article
+    paper_data = extract_research_paper_arxiv(arxiv_id, node_type)
+
+    if paper_data["title"].startswith("Erreur lors de la récupération du contenu") or paper_data["title"] == "Titre non trouvé sur la page":
+        logger.warning(f"Impossible de récupérer ou d'analyser le contenu pour l'ID Arxiv {arxiv_id}. Titre: {paper_data['title']}")
+        raise HTTPException(status_code=404, detail=f"Impossible de récupérer ou d'analyser le contenu pour l'ID Arxiv {arxiv_id}. Titre: {paper_data['title']}")
+
+    # Étape 2: Ajouter/Mettre à jour dans Neo4j
+    driver = None # Initialisation pour le bloc finally
+    try:
+        auth_token = basic_auth(NEO4J_USER, NEO4J_PASSWORD)
+        driver = GraphDatabase.driver(NEO4J_URI, auth=auth_token)
+        driver.verify_connectivity()
+        logger.info("Connecté avec succès à Neo4j.")
+        
+        nodes_created_count = add_nodes_to_neo4j(driver, [paper_data], node_type)
+            
+        if nodes_created_count > 0 :
+            message = f"L'article de recherche {arxiv_id} a été ajouté avec succès à Neo4j."
+            status_code = 201 # Created
+        else:
+            # Si MERGE a trouvé un noeud existant et l'a mis à jour, nodes_created_count sera 0.
+            # On considère cela comme un succès (idempotence).
+            message = f"L'article de recherche {arxiv_id} a été traité (potentiellement mis à jour s'il existait déjà)."
+            status_code = 200 # OK (car pas de nouvelle création, mais opération réussie)
+        
+        logger.info(message)
+        return {
+            "message": message,
+            "data": paper_data,
+            "status_code_override": status_code # Pour information, FastAPI utilisera le status_code de l'endpoint ou celui de l'HTTPException
+        }
+
+    except HTTPException as e: # Re-lever les HTTPExceptions
+        logger.error(f"HTTPException lors de l'opération Neo4j pour {arxiv_id}: {e.detail}")
+        raise e
+    except Exception as e:
+        logger.error(f"Une erreur inattendue est survenue lors de l'opération Neo4j pour {arxiv_id}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Une erreur serveur inattendue est survenue: {e}")
+    finally:
+        if driver:
+            driver.close()
+            logger.info("Connexion Neo4j fermée.")
+
+
+# --- Pour exécuter cette application (exemple avec uvicorn) ---
+# 1. Sauvegardez ce code sous main.py
+# 2. Définissez les variables d'environnement: NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD, GEMINI_API_KEY
+# 3. Installez les dépendances: pip install fastapi uvicorn requests beautifulsoup4 neo4j google-generativeai python-dotenv
+#    (python-dotenv est utile pour charger les fichiers .env localement)
+# 4. Exécutez avec Uvicorn: uvicorn main:app --reload
+#
+# Exemple d'utilisation avec curl après avoir démarré le serveur:
+# curl -X POST http://127.0.0.1:8000/add_research_paper/2305.12345
+# (Remplacez 2305.12345 par un ID Arxiv valide)