Update utils.py

utils.py

@@ -102,16 +102,6 @@ HF_WRITE = os.getenv("HF_WRITE")
 # HfApi-Instanz erstellen
 api = HfApi()
 
-# Überprüfen, ob das Repository existiert und zugänglich ist
-try:
-    repo_info = api.list_repo_files(repo_id=STORAGE_REPO_ID, repo_type=REPO_TYPE, token=hf_token)
-    print(f"Repository '{STORAGE_REPO_ID}' enthält folgende Dateien: {repo_info}")
-except Exception as e:
-    print(f"Fehler beim Zugriff auf das Repository: {e}")
-
-
-
-
 
 #Maoing für die Splits (orginal und Preprocessed
 split_to_original_mapping = []
@@ -260,10 +250,7 @@ def clean_text(text):
 ##################################################
 #RAG Hilfsfunktionen - Dokumenten bearbeiten für Vektorstore
 ##################################################
-##################################################
-# Directory Loader Konfigurieren um Text zu extrahieren
-##################################################
-
+#Files aus anderem Repi downloaden
 def access_pdf(self, filename):
         # Temporäre Datei erstellen
         with tempfile.NamedTemporaryFile(delete=False, suffix=self.file_type) as temp_file:
@@ -280,35 +267,8 @@ def access_pdf(self, filename):
 
         return temp_path
     
