maj app pour recup les data sur le db

app.py

@@ -81,201 +81,124 @@ class StatsResponse(BaseModel):
 # SEARCH ENGINE - Recherche locale optimisée
 # ============================================================================
 
-class LocalSearchEngine:
-    """Moteur de recherche local ultra-rapide avec fuzzy matching"""
-    
-    def __init__(self, documents_file: Path):
-        self.documents_file = documents_file
-        self.documents = []
-        self.load_documents()
-    
-    def load_documents(self):
-        """Charge les documents depuis le fichier JSON"""
-        if self.documents_file.exists():
-            try:
-                with open(self.documents_file, 'r', encoding='utf-8') as f:
-                    self.documents = json.load(f)
-                logger.info(f"✅ {len(self.documents)} documents chargés")
-            except Exception as e:
-                logger.error(f"Erreur chargement documents: {e}")
-                self.documents = []
-        else:
-            self.documents = []
-    
-    def reload(self):
-        """Recharge les documents (après scraping)"""
-        self.load_documents()
+# ============================================================================
+# SEARCH ENGINE - Recherche MongoDB Native
+# ============================================================================
+
+from db.mongo_connector import db as mongo_db
+
+class MongoSearchEngine:
+    """Moteur de recherche connecté directement à MongoDB"""
     
-    def fuzzy_match(self, text: str, query: str, threshold: float = 0.6) -> bool:
-        """Fuzzy matching simple basé sur la distance de Levenshtein"""
-        text = text.lower()
-        query = query.lower()
-        
-        # Recherche exacte d'abord
-        if query in text:
-            return True
-        
-        # Fuzzy matching pour les mots individuels
-        query_words = query.split()
-        text_words = text.split()
-        
-        for q_word in query_words:
-            for t_word in text_words:
-                # Calcul de similarité simple
-                if len(q_word) < 3:
-                    if q_word == t_word:
-                        return True
-                else:
-                    # Tolérance aux fautes pour mots > 3 caractères
-                    if self._similarity(q_word, t_word) >= threshold:
-                        return True
-        
-        return False
+    def __init__(self):
+        self.collection = mongo_db["documents"]
     
-    def _similarity(self, s1: str, s2: str) -> float:
-        """Calcule la similarité entre deux chaînes (0-1)"""
-        if s1 == s2:
-            return 1.0
-        
-        # Distance de Levenshtein simplifiée
-        len_s1, len_s2 = len(s1), len(s2)
-        if abs(len_s1 - len_s2) > 2:
-            return 0.0
-        
-        # Compte les caractères communs
-        common = sum(1 for a, b in zip(s1, s2) if a == b)
-        max_len = max(len_s1, len_s2)
-        
-        return common / max_len if max_len > 0 else 0.0
+    async def reload(self):
+        """Pas nécessaire avec MongoDB (temps réel)"""
+        pass
     
