Passage par GitHub Gist pour uploader jusqu'à 10Mo dans Qdrant

app.py

@@ -2,7 +2,6 @@ import streamlit as st
 import hashlib
 import requests
 import os
-import json
 import pytz
 import time
 import unicodedata
@@ -10,6 +9,7 @@ import importlib.metadata
 import re
 import tempfile
 import uuid
+import base64
 from pydantic import BaseModel, validator
 from dotenv import load_dotenv
 from sentence_transformers import SentenceTransformer
@@ -20,11 +20,6 @@ from datetime import datetime, timedelta
 from collections import defaultdict
 from PyPDF2 import PdfReader
 from docx import Document
-from google.oauth2 import service_account
-from googleapiclient.discovery import build
-from googleapiclient.http import MediaFileUpload
-# from unstructured.partition.pdf import partition_pdf  # Optionnel, pour une extraction plus fine
-# from unstructured.partition.docx import partition_docx
 
 try:
     import pdfplumber
@@ -349,76 +344,6 @@ class ResponseDocument(BaseModel):
 
 # --- 1a. Fonctions d'upload, d'indexation et d'embedding
 
-# Fonction pour uploader un fichier dans le Drive
-def upload_to_drive(uploaded_file):
-    """Upload le fichier vers ton Drive et retourne son ID + chemin temporaire"""
-    with tempfile.NamedTemporaryFile(delete=False, suffix=f".{uploaded_file.name.split('.')[-1]}") as tmp_file:
-        tmp_file.write(uploaded_file.getvalue())
-        tmp_path = tmp_file.name
-
-    file_metadata = {"name": uploaded_file.name, "parents": [FOLDER_ID]}
-    media = MediaFileUpload(tmp_path, resumable=True)
-    file = drive_service.files().create(body=file_metadata, media_body=media, fields="id").execute()
-    return file.get("id"), tmp_path
-
-# Fonction qui permet de reprendre un upload interrompu
-def upload_to_drive_resumable(uploaded_file):
-    """Upload vers Google Drive en mode resumable (chunked) avec logs de debug"""
-    st.write("🔧 Début de upload_to_drive_resumable")
-    print("DEBUG: Entrée dans upload_to_drive_resumable")
-
-    # Sauvegarde temporaire du fichier
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{uploaded_file.name.split('.')[-1]}") as tmp_file:
-            data = uploaded_file.getvalue()
-            st.write(f"📦 Taille du fichier lu : {len(data)} octets")
-            print("DEBUG: Taille du fichier lu:", len(data))
-            tmp_file.write(data)
-            tmp_path = tmp_file.name
-        st.write(f"📄 Fichier temporaire créé : {tmp_path}")
-        print("DEBUG: Fichier temporaire créé:", tmp_path)
-    except Exception as e:
-        st.error(f"❌ Erreur lors de la création du fichier temporaire : {e}")
-        print("DEBUG: Erreur création fichier temporaire:", e)
-        raise
-
-    # Préparation des métadonnées
-    file_metadata = {"name": uploaded_file.name, "parents": [FOLDER_ID]}
-    st.write(f"📝 Métadonnées du fichier : {file_metadata}")
-    print("DEBUG: Métadonnées du fichier:", file_metadata)
-
-    try:
-        media = MediaFileUpload(tmp_path, resumable=True)
-        request = drive_service.files().create(body=file_metadata, media_body=media, fields="id")
-        st.write("🚀 Requête Drive initialisée")
-        print("DEBUG: Requête Drive initialisée")
-    except Exception as e:
-        st.error(f"❌ Erreur initialisation requête Drive : {e}")
-        print("DEBUG: Erreur initialisation requête Drive:", e)
-        raise
-
-    # Upload en chunks
-    response = None
-    try:
-        while response is None:
-            status, response = request.next_chunk()
-            if status:
-                percent = int(status.progress() * 100)
-                st.write(f"⬆️ Upload vers Drive : {percent}%")
-                print("DEBUG: Progression upload:", percent, "%")
-        st.write("✅ Upload terminé")
-        print("DEBUG: Upload terminé, réponse:", response)
-    except Exception as e:
-        st.error(f"❌ Erreur pendant l'upload vers Drive : {e}")
-        print("DEBUG: Erreur pendant l'upload:", e)
-        raise
-
-    file_id = response.get("id")
-    st.write(f"📂 ID du fichier Drive : {file_id}")
-    print("DEBUG: ID du fichier Drive:", file_id)
-
-    return file_id, tmp_path
-
 # Fonction pour extraire le texte d'un document pdf
 def extract_text(pdf_path: str, max_pages: Optional[int] = None) -> str:
     """Extrait le texte d'un PDF, avec gestion des erreurs et des pages vides (VOTRE FONCTION)."""