-"""
-#besseren directory Loader als CustomLoader definieren, der den inhalt des dokuemnts, die seitenzahlen, die überschriften und die pfadezu den dokumenten extrahieren
-def  create_custom_loader(file_type, file_list): #create_directory_loader(file_type, directory_path):
-    loaders = {
-        '.pdf': load_pdf_with_metadata,
-        '.word': load_word_with_metadata,
-    }
-
-    
-    class CustomLoader:
-       
-        def __init__(self, directory_path, file_type, loader_func):
-            self.directory_path = directory_path
-            self.file_type = file_type
-            self.loader_func = loader_func
-
-        def load(self):
-            documents = []
-            for root, _, files in os.walk(self.directory_path):
-                for file in files:
-                    if file.endswith(self.file_type):
-                        file_path = os.path.join(root, file)
-                        documents.extend(self.loader_func(file_path))
-            return documents
-
-    return CustomLoader(directory_path, file_type, loaders[file_type])
-"""
-
-    
+################################################
+#besseren directory Loader als CustomLoader definieren, der den inhalt des dokuemnts, die seitenzahlen, die überschriften und die pfadezu den dokumenten extrahieren  
 def create_custom_loader(file_type, file_list):
     loaders = {
         '.pdf': load_pdf_with_metadata,
@@ -330,7 +290,7 @@ def load_pdf_with_metadata(file_path):
         documents.append(Document(content=content, title=title, page=page_number, path=file_path, split_id=None))
     return documents
     
-#für WOrD Dokumente
+#für Word Dokumente
 def load_word_with_metadata(file_path):
     document = docx.Document(file_path)
     title = "Dokument"
@@ -345,22 +305,11 @@ def load_word_with_metadata(file_path):
 
     
 ################################################
-#Vektorstore
+#für den Vektorstore
 ################################################
-#liste aller files in einem dir...
-"""
-def list_files_in_hf_repo(repo_id, directory=""):
-    try:
-        repo_info = api.list_repo_files(repo_id=repo_id, repo_type=REPO_TYPE)
-        if directory:
-            repo_info = [file for file in repo_info if file.startswith(directory)]
-        return repo_info
-    except Exception as e:
-        print(f"Fehler beim Zugriff auf das Repository.........................:{repo_id} {e}")
-        return []
-"""    
+ 
 ################################################
-# Document Splitting
+# Document Splitting - und id für das Mapping
 ################################################    
 #die Inhalte splitten, um in Vektordatenbank entsprechend zu laden als Splits
 # Funktion zum Splitten und Zuweisen der doc_id
@@ -382,34 +331,11 @@ def split_documents_with_id(docs, text_splitter):
     
 
 ########################################
-#finally die Splits erzeugen und laden.....
+#finally die Splits erzeugen und laden..... für den Vektorstore
 def document_loading_splitting():
     docs = []
     print("Directory Loader neu............................")
 
-
-
-    # Verzeichnis für heruntergeladene Dateien
-    #download_dir = CHROMA_PDF
-    #os.makedirs(download_dir, exist_ok=True)
-
-    # Dateien im Hugging Face Space auflisten
-    """
-    files_in_repo = list_files_in_hf_repo(STORAGE_REPO_ID, "chroma/kkg/pdf/")
-    print("hier.....................................")
-    # Dateien aus dem Hugging Face Space mit der STORAGE_REPO_ID herunterladen
-    for file_name in files_in_repo:
-        if file_name.endswith('.pdf'):
-            local_file_path = os.path.join(CHROMA_PDF, os.path.basename(file_name))
-            download_file_from_hf(file_name, local_file_path)
-        if file_name.endswith('.docx'):
-            local_file_path = os.path.join(CHROMA_WORD, os.path.basename(file_name))
-            download_file_from_hf(file_name, local_file_path)
-        print("file_name..................."+str(file_name))
-        print("local_file_path..................."+str(local_file_path)) 
-    """
-
-
     # Dateien im Hugging Face Space auflisten
     files_in_repo = list_repo_files(repo_id=STORAGE_REPO_ID, repo_type="space", token=hf_token)
     pdf_files = [f for f in files_in_repo if f.endswith('.pdf') and f.startswith("chroma/kkg/pdf/")]
@@ -417,19 +343,9 @@ def document_loading_splitting():
 
     
     # Erstellen von DirectoryLoader für jeden Dateityp
-    # pdf_loader = create_directory_loader('.pdf', CHROMA_PDF)
-    #word_loader = create_directory_loader('.word', CHROMA_WORD)
-
     pdf_loader = create_custom_loader('.pdf', pdf_files)
     word_loader = create_custom_loader('.docx', word_files)
 
-
-
-    """
-    # kreiere einen DirectoryLoader für jeden file type
-    pdf_loader = create_directory_loader('.pdf', CHROMA_PDF)
-    word_loader = create_directory_loader('.word', CHROMA_WORD)
-    """
     # Load the files
     pdf_documents = pdf_loader.load()
     word_documents = word_loader.load()
@@ -489,6 +405,7 @@ def document_storage_chroma(splits):
 
 ########################################################
 #Splits für den Vektorstore speichern - bzw. laden
+########################################################
 def save_splits(preprocessed_splits, original_splits, directory="chroma/kkg", preprocessed_filename="preprocessed_splits.pkl", original_filename="original_splits.pkl"):
     # Erstellen des Verzeichnisses, falls es nicht existiert
     if not os.path.exists(directory):
@@ -507,23 +424,7 @@ def save_splits(preprocessed_splits, original_splits, directory="chroma/kkg", pr
     # Hochladen der Splits-Dateien zum Hugging Face Space
     upload_file_to_huggingface(preprocessed_filepath, f"{directory}/{preprocessed_filename}")
     upload_file_to_huggingface(original_filepath, f"{directory}/{original_filename}")
-"""
-def load_splits(directory="chroma/kkg", preprocessed_filename="preprocessed_splits.pkl", original_filename="original_splits.pkl"):
-    # Vollständigen Pfad zur Datei erstellen
-    preprocessed_filepath = os.path.join(directory, preprocessed_filename)
-    original_filepath = os.path.join(directory, original_filename)
-    
-    # Laden der vorverarbeiteten Splits aus der Datei
-    if os.path.exists(preprocessed_filepath) and os.path.exists(original_filepath):
-        with open(preprocessed_filepath, "rb") as f:
-            preprocessed_splits = pickle.load(f)
-        
-        with open(original_filepath, "rb") as f:
-            original_splits = pickle.load(f)
-        
-        return preprocessed_splits, original_splits
-    return None, None
-"""
+
 def load_splits(directory="chroma/kkg", preprocessed_filename="preprocessed_splits.pkl", original_filename="original_splits.pkl"):
     preprocessed_splits = None
     original_splits = None
@@ -554,20 +455,11 @@ def load_splits(directory="chroma/kkg", preprocessed_filename="preprocessed_spli
 
     return preprocessed_splits, original_splits
 
-########################################################
-#Vektorstore speichern - bzw. laden       
-#Laden des Vektorstores - aus den gespeicherten splits
-"""
-def load_vectorstore():
-    splits_and_metadata = load_splits_and_metadata()
-    if splits_and_metadata is not None:
-        PREPROCESSED_SPLITS, SPLIT_TO_ORIGINAL_MAPPING = splits_and_metadata
-        return document_storage_chroma(PREPROCESSED_SPLITS)
-    return None
-"""
 
-#################################
-#das Mapping der orginal-Splits und der preprocessed Splits speichern
+
+########################################
+#das Mapping der orginal-Splits und der preprocessed Splits speichern - und laden
+########################################
 def save_split_to_original_mapping(mapping, directory="chroma/kkg", filename="mapping.pkl"):
     # Erstellen des Verzeichnisses, falls es nicht existiert
     if not os.path.exists(directory):
@@ -580,17 +472,7 @@ def save_split_to_original_mapping(mapping, directory="chroma/kkg", filename="ma
     
     # Hochladen der Mapping-Datei zum Hugging Face Space
     upload_file_to_huggingface(filepath, f"{directory}/{filename}")
-"""
-def load_split_to_original_mapping(directory="chroma/kkg", filename="mapping.pkl"):
-    # Vollständigen Pfad zur Datei erstellen
-    filepath = os.path.join(directory, filename)
-    
-    # Laden des Mappings aus der Datei
-    if os.path.exists(filepath):
-        with open(filepath, "rb") as f:
-            return pickle.load(f)
-    return None
-"""
+
 
 def load_split_to_original_mapping(directory="chroma/kkg", filename="mapping.pkl"):
     try:
@@ -624,7 +506,7 @@ def upload_file_to_huggingface(file_path, upload_path):
     )
 
 
-#ein File aus dem Space mit der REPO_ID laden
+#ein File aus dem Space mit der REPO_ID laden - Authentifizierung über den HEADER
 def download_file_from_hf(file_name, save_path):
     url = f"https://huggingface.co/{STORAGE_REPO_ID}/resolve/main/{file_name}"
     response = requests.get(url, headers=HEADERS)
@@ -776,7 +658,7 @@ def rag_chain_simpel( prompt,  retriever):
         # keine relevanten Dokumente gefunden
         result = {
             "answer": "Keine relevanten Dokumente gefunden",
-            "relevant_docs": most_relevant_docs
+            "relevant_docs": None
         }
         
     return result
@@ -793,16 +675,7 @@ def extract_document_info(documents):
         title = filename if filename else "Keine Überschrift"
         doc_path = doc.metadata.get("path", "")
         # Determine the document type and adjust the path accordingly
-        d_link = download_link(doc)
-        """
-        doc_path = doc.metadata.get("path", "")
-        if doc_path.endswith('.pdf'):
-            download_link = download_link(doc) #f"https://huggingface.co/spaces/alexkueck/{STORAGE_REPO_ID}/resolve/main/chroma/kkg/pdf/{title}"
-        elif doc_path.endswith('.docx'):
-            download_link = f"https://huggingface.co/spaces/alexkueck/{STORAGE_REPO_ID}/resolve/main/chroma/kkg/word/{title}"
-        else:
-            download_link = doc_path
-        """    
+        d_link = download_link(doc)  
         
         info = {
             'content': doc.page_content,
@@ -838,16 +711,6 @@ def generate_prompt_with_history(text, history, max_length=4048):
         return None
 
 
-#############################################
-#Prompt und History für Hugging Face Schnittstelle
-def generate_prompt_with_history_hf(prompt, history):
-    history_transformer_format = history + [[prompt, ""]]
-    #stop = StopOnTokens()
-
-    messages = "".join(["".join(["\n<human>:"+item[0], "\n<bot>:"+item[1]])  #curr_system_message +
-                for item in history_transformer_format])
-
-
 
 ##########################################
 #Hashing.... Für die Validierung........
@@ -869,20 +732,7 @@ def transfer_input(inputs):
 
 
 ########################################################
-######## Hilfsfunktionen Datei-Upload ##################
-"""
-def download_link(doc):
-    # URL für das Herunterladen der Datei
-    # Check if doc is a dictionary and contains the key 'pfad'
-    if isinstance(doc, dict) and 'pfad' in doc:
-        file_url = f"https://huggingface.co/spaces/alexkueck/{STORAGE_REPO_ID}/resolve/main/chroma/kkg/{doc['pfad']}?token=hf_token"
-        return f'<b><a href="{file_url}" target="_blank" style="color: #BB70FC; font-weight: bold;">{doc["titel"]}</a></b>'
-    else:
-        file_url = f"https://huggingface.co/spaces/alexkueck/{STORAGE_REPO_ID}/resolve/main/{doc}?token=hf_token"
-        return f'<b><a href="{file_url}" target="_blank" style="color: #BB70FC; font-weight: bold;">{doc}</a></b>'
-
-"""
-
+######## Hilfsfunktionen Datei-Download ##################
 def download_link(doc):
     # Basis-URL für das Hugging Face Repository
     base_url = f"https://huggingface.co/spaces/{STORAGE_REPO_ID}/resolve/main"
@@ -917,32 +767,6 @@ def download_link(doc):
 #################################################
 #File Liste beim Tab für File-Upload schön darstellen
 #################################################
-"""
-def display_files():
-    files = os.listdir(DOCS_DIR_PDF)
-    files_table = "<table style='width:100%; border-collapse: collapse;'>"
-    files_table += "<tr style='background-color: #930BBA; color: white; font-weight: bold; font-size: larger;'><th>Dateiname - PDF-Ordner</th></tr>"
-    for i, file in enumerate(files):
-        file_path = os.path.join(DOCS_DIR_PDF, file)
-        file_size = os.path.getsize(file_path) / 1024  # Größe in KB
-        row_color = "#4f4f4f" if i % 2 == 0 else "#3a3a3a"  # Wechselnde Zeilenfarben
-        files_table += f"<tr style='background-color: {row_color}; border-bottom: 1px solid #ddd;'>"
-        files_table += f"<td><b>{download_link(file)}</b></td></tr>"
-    files_table += "</table>"
-
-    files = os.listdir(DOCS_DIR_WORD)
-    files_table += "<table style='width:100%; border-collapse: collapse;'>"
-    files_table += "<tr style='background-color: #930BBA; color: white; font-weight: bold; font-size: larger;'><th>Dateiname - Word-Ordner</th></tr>"
-    for i, file in enumerate(files):
-        file_path = os.path.join(DOCS_DIR_WORD, file)
-        file_size = os.path.getsize(file_path) / 1024  # Größe in KB
-        row_color = "#4f4f4f" if i % 2 == 0 else "#3a3a3a"  # Wechselnde Zeilenfarben
-        files_table += f"<tr style='background-color: {row_color}; border-bottom: 1px solid #ddd;'>"
-        files_table += f"<td><b>{download_link(file)}</b></td></tr>"
-    files_table += "</table>"
-    return files_table
-"""
-
 def display_files():
     files_table = "<table style='width:100%; border-collapse: collapse;'>"
     
@@ -966,13 +790,6 @@ def display_files():
     return files_table
 
 
-# gefundene relevante Dokumente auflisten (links)
-"""
-def list_pdfs():
-    if not os.path.exists(DOCS_DIR):
-        return []
-    return [f for f in os.listdir(SAVE_DIR) if f.endswith('.pdf')]
-"""
 ##########################################
 #Extension des hochgeladenen Files bestimmen
 def analyze_file(file):
@@ -1012,8 +829,9 @@ class State:
         self.interrupted = False
 shared_state = State()
 
-
+###############################################
 #Für die relevanten Dokumente - damit sie passend zum Dictionary die Attribute haben
+###############################################
 class Document:
     def __init__(self, content, title, page, path, split_id=None):
         self.page_content = content