-    def search(
+    async def search(
         self,
         query: str,
         pays: Optional[str] = None,
         langue: Optional[str] = None,
-        limit: int = 10,
+        limit: int = 20,
         fuzzy: bool = True
     ) -> List[Dict[str, Any]]:
-        """Recherche dans les documents avec scoring"""
+        """Recherche dans MongoDB avec Regex (Simple & Efficace sans Atlas Search)"""
         
-        results = []
-        query_lower = query.lower()
+        filter_query = {}
         
-        for doc in self.documents:
-            score = 0.0
-            
-            # Filtres
-            if pays and doc.get('pays') != pays:
-                continue
-            if langue and doc.get('langue') != langue:
-                continue
+        # Filtres exacts
+        if pays and pays != "Tous":
+            filter_query["pays"] = pays
+        if langue and langue != "Toutes":
+            filter_query["langue"] = langue
             
-            # Scoring
-            titre = doc.get('titre', '')
-            texte = doc.get('texte', '')
+        # Recherche texte (Regex insensible à la case)
+        if query:
+            regex_pattern = {"$regex": query, "$options": "i"}
+            filter_query["$or"] = [
+                {"titre": regex_pattern},
+                {"texte": regex_pattern},
+                {"tags": regex_pattern}
+            ]
             
-            if fuzzy:
-                # Recherche permissive
-                if self.fuzzy_match(titre, query):
-                    score += 10.0  # Boost titre
-                if self.fuzzy_match(texte, query):
-                    score += 5.0
-            else:
-                # Recherche exacte
-                if query_lower in titre.lower():
-                    score += 10.0
-                if query_lower in texte.lower():
-                    score += 5.0
+        try:
+            cursor = self.collection.find(filter_query).limit(limit).sort("date", -1)
+            results = await cursor.to_list(length=limit)
             
-            # Boost par pertinence
-            if 'tags' in doc:
-                for tag in doc.get('tags', []):
-                    if query_lower in tag.lower():
-                        score += 3.0
-            
-            if score > 0:
-                results.append({
-                    **doc,
-                    '_score': score
-                })
-        
-        # Tri par score décroissant
-        results.sort(key=lambda x: x['_score'], reverse=True)
-        
-        return results[:limit]
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """Retourne les statistiques de la base"""
-        pays_count = {}
-        langues_count = {}
-        sources_count = {}
-        
-        for doc in self.documents:
-            # Pays
-            pays = doc.get('pays', 'Inconnu')
-            pays_count[pays] = pays_count.get(pays, 0) + 1
+            # Conversion ObjectId -> str
+            for doc in results:
+                if '_id' in doc:
+                    doc['_id'] = str(doc['_id'])
+                # Ajout d'un score fictif pour compatibilité frontend
+                doc['_score'] = 1.0 
+                
+            return results
+        except Exception as e:
+            logger.error(f"Erreur recherche MongoDB: {e}")
+            return []
+
+    async def get_stats(self) -> Dict[str, Any]:
+        """Retourne les statistiques agrégées depuis MongoDB"""
+        try:
+            total = await self.collection.count_documents({})
             
-            # Langues
-            langue = doc.get('langue', 'Inconnu')
-            langues_count[langue] = langues_count.get(langue, 0) + 1
-            
-            # Sources
-            source_url = doc.get('source_url', '')
-            if source_url:
-                domain = source_url.split('/')[2] if len(source_url.split('/')) > 2 else 'Inconnu'
-                sources_count[domain] = sources_count.get(domain, 0) + 1
-        
-        return {
-            'total_documents': len(self.documents),
-            'pays': pays_count,
-            'langues': langues_count,
-            'sources': sources_count,
-            'derniere_mise_a_jour': datetime.now().isoformat()
-        }
-
-# Instance globale du moteur de recherche
-search_engine = LocalSearchEngine(DOCUMENTS_FILE)
+            pipeline_pays = [{"$group": {"_id": "$pays", "count": {"$sum": 1}}}]
+            pays_data = await self.collection.aggregate(pipeline_pays).to_list(length=100)
+            pays_count = {d["_id"]: d["count"] for d in pays_data if d["_id"]}
+
+            pipeline_langue = [{"$group": {"_id": "$langue", "count": {"$sum": 1}}}]
+            langue_data = await self.collection.aggregate(pipeline_langue).to_list(length=100)
+            langues_count = {d["_id"]: d["count"] for d in langue_data if d["_id"]}
+
+            # Pour les sources, on fait une estimation ou on extrait le domaine
+            # Ici simplifié : on compte juste les total
+            sources_count = {"MongoDB": total}
+
+            return {
+                'total_documents': total,
+                'pays': pays_count,
+                'langues': langues_count,
+                'sources': sources_count,
+                'derniere_mise_a_jour': datetime.now().isoformat()
+            }
+        except Exception as e:
+            logger.error(f"Erreur stats MongoDB: {e}")
+            return {
+                'total_documents': 0, 'pays': {}, 'langues': {}, 'sources': {}, 'derniere_mise_a_jour': None
+            }
+
+# Instance globale
+search_engine = MongoSearchEngine()
 
 # ============================================================================
 # API ENDPOINTS
 # ============================================================================
 
-
-
 @app.get("/api/health")
 async def health():
     """Health check"""
+    try:
+        count = await search_engine.get_stats()
+        status = "healthy"
+    except:
+        status = "db_error"
+        count = {"total_documents": 0}
+        
     return {
-        "status": "healthy",
-        "documents_loaded": len(search_engine.documents),
+        "status": status,
+        "documents_loaded": count["total_documents"],
         "timestamp": datetime.now().isoformat()
     }
 
 @app.post("/api/search", response_model=SearchResponse)
 async def api_search(request: SearchRequest):
-    """
-    Endpoint de recherche principal
-    
-    **Paramètres:**
-    - query: Texte à rechercher
-    - pays: Filtrer par pays (optionnel)
-    - langue: Filtrer par langue (optionnel)
-    - limit: Nombre de résultats (défaut: 10)
-    - fuzzy: Recherche permissive avec tolérance aux fautes (défaut: true)
-    
-    **Exemple:**
-    ```json
-    {
-        "query": "économie togo",
-        "pays": "Togo",
-        "limit": 20,
-        "fuzzy": true
-    }
-    ```
-    """
+    """Endpoint de recherche principal (MongoDB)"""
     start_time = datetime.now()
     
-    results = search_engine.search(
+    results = await search_engine.search(
         query=request.query,
         pays=request.pays,
         langue=request.langue,
@@ -300,11 +223,7 @@ async def api_search_get(
     limit: int = Query(10, ge=1, le=100, description="Nombre de résultats"),
     fuzzy: bool = Query(True, description="Recherche permissive")
 ):
-    """
-    Endpoint de recherche (GET)
-    
-    **Exemple:** `/api/search?q=économie&pays=Togo&limit=20`
-    """
+    """Endpoint de recherche (GET)"""
     request = SearchRequest(
         query=q,
         pays=pays,
@@ -316,16 +235,8 @@ async def api_search_get(
 
 @app.get("/api/stats", response_model=StatsResponse)
 async def api_stats():
-    """
-    Retourne les statistiques de la base de données
-    
-    **Retourne:**
-    - total_documents: Nombre total de documents
-    - pays: Répartition par pays
-    - langues: Répartition par langue
-    - sources: Répartition par source
-    """
-    stats = search_engine.get_stats()
+    """Retourne les statistiques de la base MongoDB"""
+    stats = await search_engine.get_stats()
     return StatsResponse(**stats)
 
 @app.get("/api/documents")
@@ -333,16 +244,15 @@ async def api_documents(
     skip: int = Query(0, ge=0),
     limit: int = Query(10, ge=1, le=100)
 ):
-    """
-    Retourne la liste des documents (paginée)
-    
-    **Paramètres:**
-    - skip: Nombre de documents à sauter
-    - limit: Nombre de documents à retourner
-    """
-    documents = search_engine.documents[skip:skip+limit]
+    """Retourne la liste des documents (paginée)"""
+    cursor = search_engine.collection.find({}).skip(skip).limit(limit)
+    documents = await cursor.to_list(length=limit)
+    for doc in documents:
+        if '_id' in doc: doc['_id'] = str(doc['_id'])
+        
+    total = await search_engine.collection.count_documents({})
     return {
-        "total": len(search_engine.documents),
+        "total": total,
         "skip": skip,
         "limit": limit,
         "documents": documents
@@ -350,31 +260,36 @@ async def api_documents(
 
 @app.get("/api/documents/{doc_id}")
 async def api_document_by_id(doc_id: str):
-    """Retourne un document par son ID"""
-    for doc in search_engine.documents:
-        if doc.get('id') == doc_id:
-            return doc
-    raise HTTPException(status_code=404, detail="Document non trouvé")
+    """Retourne un document par son ID (champ 'id' ou '_id')"""
+    doc = await search_engine.collection.find_one({"id": doc_id})
+    if not doc:
+        # Essai avec ObjectId
+        try:
+            from bson import ObjectId
+            doc = await search_engine.collection.find_one({"_id": ObjectId(doc_id)})
+        except: pass
+        
+    if not doc:
+        raise HTTPException(status_code=404, detail="Document non trouvé")
+        
+    if '_id' in doc: doc['_id'] = str(doc['_id'])
+    return doc
 
 @app.post("/api/reload")
 async def api_reload():
-    """Recharge les documents depuis le fichier (après scraping)"""
-    search_engine.reload()
-    return {
-        "status": "success",
-        "documents_loaded": len(search_engine.documents)
-    }
+    """Endpoint dummy pour compatibilité"""
+    return {"status": "success", "message": "MongoDB is real-time"}
 
 # ============================================================================
 # GRADIO INTERFACE
 # ============================================================================
 
-def gradio_search(query: str, pays: str, langue: str, fuzzy: bool):
-    """Fonction de recherche pour Gradio"""
+async def gradio_search(query: str, pays: str, langue: str, fuzzy: bool):
+    """Fonction de recherche pour Gradio (Async wrapper)"""
     if not query:
         return "⚠️ Veuillez entrer une requête de recherche"
     
-    results = search_engine.search(
+    results = await search_engine.search(
         query=query,
         pays=pays if pays != "Tous" else None,
         langue=langue if langue != "Toutes" else None,
@@ -392,11 +307,10 @@ def gradio_search(query: str, pays: str, langue: str, fuzzy: bool):
         titre = doc.get('titre', 'Sans titre')
         texte = doc.get('texte', '')[:200] + "..."
         pays_doc = doc.get('pays', 'Inconnu')
-        source = doc.get('source_url', '')
         score = doc.get('_score', 0)
         
         output += f"### {i}. {titre}\n"
-        output += f"**Pays:** {pays_doc} | **Score:** {score:.1f}\n\n"
+        output += f"**Pays:** {pays_doc}\n\n"
         output += f"{texte}\n\n"
         output += f"[🔗 Source]({source})\n\n"
         output += "---\n\n"