@@ -438,10 +363,6 @@ def extract_text(pdf_path: str, max_pages: Optional[int] = None) -> str:
 # Fonction pour extraire le texte d'un document Word
 def extract_text_from_docx(file_path: str, use_unstructured: bool = False) -> str:
     """Extrait le texte d'un fichier Word."""
-#    if use_unstructured:
-#        elements = partition_docx(file_path)
-#        text = "\n\n".join([str(el) for el in elements])
-#    else:
     doc = Document(file_path)
     text = "\n".join([para.text for para in doc.paragraphs if para.text.strip()])
     return text.strip()
@@ -2730,120 +2651,115 @@ else:
         # 2. Section d'upload de documents
         st.markdown("---")
         st.markdown("**Ajouter un document**")
-
         uploaded_file = st.file_uploader(
-            "Sélectionnez un PDF ou Word",
+            "Sélectionnez un PDF ou Word (max 10 Mo)",
             type=["pdf", "docx"],
             key="doc_uploader"
         )
 
         if uploaded_file:
-            default_name = os.path.splitext(uploaded_file.name)[0]
-            custom_name = st.text_input(
-                "Nom du document (sera aussi le nom de la collection):",
-                value=default_name,
-                key="doc_name_input"
-            )
-
-            if st.button("Ajouter le document", key="add_document"):
-                st.write("➡️ Bouton 'Ajouter le document' cliqué")
-
-                if uploaded_file:
-                    st.write("📂 Fichier sélectionné :", uploaded_file.name)
-                    print("DEBUG: Fichier sélectionné:", uploaded_file.name)
-
-                    try:
-                        file_id, tmp_path = upload_to_drive_resumable(uploaded_file)
-                        st.success(f"✅ Upload terminé. ID Drive : {file_id}")
-                        st.write("📄 Fichier temporaire créé :", tmp_path)
-                        print("DEBUG: Upload terminé, ID:", file_id, "tmp_path:", tmp_path)
-                    except Exception as e:
-                        st.error(f"❌ Erreur pendant l'upload vers Drive : {e}")
-                        print("DEBUG: Erreur upload_to_drive_resumable:", e)
-
-                    try:
-                        results = drive_service.files().list(
-                            q=f"'{FOLDER_ID}' in parents",
-                            fields="files(id, name)"
-                        ).execute()
-                        st.write("📂 Contenu du dossier uploads :", results.get("files", []))
-                        print("DEBUG: Contenu du dossier uploads:", results.get("files", []))
-                    except Exception as e:
-                        st.error(f"❌ Erreur pendant la liste des fichiers : {e}")
-                        print("DEBUG: Erreur drive_service.files().list:", e)
-
-                if not custom_name.strip():
-                    st.warning("Veuillez entrer un nom valide.")
-                    print("DEBUG: Nom du document invalide")
-                else:
-                    display_name = custom_name.strip().replace(" ", "_")
-                    collection_name = f"{display_name}__{int(datetime.now().timestamp())}"
-                    st.write("🆕 Nom de collection généré :", collection_name)
-                    print("DEBUG: Nom de collection généré:", collection_name)
-
-                    progress_bar = st.progress(0)
-                    status_text = st.empty()
-
-                    def update_progress(current, total, message):
-                        percent = int((current / total) * 100) if total > 0 else 0
-                        progress_bar.progress(percent)
-                        status_text.text(f"{message} ({current}/{total})")
-                        print(f"DEBUG: Progress {percent}% - {message}")
-
-                    try:
-                        status_text.text("Création de la collection dans Qdrant...")
-                        st.write("⚙️ Création collection Qdrant :", collection_name)
-                        print("DEBUG: Création collection Qdrant:", collection_name)
-
-                        qdrant_client.create_collection(
-                            collection_name=collection_name,
-                            vectors_config=models.VectorParams(size=1024, distance=models.Distance.COSINE)
-                        )
-
-                        status_text.text("Upload vers Google Drive...")
-                        st.write("⚙️ Upload vers Drive (resumable)...")
-                        print("DEBUG: Upload vers Drive (resumable)...")
-                        file_id, tmp_path = upload_to_drive_resumable(uploaded_file)
-                        st.write("📄 Fichier temporaire pour traitement :", tmp_path)
-                        print("DEBUG: Fichier temporaire pour traitement:", tmp_path)
-
-                        status_text.text("Traitement et indexation en cours...")
-                        st.write("⚙️ Lancement process_and_index_document...")
-                        print("DEBUG: Lancement process_and_index_document...")
-                        success = process_and_index_document(
-                            file_path=tmp_path,
-                            file_type=uploaded_file.name.split('.')[-1],
-                            collection_name=collection_name,
-                            qdrant_client=qdrant_client,
-                            embedding_model=embedding_model,
-                            progress_callback=update_progress
-                        )
-
-                        if success:
-                            status_text.text("Document ajouté avec succès !")
-                            progress_bar.progress(100)
-                            st.success(f"✅ Document ajouté sous le nom '{custom_name}' !")
-                            print("DEBUG: Document ajouté avec succès")
-
-                            if os.path.exists(tmp_path):
-                                os.unlink(tmp_path)
-                                print("DEBUG: Fichier temporaire supprimé:", tmp_path)
-
-                            st.session_state.manage_doc_base = False
-                            st.rerun()
+            # Vérifier la taille du fichier
+            if uploaded_file.size > 10 * 1024 * 1024:  # 10 Mo
+                st.error("❌ Le fichier dépasse la limite de 10 Mo autorisée.")
+            else:
+                # Champ pour le nom personnalisé
+                default_name = os.path.splitext(uploaded_file.name)[0]
+                custom_name = st.text_input(
+                    "Nom du document :",
+                    value=default_name,
+                    key="doc_name_input"
+                )
+                if st.button("Ajouter le document", key="add_document"):
+                    if not custom_name.strip():
+                        st.warning("Veuillez entrer un nom valide.")
+                    else:
+                        # Remplacez par votre token GitHub (à générer dans Settings > Developer settings > Personal access tokens)
+                        GITHUB_TOKEN = st.secrets.get("GITHUB_TOKEN", "")  # Ou définissez-le directement ici (moins sécurisé)
+                        if not GITHUB_TOKEN:
+                            st.error("❌ Token GitHub manquant. Veuillez configurer `GITHUB_TOKEN` dans les secrets de votre Space.")
                         else:
