import requests
import os, sys, json
import gradio as gr
import time
import re
import io
#from PIL import Image, ImageDraw, ImageOps, ImageFont
#import base64
import tempfile
import asyncio
from concurrent.futures import ThreadPoolExecutor
from PyPDF2 import PdfReader, PdfWriter
#from langchain.chains import LLMChain, RetrievalQA
from langchain_community.document_loaders import PyPDFLoader, UnstructuredWordDocumentLoader, DirectoryLoader
from langchain_community.document_loaders.blob_loaders.youtube_audio import YoutubeAudioLoader
#from langchain.document_loaders import GenericLoader
#from langchain.schema import AIMessage, HumanMessage
#from langchain_community.llms import HuggingFaceHub
from langchain_huggingface import HuggingFaceEndpoint
#from langchain_community.llms import HuggingFaceEndPoints
from langchain_huggingface import HuggingFaceEmbeddings
#from langchain_community.llms import HuggingFaceTextGenInference
#from langchain_community.embeddings import HuggingFaceInstructEmbeddings, HuggingFaceEmbeddings, HuggingFaceBgeEmbeddings, HuggingFaceInferenceAPIEmbeddings
#from langchain.prompts import PromptTemplate
#from langchain.chains import Runnable.................................
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from chromadb.errors import InvalidDimensionException
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import pipeline
from huggingface_hub import InferenceApi
from utils import *
from beschreibungen import *
#Konstanten
#Validieren des PW
ANTI_BOT_PW = os.getenv("VALIDATE_PW")
###############################
#HF Authentifizierung
HUGGINGFACEHUB_API_TOKEN = os.getenv("HF_READ")
os.environ["HUGGINGFACEHUB_API_TOKEN"] = HUGGINGFACEHUB_API_TOKEN
HEADERS = {"Authorization": f"Bearer {HUGGINGFACEHUB_API_TOKEN}"}
# Hugging Face Token direkt im Code setzen
hf_token = os.getenv("HF_READ")
#max Anzahl der zurückgelieferten Dokumente
ANZAHL_DOCS = 5
PATH_WORK = "."
CHROMA_DIR = "/chroma/kkg"
CHROMA_PDF = './chroma/kkg/pdf'
CHROMA_WORD = './chroma/kkg/word'
CHROMA_EXCEL = './chroma/kkg/excel'
DOCS_DIR = "chroma/kkg"
###########################################
# Alternativen, um HF Modelle in der rAG Chain einzusetzen
###########################################
#######################################
#1. Alternative: HuggingFace Model name--------------------------------
#MODEL_NAME_HF = "HuggingFaceH4/zephyr-7b-alpha" #"t5-small" #"meta-llama/Meta-Llama-3-8B-Instruct" #"mistralai/Mistral-7B-Instruct-v0.3" #"microsoft/Phi-3-mini-4k-instruct" #"HuggingFaceH4/zephyr-7b-alpha"
############################################
#2. Alternative_ HuggingFace Reop ID--------------------------------
#repo_id = "meta-llama/Llama-2-13b-chat-hf"
#repo_id = "HuggingFaceH4/zephyr-7b-alpha" #das Modell ist echt gut!!! Vom MIT
#repo_id = "TheBloke/Yi-34B-Chat-GGUF"
#repo_id = "meta-llama/Llama-2-70b-chat-hf"
#repo_id = "tiiuae/falcon-40b"
#repo_id = "Vicuna-33b"
#repo_id = "alexkueck/ChatBotLI2Klein"
#repo_id = "mistralai/Mistral-7B-v0.1"
#repo_id = "internlm/internlm-chat-7b"
#repo_id = "Qwen/Qwen-7B"
#repo_id = "Salesforce/xgen-7b-8k-base"
#repo_id = "Writer/camel-5b-hf"
#repo_id = "databricks/dolly-v2-3b"
#repo_id = "google/flan-t5-xxl"
#repo_id = "mistralai/Mixtral-8x7B-Instruct-v0.1"
#repo_id = "abacusai/Smaug-72B-v0.1"
###########################################
#3. Alternative: HF API - URL
#API_URL = "https://api-inference.huggingface.co/models/Falconsai/text_summarization"
###############################################
#globale Variablen
##############################################
#Filepath zu temp Folder (temp) mit File von ausgewähltem chatverlauf
file_path_download = ""
################################################
# Erstellen des Vektorstores
################################################
def create_vectorstore():
global vektordatenbank, SPLIT_TO_ORIGINAL_MAPPING, ORIGINAL_SPLITS, PREPROCESSED_SPLITS
# Splits zu allen Dokumenten in den Verzeichnissen erstellen
PREPROCESSED_SPLITS, SPLIT_TO_ORIGINAL_MAPPING, ORIGINAL_SPLITS = document_loading_splitting()
if PREPROCESSED_SPLITS:
print("Vektordatenbank neu .....................")
# Vektordatenbank zu den Splits erstellen
vektordatenbank = document_storage_chroma(PREPROCESSED_SPLITS)
# Speichern der Splits und Metadaten
save_splits(PREPROCESSED_SPLITS, ORIGINAL_SPLITS)
save_split_to_original_mapping(SPLIT_TO_ORIGINAL_MAPPING)
#falls Vektorstore vorhanden: neu laden!!!!!!!!!!!!!!!!!
def load_vectorstore_and_mapping():
global vektordatenbank, SPLIT_TO_ORIGINAL_MAPPING, ORIGINAL_SPLITS, PREPROCESSED_SPLITS
preprocessed_splits, original_splits = load_splits()
mapping = load_split_to_original_mapping()
if preprocessed_splits is not None and original_splits is not None and mapping is not None:
# Vektordatenbank zu den Splits erstellen
vektordatenbank = document_storage_chroma(preprocessed_splits)
SPLIT_TO_ORIGINAL_MAPPING = mapping
ORIGINAL_SPLITS = original_splits
PREPROCESSED_SPLITS = preprocessed_splits
else:
#fehler beim laden -> Vektorstore neu zusammensetzen
create_vectorstore()
###########################################
# Beim Start der Anwendung - Vektorstore laden!!!!
###########################################
print("Vektorstore laden.........................")
#die Variablen: vektordatenbank, PREPROCESSED_SPLITS, ORGINAL_SPLITS und das Mapping werden neu gesetzt global!!!!
load_vectorstore_and_mapping()
#################################################
#################################################
#Funktionen zur Verarbeitung
################################################
##############################################
#wenn löschen Button geklickt
def clear_all(history, uploaded_file_paths, chats):
dic_history = {schluessel: wert for schluessel, wert in history}
#später wird die summary auf 50 tokens verkürzt, um die Anfrage nicht so teuer werden zu lassen
#summary wird gebraucht für die Anfrage beim NN, um eine Überschrift des Eintrages zu generieren
summary = "\n\n".join(f'{schluessel}: \n {wert}' for schluessel, wert in dic_history.items())
#falls file mit summay für download existiert hat: das zunächst löschen
#cleanup(file_path_download)
#noch nicht im Einsatz, aber hier werden alle Chats einer Sitzung gespeichert
#den aktuellen Chatverlauf zum Download bereitstellen:
if chats != {} :
id_neu = len(chats)+1
chats[id_neu]= summary
else:
chats[0]= summary
#Eine Überschrift zu dem jeweiligen Chatverlauf finden - abhängig vom Inhalt
#file_path_download = save_and_download(summary)
#headers, payload = process_chatverlauf(summary, MODEL_NAME, OAI_API_KEY)
#response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
#als json ausgeben
#data = response.json()
# Den "content" auswählen, da dort die Antwort der Ki enthalten ist
#result = data['choices'][0]['message']['content']
#worte = result.split()
#if len(worte) > 2:
#file_path_download = "data/" + str(len(chats)) + "_Chatverlauf.pdf"
#else:
#file_path_download = "data/" + str(len(chats)) + "_" + result + ".pdf"
#erstellePdf(file_path_download, result, dic_history)
#die session variable in gradio erweitern und alle fliepath neu in das gr.File hochladen
#uploaded_file_paths= uploaded_file_paths + [file_path_download]
return None, gr.Image(visible=False), uploaded_file_paths, [], gr.File(uploaded_file_paths, label="Download-Chatverläufe", visible=True, file_count="multiple", interactive = False), chats
#wenn löschen Button geklickt
def clear_all3(history):
#die session variable in gradio erweitern und alle fliepath neu in das gr.File hochladen
uploaded_file_paths= ""
return None, gr.Image(visible=False), [],
##############################################
#History - die Frage oder das File eintragen...
#in history_file ist ein file gespeichert, falls voher im Verlauf schon ein File hochgeladen wurde.
#wird ein neuer File hochgeladen, so wird history_fiel dadurch ersetzt
def add_text(chatbot, history, prompt, file, file_history):
if (file == None):
chatbot = chatbot +[(prompt, None)]
else:
file_history = file
if (prompt == ""):
chatbot=chatbot + [((file.name,), "Prompt fehlt!")]
else:
chatbot = chatbot +[("Hochgeladenes Dokument: "+ get_filename(file) +"\n" + prompt, None)]
return chatbot, history, prompt, file, file_history, gr.Image(visible = False), ""
############################################
#nach dem Upload soll das zusätzliche Fenster mit dem image drinnen angezeigt werden
def file_anzeigen(file):
ext = analyze_file(file)
if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"):
return gr.Image(width=47, visible=True, interactive = False, height=47, min_width=47, show_label=False, show_share_button=False, show_download_button=False, scale = 0.5), file, file
else:
return gr.Image(width=47, visible=True, interactive = False, height=47, min_width=47, show_label=False, show_share_button=False, show_download_button=False, scale = 0.5), "data/file.png", file
def file_loeschen():
return None, gr.Image(visible = False)
############################################
#wenn 'Stop' Button geklickt, dann Message dazu und das Eingabe-Fenster leeren
def cancel_outputing():
reset_textbox()
return "Stop Done"
def reset_textbox():
return gr.update(value=""),""
####################################################
#aus einem Text-Prompt die Antwort von KI bekommen
def generate_text (prompt, chatbot, history, retriever, top_p=0.6, temperature=0.2, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3, top_k=35):
if (prompt == ""):
raise gr.Error("Prompt ist erforderlich.")
try:
#########################################
#Prompt mit History Daten zusammenstellen:
#Prompt an history anhängen und einen Text daraus machen
#history_text_und_prompt = generate_prompt_with_history(prompt, history)
#oder an Hugging Face --------------------------
print("HF Anfrage.......................")
#zusätzliche Dokumenten Splits aus DB zum Prompt hinzufügen (aus VektorDB - Chroma oder Mongo DB)
print("LLM aufrufen mit RAG: .....................................................")
##############################################
#Verschiedene Alternativen als llm übergeben an die rag-chain
#############################################
#0. Alternative - repo ID
# Verwenden Sie die Inference Api von huggingface_hub
#llm = InferenceApi(repo_id, token=hf_token)
#result = rag_chain(llm, history_text_und_prompt, retriever)
##############################################
#1.Alternative mit Inference API ung HF EndPoint
# Erstelle eine HuggingFaceEndPoints-Instanz mit den entsprechenden Endpunkt-Parametern
"""
llm = HuggingFaceEndpoint(
endpoint_url=f"https://api-inference.huggingface.co/models/{MODEL_NAME_HF}",
api_key=hf_token,
temperature=0.5,
max_length=1024,
top_k=top_k,
top_p=top_p,
repetition_penalty=repetition_penalty
)
result = rag_chain(llm, history_text_und_prompt, retriever)
#############################################
#2. Alternative: mit API_URL
#result = rag_chain(API_URL, history_text_und_prompt, retriever)
#############################################
#3.te Alternative für pipeline
# Erstelle eine Pipeline mit den gewünschten Parametern
#llm = pipeline("text-generation", model=MODEL_NAME_HF, config={"temperature": 0.5, "max_length": 1024, "num_return_sequences": 1, "top_k": top_k, "top_p": top_p, "repetition_penalty": repetition_penalty}, trust_remote_code=True)
#llm = pipeline("summarization", model=MODEL_NAME_HF, trust_remote_code=True)
#result = rag_chain(llm, history_text_und_prompt, retriever)
"""
result = rag_chain_simpel(prompt, retriever)
except Exception as e:
raise gr.Error(e)
return result, False
##############################################################
#Eingaben der GUI verarbeiten
def generate_auswahl(prompt_in, file, file_history, chatbot, history, anzahl_docs=4, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3,top_k=5, validate=False):
global vektordatenbank, SPLIT_TO_ORIGINAL_MAPPING
#nur wenn man sich validiert hat, kann die Anwendung los legen
if (validate and not prompt_in == "" and not prompt_in == None):
# Vektorstore initialisieren
#falls schon ein File hochgeladen wurde, ist es in history_file gespeichert - falls ein neues File hochgeladen wurde, wird es anschließend neu gesetzt
neu_file = file_history
#prompt normalisieren bevor er an die KIs geht
prompt = preprocess_text(prompt_in)
if vektordatenbank is None:
print("db neu aufbauen!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1")
#Splits zu allen Dokumenten in den Verzeichnissen erstellen
#vektordatenbank, SPLIT_TO_ORIGINAL_MAPPING werden aktualisiert
create_vectorstore()
if vektordatenbank:
#Retriever erstellen, um die relevanten Slpits zu einem Prompt zu suchen.... (retrieven)
retriever = vektordatenbank.as_retriever(search_kwargs = {"k": ANZAHL_DOCS})
#kein Bild hochgeladen -> auf Text antworten...
status = "Antwort der Vektordatenbank"
results, status = generate_text(prompt, chatbot, history, retriever, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3, top_k=3)
#in results sind die preprocessed Splits enthalten, dargestellt werden sollen die orginalen:
relevant_docs_org=[]
for result in results['relevant_docs']:
split_id = result.get("metadata", {}).get("split_id")
if split_id:
original_split = SPLIT_TO_ORIGINAL_MAPPING[split_id]
relevant_docs_org.append(original_split)
relevant_docs = extract_document_info(relevant_docs_org)
#Ergebnisse für history und chatbot zusammenstellen
summary = str(results['answer']) + "\n\n"
summary += " ".join([
'
'
#'
'
for doc in relevant_docs])
history = history + [[prompt_in, summary]]
chatbot[-1][1] = summary
return chatbot, history, None, file_history, ""
else:
chatbot[-1][1] = "keine Dokumente gefunden!"
return chatbot, history, None, file_history, ""
else: #noch nicht validiert, oder kein Prompt
return chatbot, history, None, file_history, "Erst validieren oder einen Prompt eingeben!"
########################################
# Hochladen von Dateien und Vektorstore neu erstellen
# Beispiel-Upload-PDF-Funktion
"""
def upload_pdf(files):
if not files:
logging.warning("No files uploaded.")
status_message = " Keine Dateien zum Hochladen"
else:
futures = []
with ThreadPoolExecutor() as pool:
for file in files:
try:
# Extrahieren des Dateinamens aus dem vollen Pfad
filename = os.path.basename(file.name)
# Extrahieren der Dateiendung
file_extension = os.path.splitext(filename)[1]
# Bestimmen des Upload-Pfads basierend auf der Dateiendung
if file_extension == ".pdf":
upload_path = f"chroma/kkg/pdf/{filename}"
elif file_extension == ".docx":
upload_path = f"chroma/kkg/word/{filename}"
else:
upload_path = f"chroma/kkg/{filename}"
# Entfernen der vorhandenen Datei, falls sie existiert
if os.path.exists(upload_path):
os.remove(upload_path)
# Hochladen der Datei
future = pool.submit(upload_file_to_huggingface, file.name, upload_path)
futures.append(future)
except Exception as e:
print("Fehler bei file upload...............")
# Warten, bis alle Uploads abgeschlossen sind
for future in futures:
try:
future.result()
status_message = "Dateien fertig hochgeladen"
except Exception as e:
logging.error(f"Error during file upload: {e}")
status_message = "Fehler beim Hochladen der Dateien."
# Nachdem alle Dateien hochgeladen wurden, den Vektorstore neu laden
try:
############################################
#Vektorstore neu....
############################################
#create_vectorstore()
logging.info("Vektorstore successfully renewed.")
status_message += " - Vektorstore wurde erneuert."
except Exception as e:
logging.error(f"Error renewing Vektorstore: {e}")
status_message += " - Fehler beim Erneuern des Vektorstores."
return status_message, display_files()
"""
def upload_pdf(files):
if not files:
logging.warning("No files uploaded.")
status_message = " Keine Dateien zum Hochladen"
else:
for file in files:
try:
# Extrahieren des Dateinamens aus dem vollen Pfad
filename = os.path.basename(file.name)
# Extrahieren der Dateiendung
file_extension = os.path.splitext(filename)[1]
# Bestimmen des Upload-Pfads basierend auf der Dateiendung
if file_extension == ".pdf":
upload_path = f"chroma/kkg/pdf/{filename}"
elif file_extension == ".docx":
upload_path = f"chroma/kkg/word/{filename}"
else:
upload_path = f"chroma/kkg/{filename}"
# Entfernen der vorhandenen Datei, falls sie existiert
if os.path.exists(upload_path):
os.remove(upload_path)
print("altes File removed.................")
print("file.name.............."+str(file.name))
print("upload_path.............."+str(upload_path))
# Datei zum Hugging Face Space hochladen
#upload_file_to_huggingface(file.name, upload_path)
except Exception as e:
logging.error(f"Error uploading file {file.name}: {e}")
status_message = "Nicht alle Dateien konnten hochgeladen werden..."
status_message = "Hochladen der Dateien abgeschlossen!"
return status_message, display_files()
# Nachdem alle Dateien hochgeladen wurden, den Vektorstore neu laden
def update_vectorstore():
try:
############################################
#Vektorstore neu....
############################################
create_vectorstore()
logging.info("Vektorstore successfully renewed.")
status_message += " - Vektorstore wurde erneuert."
except Exception as e:
logging.error(f"Error renewing Vektorstore: {e}")
status_message += " - Fehler beim Erneuern des Vektorstores."
########################################
# Bot- test gegen schädliche Bots die die Anwendung testen...
# Funktion zur Überprüfung der Benutzereingabe
# Funktion zur Überprüfung der Eingabe und Aktivierung der Hauptanwendung
def validate_input(user_input_validate, validate=False):
user_input_hashed = hash_input(user_input_validate)
if user_input_hashed == hash_input(ANTI_BOT_PW):
return "Richtig! Weiter gehts... ", True, gr.Textbox(visible=False), gr.Button(visible=False)
else:
return "Falsche Antwort!!!!!!!!!", False, gr.Textbox(label = "", placeholder="Bitte tippen Sie das oben im Moodle Kurs angegebene Wort ein, um zu beweisen, dass Sie kein Bot sind.", visible=True, scale= 5), gr.Button("Validieren", visible = True)
def custom_css():
return """
body, html {
background-color: #303030; /* Dunkler Hintergrund */
color:#353535;
}
"""
#############################################################################################
# Start Gui Vorabfrage
# Validierungs-Interface - Bots weghalten...
#################################################################################################
print ("Start GUI Hauptanwendung")
with open("custom.css", "r", encoding="utf-8") as f:
customCSS = f.read()
#Add Inputs für Tab 2
additional_inputs = [
gr.Slider(label="Temperature", value=0.65, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Höhere Werte erzeugen diversere Antworten", visible=True),
gr.Slider(label="Max new tokens", value=1024, minimum=0, maximum=4096, step=64, interactive=True, info="Maximale Anzahl neuer Tokens", visible=True),
gr.Slider(label="Top-p (nucleus sampling)", value=0.6, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Höhere Werte verwenden auch Tokens mit niedrigerer Wahrscheinlichkeit.", visible=True),
gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Strafe für wiederholte Tokens", visible=True)
]
with gr.Blocks(css=customCSS, theme=themeAlex) as demo:
#validiert speichern
validate = gr.State(True)
#Session Variablen, um Weete zu speichern, auch wenn die Felder in der GUI bereits wieder leer sind
# history parallel zu chatbot speichern - da in chatbot bei Bildern zum Anzeigen in der GUI die Bilder speziell formatiert werden,
# für die Übergabe an die ki aber der Pfad zum Bild behalten werden muss - was in der history der Fall ist!
history = gr.State([])
uploaded_file_paths= gr.State([])
history3 = gr.State([])
uploaded_file_paths3= gr.State([])
#alle chats einer Session sammeln
chats = gr.State({})
#damit der Prompt auch nach dem upload in die History noch für predicts_args verfügbar ist
user_question = gr.State("")
#für die anderen Tabs auch...
#damit der Prompt auch nach dem upload in die History noch für predicts_args verfügbar ist
user_question2 = gr.State("")
user_question3 = gr.State("")
attached_file = gr.State(None)
attached_file_history = gr.State(None)
attached_file3 = gr.State(None)
attached_file_history3 = gr.State(None)
status_display = gr.State("")
status_display2 = gr.State("")
status_display3 = gr.State("")
################################################
# Tab zum Chatbot mit Text oder Bildeingabe
################################################
gr.Markdown(description_top)
"""
with gr.Row():
user_input_validate =gr.Textbox(label= "Bitte das oben im Moodle Kurs angegebene Wort eingeben, um die Anwendung zu starten", visible=True, interactive=True, scale= 7)
validate_btn = gr.Button("Validieren", visible = True)
#validation_result = gr.Text(label="Validierungsergebnis")
"""
with gr.Tab("KKG KI-Suche"):
with gr.Row():
#gr.HTML("LI Chatot")
status_display = gr.Markdown("Antwort der KI ...", visible = True) #, elem_id="status_display")
with gr.Row():
with gr.Column(scale=5):
with gr.Row():
chatbot = gr.Chatbot(elem_id="li-chat",show_copy_button=True)
with gr.Row():
with gr.Column(scale=12):
user_input = gr.Textbox(
show_label=False, placeholder="Gib hier deine Such-Frage ein...",
container=False
)
with gr.Column(min_width=70, scale=1):
submitBtn = gr.Button("Senden")
with gr.Column(min_width=70, scale=1):
cancelBtn = gr.Button("Stop")
with gr.Row():
image_display = gr.Image( visible=False)
upload = gr.UploadButton("📁", file_types=["pdf", "docx", "pptx", "xlsx"], scale = 10, visible = False)
emptyBtn = gr.ClearButton([user_input, chatbot, history, attached_file, attached_file_history, image_display], value="🧹 Neue Session", scale=10)
with gr.Column(visible = False):
with gr.Column(min_width=50, scale=1):
with gr.Tab(label="KKG-Suche ..."):
#Geht nicht, da für alle gleichzeitig sichtbar
#chat_selector = gr.CheckboxGroup(label="", choices=update_chat_options())
#download_button = gr.Button("Download ausgewählte Chats")
file_download = gr.File(label="Noch keine Chatsverläufe", visible=True, interactive = False, file_count="multiple",)
with gr.Tab(label="Parameter"):
#gr.Markdown("# Parameters")
#rag_option = gr.Radio(["Aus", "An"], label="KKG Erweiterungen (RAG)", value = "Aus")
model_option = gr.Radio(["HuggingFace"], label="Modellauswahl", value = "HuggingFace")
#websuche = gr.Radio(["Aus", "An"], label="Web-Suche", value = "Aus")
top_p = gr.Slider(
minimum=-0,
maximum=1.0,
value=0.95,
step=0.05,
interactive=True,
label="Top-p",
visible=False,
)
top_k = gr.Slider(
minimum=1,
maximum=100,
value=35,
step=1,
interactive=True,
label="Top-k",
visible=False,
)
temperature = gr.Slider(
minimum=0.1,
maximum=2.0,
value=0.2,
step=0.1,
interactive=True,
label="Temperature",
visible=False
)
max_length_tokens = gr.Slider(
minimum=0,
maximum=512,
value=512,
step=8,
interactive=True,
label="Max Generation Tokens",
visible=False,
)
max_context_length_tokens = gr.Slider(
minimum=0,
maximum=4096,
value=2048,
step=128,
interactive=True,
label="Max History Tokens",
visible=False,
)
repetition_penalty=gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Strafe für wiederholte Tokens", visible=False)
anzahl_docs = gr.Slider(label="Anzahl Dokumente", value=3, minimum=1, maximum=10, step=1, interactive=True, info="wie viele Dokumententeile aus dem Vektorstore an den prompt gehängt werden", visible=False)
openai_key = gr.Textbox(label = "OpenAI API Key", value = "sk-", lines = 1, visible = False)
with gr.Tab("Datei hochladen"):
upload_pdf_files = gr.Files(label="PDF- oder Word-Dateien in Zwischenablage", file_count="multiple")
output_text = gr.Textbox(label="Status")
renew_button = gr.Button("Dateien hochladen und System aktualisieren", elem_id="renew_button")
file_list = gr.HTML(elem_id="file_list", show_label=False)
# Automatisches Ausführen der Upload-Funktion, wenn eine Datei hochgeladen wird
#upload_pdf_file.change(fn=upload_pdf, inputs=upload_pdf_file, outputs=output_text)
#upload_pdf_files.change(fn=upload_pdf, inputs=upload_pdf_files, outputs=[output_text, file_list]) #, postprocess=display_files)
#renew_button.click(fn=upload_pdf, inputs=upload_pdf_files, outputs=[output_text, file_list])
#gr.HTML(update=display_files, elem_id="file_list", show_label=False)
#demo.load(display_files, outputs=file_list)
"""
with gr.Tab("Datei hochladen"):
upload_pdf_file = gr.File(label="PDF- oder Word-Datei hochladen")
output_text = gr.Textbox(label="Status")
#upload_button = gr.Button("Datei hochladen")
file_list = gr.HTML(elem_id="file_list", show_label=False)
#upload_button.click(fn=upload_pdf, inputs=upload_pdf_file, outputs=output_text)
# Automatisches Ausführen der Upload-Funktion, wenn eine Datei hochgeladen wird
upload_pdf_file.change(fn=upload_pdf, inputs=upload_pdf_file, outputs=output_text)
#gr.HTML(update=display_files, elem_id="file_list", show_label=False)
demo.load(display_files, outputs=file_list)
"""
gr.Markdown(description)
######################################
# Events und Übergabe Werte an Funktionen
#######################################
######################################
# Für Tab 1: Chatbot
#Argumente für generate Funktion als Input
predict_args = dict(
fn=generate_auswahl,
inputs=[
user_question,
attached_file,
attached_file_history,
chatbot,
history,
anzahl_docs,
top_p,
temperature,
max_length_tokens,
max_context_length_tokens,
repetition_penalty,
top_k,
validate
],
outputs=[chatbot, history, attached_file, attached_file_history, status_display],
show_progress=True,
)
reset_args = dict(
fn=reset_textbox, inputs=[], outputs=[user_input, status_display]
)
# Chatbot
transfer_input_args = dict(
fn=add_text, inputs=[chatbot, history, user_input, attached_file, attached_file_history], outputs=[chatbot, history, user_question, attached_file, attached_file_history, image_display , user_input], show_progress=True
)
##############################################
# Button Events....
#Validation Button
# Event-Handler für die Validierung
#validate_btn.click(validate_input, inputs=[user_input_validate, validate], outputs=[status_display, validate, user_input_validate, validate_btn])
#user_input_validate.submit(validate_input, inputs=[user_input_validate, validate], outputs=[status_display, validate, user_input_validate, validate_btn])
#############################################
#1ter Tab
predict_event1 = user_input.submit(**transfer_input_args, queue=False,).then(**predict_args)
predict_event2 = submitBtn.click(**transfer_input_args, queue=False,).then(**predict_args)
predict_event3 = upload.upload(file_anzeigen, [upload], [image_display, image_display, attached_file] ) #.then(**predict_args)
emptyBtn.click(clear_all, [history, uploaded_file_paths, chats], [attached_file, image_display, uploaded_file_paths, history, file_download, chats])
#Bild Anzeige neben dem Button wieder entfernen oder austauschen..
image_display.select(file_loeschen, [], [attached_file, image_display])
#Berechnung oder Ausgabe anhalten (kann danach fortgesetzt werden)
cancelBtn.click(cancel_outputing, [], [status_display], cancels=[predict_event1,predict_event2, predict_event3])
############################################
#2ter Tab
#renew_button.click(fn=upload_pdf, inputs=upload_pdf_files, outputs=[output_text, file_list])
# Hochladen der Dateien und dann Vektorstore aktualisieren
renew_button.click(fn=upload_pdf, inputs=upload_pdf_files, outputs=[output_text, file_list]).then(
fn=update_vectorstore, inputs=None, outputs=output_text
)
demo.load(display_files, outputs=file_list)
demo.title = "KKG-Suche"
demo.queue(default_concurrency_limit=15).launch(debug=True)