Update pinecone_utilsB.py

pinecone_utilsB.py

@@ -13,6 +13,8 @@ import base64
 import json
 nltk.download('punkt_tab')
 
+
+
 CONFIG_FILE = "indexing_state.json"
 
 def load_indexing_state():
@@ -29,32 +31,25 @@ def save_indexing_state(state):
 
 class HybridSearchEngine:
     def __init__(self):
-        # Initialisation des modèles et encodeurs
         self.model = SentenceTransformer("intfloat/multilingual-e5-large")
         self.sparse_encoder = BM25Encoder().default()
-
-        # Créer une instance de HuggingFaceEmbeddings
         self.embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
-
-        # Utiliser st.session_state pour stocker l'état de l'indexation
-        if "bm25_corpus" not in st.session_state:
-            st.session_state.bm25_corpus = []
-        if "indexing_done" not in st.session_state:
-            st.session_state.indexing_done = False
-
-        # Initialisation du PineconeVectorStore
         self.vectorstore = PineconeVectorStore(index=indexB, embedding=self.embeddings)
-
-        # Initialisation du retriever hybride
         self.retriever = PineconeHybridSearchRetriever(
             embeddings=self.embeddings,
             sparse_encoder=self.sparse_encoder,
             index=indexB
         )
 
+        # Utiliser st.session_state pour stocker l'état de l'indexation
+        if "bm25_corpus" not in st.session_state:
+            st.session_state.bm25_corpus = []
+        if "indexing_done" not in st.session_state:
+            st.session_state.indexing_done = False
+
     def is_initialized(self):
-        """Vérifie si l'index BM25 est initialisé."""
-        return bool(st.session_state.bm25_corpus)
+        """Vérifie si l'index BM25 est bien prêt à être utilisé."""
+        return bool(st.session_state.get("bm25_corpus")) and st.session_state.get("indexing_done")
 
     def tokenize(self, text):
         """Tokenise un texte avec NLTK."""
@@ -63,110 +58,82 @@ class HybridSearchEngine:
     def get_existing_vectors(self):
         """Récupère les textes compressés déjà indexés dans Pinecone."""
         existing_texts = set()
-
         try:
-            # Effectuer une recherche avec un mot-clé fictif pour récupérer des documents
             results = self.vectorstore.similarity_search("random_query", k=10000)
-
             for doc in results:
                 if "compressed_text" in doc.metadata:
                     existing_texts.add(doc.metadata["compressed_text"])
-
         except Exception as e:
             st.error(f"Erreur lors de la récupération des vecteurs existants : {e}")
-
         return existing_texts
 
     def index_pdf_B(self, texts, pdf_path):
-        """Indexe les textes en évitant les doublons (même contenu)."""
+        """Indexe les textes en évitant les doublons."""
         if not texts:
             st.error("La liste des textes ne peut pas être vide.")
             return
 
+        # Vérifier si l'indexation est déjà faite
+        if st.session_state.get("indexing_done", False):
+            st.write("L'indexation est déjà terminée, pas besoin de la refaire.")
+            return
+
         # Charger l'état d'indexation
         indexing_state = load_indexing_state()
-
-        # Vérifier si ce fichier PDF a déjà été indexé
         if pdf_path in indexing_state["indexed_files"]:
             st.write("Ce fichier PDF a déjà été indexé.")
             return
 
         st.write("Indexation en cours, veuillez patienter...")
 
-        # Récupérer les textes déjà indexés dans Pinecone
         existing_texts = self.get_existing_vectors()
 
-        # Initialiser BM25
+        # Entraîner BM25 uniquement si ce n'est pas déjà fait
         st.session_state.bm25_corpus = texts
         self.sparse_encoder.fit(texts)
 
         documents = []
-        for i, text in enumerate(texts):
+        for text in texts:
             chunks = self.split_text_into_chunks(text, max_chunk_size=1024)
-            for j, chunk in enumerate(chunks):
+            for chunk in chunks:
                 compressed_chunk = self.compress_text(chunk)
-
-                # Vérifier si ce texte est déjà dans l'index Pinecone
                 if compressed_chunk in existing_texts:
                     continue  # Ignorer ce document car il est déjà indexé
 
-                # Générer un ID unique pour ce chunk
                 doc_id = f"doc_{zlib.crc32(chunk.encode('utf-8'))}"
-
                 metadata = {"compressed_text": compressed_chunk}
-                metadata_size = self.get_metadata_size(metadata)
-
-                if metadata_size <= 40960:  # 40 KB
-                    document = Document(
-                        page_content=chunk,
-                        metadata=metadata
-                    )
-                    documents.append((doc_id, document))
+                if self.get_metadata_size(metadata) <= 40960:
+                    documents.append(Document(page_content=chunk, metadata=metadata))
 
-        # Ajouter uniquement les nouveaux documents
         if documents:
-            self.vectorstore.add_documents([doc for _, doc in documents])
+            self.vectorstore.add_documents(documents)
 
-        # Mettre à jour l'état d'indexation
+        # Marquer l'indexation comme terminée
         indexing_state["indexed_files"].append(pdf_path)
         save_indexing_state(indexing_state)
+        st.session_state.indexing_done = True
 
         st.success("Indexation terminée sans duplication de contenu.")
 
     def hybrid_search(self, query):
-        """Récupère les documents pertinents en combinant les résultats de Pinecone et BM25."""
+        """Effectue une recherche hybride combinant BM25 et Pinecone."""
         if not self.is_initialized():
             st.warning("L'index BM25 n'est pas encore prêt. Veuillez patienter pendant l'indexation...")
             return []
 
         try:
-            # Recherche hybride avec PineconeHybridSearchRetriever
             results = self.retriever.get_relevant_documents(query)
-
-            # Récupérer les documents pertinents
             relevant_docs = []
             for result in results:
-                # Vérifier si le résultat est un objet Document
-                if hasattr(result, "metadata"):
-                    metadata = result.metadata or {}  # Assurez-vous que metadata n'est jamais None
-                else:
-                    metadata = {}
-
-                # Vérifier si 'context' existe avant d'y accéder
-                if "context" in metadata:
-                    _ = metadata.pop("context", None)  # Sécuriser l'accès à 'context'
-
+                metadata = result.metadata or {}
                 compressed_text = metadata.get("compressed_text")
                 if compressed_text:
                     relevant_docs.append(self.decompress_text(compressed_text))
-
             return relevant_docs
-
         except Exception as e:
             st.error(f"Erreur lors de la recherche hybride : {e}")
             return []
 
-
     def compress_text(self, text):
         """Compresse un texte en base64."""
         compressed = zlib.compress(text.encode("utf-8"))
@@ -187,4 +154,4 @@ class HybridSearchEngine:
 
     def get_metadata_size(self, metadata):
         """Calcule la taille des métadonnées en octets."""
-        return len(str(metadata).encode("utf-8"))
+        return len(str(metadata).encode("utf-8"))