-                            status_text.text("Échec de l'ajout du document")
-                            st.error("❌ Échec de l'ajout.")
-                            print("DEBUG: process_and_index_document a retourné False")
-
-                    except Exception as e:
-                        status_text.text(f"Erreur: {str(e)}")
-                        st.error(f"Erreur: {e}")
-                        print("DEBUG: Exception attrapée:", e)
-                    finally:
-                        time.sleep(2)
-                        progress_bar.empty()
-                        status_text.empty()
+                            # Génération du nom de la collection
+                            display_name = custom_name.strip().replace(" ", "_")
+                            collection_name = f"{display_name}__{int(datetime.now().timestamp())}"
+                            progress_bar = st.progress(0)
+                            status_text = st.empty()
+
+                            def update_progress(current, total, message):
+                                percent = int((current / total) * 100) if total > 0 else 0
+                                progress_bar.progress(percent)
+                                status_text.text(f"{message} ({current}/{total})")
+
+                            try:
+                                # 1. Upload vers GitHub Gist
+                                status_text.text("Upload du fichier vers GitHub Gist...")
+                                headers = {"Authorization": f"token {GITHUB_TOKEN}"}
+                                file_content = base64.b64encode(uploaded_file.getvalue()).decode("utf-8")
+                                data = {
+                                    "description": f"Document pour RAG: {custom_name}",
+                                    "public": False,
+                                    "files": {
+                                        uploaded_file.name: {"content": file_content}
+                                    }
+                                }
+                                response = requests.post("https://api.github.com/gists", json=data, headers=headers)
+                                response.raise_for_status()  # Vérifie les erreurs HTTP
+                                gist_data = response.json()
+                                gist_url = gist_data["html_url"]
+                                raw_url = gist_data["files"][uploaded_file.name]["raw_url"]
+
+                                # 2. Téléchargement du fichier depuis GitHub Gist
+                                status_text.text("Téléchargement du fichier depuis GitHub Gist...")
+                                file_response = requests.get(raw_url)
+                                file_response.raise_for_status()
+
+                                # 3. Sauvegarde temporaire locale
+                                with tempfile.NamedTemporaryFile(delete=False, suffix=f".{uploaded_file.name.split('.')[-1]}") as tmp_file:
+                                    tmp_file.write(file_response.content)
+                                    tmp_path = tmp_file.name
+
+                                # 4. Création de la collection Qdrant
+                                status_text.text("Création de la collection dans Qdrant...")
+                                qdrant_client.create_collection(
+                                    collection_name=collection_name,
+                                    vectors_config=models.VectorParams(
+                                        size=1024,
+                                        distance=models.Distance.COSINE
+                                    )
+                                )
+
+                                # 5. Traitement et indexation
+                                status_text.text("Traitement et indexation en cours...")
+                                success = process_and_index_document(
+                                    file_path=tmp_path,
+                                    file_type=uploaded_file.name.split('.')[-1],
+                                    collection_name=collection_name,
+                                    qdrant_client=qdrant_client,
+                                    embedding_model=embedding_model,
+                                    progress_callback=update_progress
+                                )
+
+                                if success:
+                                    status_text.text("Document ajouté avec succès.")
+                                    progress_bar.progress(100)
+                                    st.success(f"✅ Document ajouté sous le nom '{custom_name}'.")
+                                else:
+                                    status_text.text("Échec de l'ajout du document")
+                                    st.error("❌ Échec de l'ajout.")
+
+                            except requests.exceptions.RequestException as e:
+                                status_text.text(f"Erreur GitHub: {str(e)}")
+                                st.error(f"Erreur GitHub: {e}")
+                            except Exception as e:
+                                status_text.text(f"Erreur: {str(e)}")
+                                st.error(f"Erreur: {e}")
+                            finally:
+                                # Nettoyage
+                                if 'tmp_path' in locals() and os.path.exists(tmp_path):
+                                    os.unlink(tmp_path)
+                                time.sleep(2)
+                                progress_bar.empty()
+                                status_text.empty()
+                                st.rerun()
 
 
 #########################################################################################

requirements.txt

@@ -12,8 +12,4 @@ pdfplumber
 matplotlib
 # onnxruntime==1.16.0
 # unstructured[pdf,docx]==0.10.30
-PyPDF2==3.0.1
-google-api-python-client
-google-auth
-google-auth-oauthlib
-google-auth-httplib2
+PyPDF2==3.0.1