api.py

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)