Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Erstelle das vollständige skript für die anwendung, nutze dafür den folgenden…

  1. User

    Erstelle das vollständige skript für die anwendung, nutze dafür den folgenden gesprächsverlauf: "main.py

    import sys import subprocess import threading import time import requests import json

    from PyQt5.QtWidgets import ( QApplication, QMainWindow, QLabel, QPushButton, QComboBox, QHBoxLayout, QVBoxLayout, QWidget, QTextEdit, QFileDialog, QTreeWidget, QTreeWidgetItem, QTextBrowser, QProgressBar ) from PyQt5.QtCore import QTimer, Qt

    class MainWindow(QMainWindow): def init(self): super().init() self.setWindowTitle('Intelligenter Assistent für Entwickler') self.setGeometry(100, 100, 1200, 800) self.init_ui() self.update_llm_list() self.paused = False self.stopped = False

    def init_ui(self):
        # LLM-Auswahl
        llm_label = QLabel('Wählen Sie ein LLM:')
        self.llm_combo = QComboBox()
    
        # Server-Statusanzeige
        self.server_status_label = QLabel('Serverstatus: Gestoppt')
        self.server_status_indicator = QLabel('🔴')  # Rot für gestoppt
    
        # Server-Kontrollbuttons
        self.start_server_btn = QPushButton('Server starten')
        self.stop_server_btn = QPushButton('Server stoppen')
    
        h_layout = QHBoxLayout()
        h_layout.addWidget(llm_label)
        h_layout.addWidget(self.llm_combo)
    
        h_layout2 = QHBoxLayout()
        h_layout2.addWidget(self.server_status_label)
        h_layout2.addWidget(self.server_status_indicator)
        h_layout2.addWidget(self.start_server_btn)
        h_layout2.addWidget(self.stop_server_btn)
    
        # Anwendungsbeschreibung
        description_label = QLabel('Anwendungsbeschreibung:')
        self.description_text = QTextEdit()
    
        # Datei-Upload
        self.upload_btn = QPushButton('Dateien hochladen')
        self.uploaded_files = []
    
        # Analyse-Button
        self.analyse_btn = QPushButton('Analyse starten')
    
        # Plan anzeigen
        self.plan_tree = QTreeWidget()
        self.plan_tree.setHeaderLabels(['Teilaufgabe', 'Details'])
    
        # Bearbeitung starten Button
        self.start_processing_btn = QPushButton('Bearbeitung starten')
    
        # Chat-Bereich
        chat_label = QLabel('Chat-Bereich:')
        self.chat_area = QTextBrowser()
    
        # Kontrollbuttons
        control_layout = QHBoxLayout()
        self.pause_btn = QPushButton('Pausieren')
        self.stop_btn = QPushButton('Stoppen')
        self.resume_btn = QPushButton('Fortsetzen')
    
        control_layout.addWidget(self.pause_btn)
        control_layout.addWidget(self.stop_btn)
        control_layout.addWidget(self.resume_btn)
    
        # Fortschrittsanzeige
        self.progress_bar = QProgressBar()
        self.progress_bar.setValue(0)
    
        # Hauptlayout
        v_layout = QVBoxLayout()
        v_layout.addLayout(h_layout)
        v_layout.addLayout(h_layout2)
        v_layout.addWidget(description_label)
        v_layout.addWidget(self.description_text)
        v_layout.addWidget(self.upload_btn)
        v_layout.addWidget(self.analyse_btn)
        v_layout.addWidget(self.plan_tree)
        v_layout.addWidget(self.start_processing_btn)
        v_layout.addWidget(chat_label)
        v_layout.addWidget(self.chat_area)
        v_layout.addLayout(control_layout)
        v_layout.addWidget(self.progress_bar)
    
        container = QWidget()
        container.setLayout(v_layout)
        self.setCentralWidget(container)
    
        # Verbindungen
        self.start_server_btn.clicked.connect(self.start_server)
        self.stop_server_btn.clicked.connect(self.stop_server)
        self.upload_btn.clicked.connect(self.upload_files)
        self.analyse_btn.clicked.connect(self.start_analysis)
        self.start_processing_btn.clicked.connect(self.start_processing)
        self.pause_btn.clicked.connect(self.pause_processing)
        self.stop_btn.clicked.connect(self.stop_processing)
        self.resume_btn.clicked.connect(self.resume_processing)
    
        # Timer zum Überprüfen des Serverstatus
        self.timer = QTimer()
        self.timer.timeout.connect(self.check_server_status)
        self.timer.start(5000)  # Alle 5 Sekunden
    
    def get_available_llms(self):
        try:
            response = requests.get('http://localhost:11434/models')  # Standardport für Ollama
            if response.status_code == 200:
                models = response.json()
                model_names = [model['name'] for model in models]
                return model_names
            else:
                return []
        except Exception as e:
            print(f"Fehler beim Abrufen der Modelle: {e}")
            return []
    
    def update_llm_list(self):
        models = self.get_available_llms()
        self.llm_combo.clear()
        self.llm_combo.addItems(models)
    
    def start_server(self):
        try:
            # Prüfen, ob der Server bereits läuft
            response = requests.get('http://localhost:11434/models')
            if response.status_code == 200:
                self.server_status_label.setText('Serverstatus: Laufend')
                self.server_status_indicator.setText('🟢')
                return
        except:
            pass  # Server läuft nicht
    
        try:
            # Starten des Ollama-Servers
            self.ollama_process = subprocess.Popen(['ollama', 'serve'])
            # Warten, bis der Server verfügbar ist
            time.sleep(2)
            self.server_status_label.setText('Serverstatus: Laufend')
            self.server_status_indicator.setText('🟢')
            self.update_llm_list()
        except Exception as e:
            print(f"Fehler beim Starten des Servers: {e}")
            self.server_status_label.setText('Serverstatus: Fehler')
            self.server_status_indicator.setText('⚠️')
    
    def stop_server(self):
        try:
            # Beenden des Ollama-Servers
            self.ollama_process.terminate()
            self.ollama_process.wait()
            self.server_status_label.setText('Serverstatus: Gestoppt')
            self.server_status_indicator.setText('🔴')
        except Exception as e:
            print(f"Fehler beim Stoppen des Servers: {e}")
            self.server_status_label.setText('Serverstatus: Fehler')
            self.server_status_indicator.setText('⚠️')
    
    def check_server_status(self):
        try:
            response = requests.get('http://localhost:11434/models')
            if response.status_code == 200:
                self.server_status_label.setText('Serverstatus: Laufend')
                self.server_status_indicator.setText('🟢')
            else:
                self.server_status_label.setText('Serverstatus: Fehler')
                self.server_status_indicator.setText('⚠️')
        except:
            self.server_status_label.setText('Serverstatus: Gestoppt')
            self.server_status_indicator.setText('🔴')
    
    def upload_files(self):
        options = QFileDialog.Options()
        files, _ = QFileDialog.getOpenFileNames(
            self, "Dateien auswählen", "", 
            "Alle Dateien (*)", options=options
        )
        if files:
            self.uploaded_files.extend(files)
            print("Hochgeladene Dateien:", self.uploaded_files)
            # Optional: Anzeige der Dateien im GUI
    
    def start_analysis(self):
        self.chat_area.append("<b>Assistent:</b> Starte die Analyse der Anwendungsbeschreibung...")
        threading.Thread(target=self.perform_analysis).start()
    
    def perform_analysis(self):
        description = self.description_text.toPlainText()
        selected_llm = self.llm_combo.currentText()
        plan = self.generate_plan(description, selected_llm)
        if plan:
            self.display_plan(plan)
            self.chat_area.append("<b>Assistent:</b> Analyse abgeschlossen. Der Plan wurde erstellt.")
        else:
            self.chat_area.append("<b>Assistent:</b> Fehler bei der Analyse.")
    
    def generate_plan(self, description, llm):
        try:
            file_contents = ""
            for file_path in self.uploaded_files:
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read()
                    file_contents += f"\n--- Inhalt von {file_path} ---\n{content}\n"
    
            prompt = f"""
            Du bist ein erfahrener Softwareentwickler. Basierend auf folgender Anwendungsbeschreibung und den bereitgestellten Dateien, erstelle einen detaillierten Entwicklungsplan. Zerlege die Aufgaben in Teilaufgaben mit Titeln, Beschreibungen und konkreten Zielen.
    
            Anwendungsbeschreibung:
            {description}
    
            Dateien:
            {file_contents}
            """
    
            payload = {
                "model": llm,
                "prompt": prompt
            }
            response = requests.post('http://localhost:11434/generate', json=payload)
            if response.status_code == 200:
                plan_text = response.json()['response']
                plan = self.parse_plan(plan_text)
                return plan
            else:
                print(f"Fehler bei der Planerstellung: {response.text}")
                return []
        except Exception as e:
            print(f"Fehler bei der Kommunikation mit dem LLM: {e}")
            return []
    
    def parse_plan(self, plan_text):
        # Hier müssen Sie den vom LLM generierten Plantext in ein Python-Objekt umwandeln.
        # Angenommen, der Plan wird im JSON-Format zurückgegeben.
        try:
            plan = json.loads(plan_text)
            return plan
        except json.JSONDecodeError:
            # Falls der Plan nicht im JSON-Format ist, müssen Sie einen Parser implementieren.
            print("Fehler beim Parsen des Plans.")
            return []
    
    def display_plan(self, plan):
        self.plan_tree.clear()
        for task in plan:
            task_item = QTreeWidgetItem([task['Titel']])
            description_item = QTreeWidgetItem(['Beschreibung', task['Beschreibung']])
            task_item.addChild(description_item)
    
            goals_item = QTreeWidgetItem(['Ziele'])
            for goal in task['Ziele']:
                goal_item = QTreeWidgetItem([goal])
                goals_item.addChild(goal_item)
            task_item.addChild(goals_item)
    
            self.plan_tree.addTopLevelItem(task_item)
    
    def start_processing(self):
        self.chat_area.append("<b>Assistent:</b> Beginne mit der Bearbeitung der Teilaufgaben.")
        self.processing_thread = threading.Thread(target=self.process_tasks)
        self.processing_thread.start()
    
    def process_tasks(self):
        self.paused = False
        self.stopped = False
        total_tasks = self.plan_tree.topLevelItemCount()
        for i in range(total_tasks):
            if self.stopped:
                break
            while self.paused:
                time.sleep(0.1)
            task_item = self.plan_tree.topLevelItem(i)
            self.chat_area.append(f"<b>Assistent:</b> Bearbeite {task_item.text(0)}.")
            self.process_task(task_item)
            progress = int(((i + 1) / total_tasks) * 100)
            self.update_progress(progress)
        else:
            if not self.stopped:
                self.chat_area.append("<b>Assistent:</b> Alle Teilaufgaben wurden abgeschlossen.")
                self.chat_area.append("<b>Assistent:</b> Generiere das Endergebnis...")
                self.display_final_result()
    
    def process_task(self, task_item):
        task_title = task_item.text(0)
        task_description = task_item.child(0).text(1)  # Annahme, dass Beschreibung das erste Kind ist
        goals_item = task_item.child(1)  # Annahme, dass Ziele das zweite Kind sind
        goals = [goals_item.child(i).text(0) for i in range(goals_item.childCount())]
    
        for goal in goals:
            if self.stopped:
                break
            while self.paused:
                time.sleep(0.1)
            self.chat_area.append(f"<b>Assistent:</b> Bearbeite Ziel: {goal}")
            # Kommunikation mit dem LLM
            result = self.llm_process_goal(task_title, goal)
            self.chat_area.append(f"<b>Assistent:</b> Ergebnis für {goal}:\n{result}")
    
    def llm_process_goal(self, task_title, goal):
        selected_llm = self.llm_combo.currentText()
        prompt = f"""
        Im Rahmen von "{task_title}" bearbeite folgendes Ziel:
    
        "{goal}"
    
        Verwende die Anwendungsbeschreibung und die bereitgestellten Dateien als Referenz. Liefere ausführlichen Code oder eine detaillierte Beschreibung, die das Ziel erfüllt.
        """
        payload = {
            "model": selected_llm,
            "prompt": prompt
        }
        try:
            response = requests.post('http://localhost:11434/generate', json=payload)
            if response.status_code == 200:
                result = response.json()['response']
                return result
            else:
                return f"Fehler: {response.text}"
        except Exception as e:
            return f"Fehler bei der Kommunikation mit dem LLM: {e}"
    
    def update_progress(self, value):
        self.progress_bar.setValue(value)
    
    def pause_processing(self):
        self.paused = True
        self.chat_area.append("<b>System:</b> Der Prozess wurde pausiert.")
    
    def resume_processing(self):
        if self.paused:
            self.paused = False
            self.chat_area.append("<b>System:</b> Der Prozess wird fortgesetzt.")
    
    def stop_processing(self):
        self.stopped = True
        self.chat_area.append("<b>System:</b> Der Prozess wurde gestoppt.")
    
    def display_final_result(self):
        selected_llm = self.llm_combo.currentText()
        prompt = """
        Fasst alle bisher erstellten Ergebnisse zusammen und generiere den vollständigen Code der Anwendung inklusive Dokumentation.
        """
    
        payload = {
            "model": selected_llm,
            "prompt": prompt
        }
        try:
            response = requests.post('http://localhost:11434/generate', json=payload)
            if response.status_code == 200:
                result = response.json()['response']
            else:
                result = f"Fehler bei der Generierung des Endergebnisses: {response.text}"
        except Exception as e:
            result = f"Fehler bei der Kommunikation mit dem LLM: {e}"
    
        self.result_window = QWidget()
        self.result_window.setWindowTitle('Endergebnis')
        layout = QVBoxLayout()
        result_label = QLabel('Zusammenfassung der Anwendung mit Code:')
        result_text = QTextBrowser()
        result_text.setText(result)
        layout.addWidget(result_label)
        layout.addWidget(result_text)
        self.result_window.setLayout(layout)
        self.result_window.resize(800, 600)
        self.result_window.show()
    

    if name == 'main': app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(app.exec_())

    Erläuterungen zum Code Importierte Module

    sys: Erforderlich für die Anwendung.
    subprocess: Zum Starten und Stoppen des Ollama-Servers.
    threading: Für die gleichzeitige Bearbeitung ohne die GUI zu blockieren.
    time: Für Wartezeiten und Pausen.
    requests: Für HTTP-Anfragen an den Ollama-Server.
    json: Zum Parsen und Erstellen von JSON-Daten.
    PyQt5.QtWidgets: Für die GUI-Komponenten.
    PyQt5.QtCore: Für den Timer und andere Core-Funktionen.
    

    Hauptklasse MainWindow

    Die Klasse MainWindow erbt von QMainWindow und enthält alle Funktionen der Anwendung. Methoden:

    __init__: Initialisiert das Fenster und die Benutzeroberfläche.
    init_ui: Baut die GUI-Komponenten auf und verbindet die Signale mit den Slots.
    get_available_llms: Ruft die verfügbaren LLMs vom Ollama-Server ab.
    update_llm_list: Aktualisiert die LLM-Auswahlliste.
    start_server: Startet den Ollama-Server.
    stop_server: Stoppt den Ollama-Server.
    check_server_status: Überprüft regelmäßig den Status des Servers.
    upload_files: Ermöglicht das Hochladen von Dateien.
    start_analysis: Startet die Analyse der Anwendungsbeschreibung.
    perform_analysis: Führt die Analyse in einem separaten Thread durch.
    generate_plan: Kommuniziert mit dem LLM, um einen Plan zu erstellen.
    parse_plan: Parst den vom LLM erhaltenen Plan in ein verwendbares Format.
    display_plan: Zeigt den Plan im GUI an.
    start_processing: Startet die Bearbeitung der Teilaufgaben.
    process_tasks: Bearbeitet die Teilaufgaben sequenziell.
    process_task: Bearbeitet eine einzelne Teilaufgabe.
    llm_process_goal: Kommuniziert mit dem LLM, um ein Ziel zu bearbeiten.
    update_progress: Aktualisiert die Fortschrittsanzeige.
    pause_processing: Pausiert die Bearbeitung.
    resume_processing: Setzt die Bearbeitung fort.
    stop_processing: Stoppt die Bearbeitung.
    display_final_result: Zeigt das vom LLM generierte Endergebnis an.
    

    Hinweise zur Verwendung

    Ollama installieren: Stellen Sie sicher, dass Ollama korrekt auf Ihrem System installiert ist und dass mindestens ein Modell verfügbar ist.
    
    Anwendung starten:
        Führen Sie die Anwendung über die Kommandozeile aus:
    
        python main.py
    
    LLM auswählen: Wählen Sie im Dropdown-Menü das gewünschte LLM aus.
    
    Server starten: Klicken Sie auf "Server starten", um den Ollama-Server zu starten.
    
    Anwendungsbeschreibung eingeben: Geben Sie im Textfeld die Beschreibung Ihrer Anwendung ein.
    
    Dateien hochladen (optional): Laden Sie relevante Dateien hoch, die bei der Planerstellung helfen.
    
    Analyse starten: Klicken Sie auf "Analyse starten", um den Plan zu erstellen.
    
    Plan überprüfen: Der generierte Plan wird im Plan-Bereich angezeigt.
    
    Bearbeitung starten: Klicken Sie auf "Bearbeitung starten", um die Teilaufgaben zu bearbeiten.
    
    Fortschritt verfolgen: Verfolgen Sie den Fortschritt und die Kommunikation im Chat-Bereich.
    
    Kontrolle: Nutzen Sie die Buttons "Pausieren", "Stoppen" und "Fortsetzen", um den Prozess zu steuern.
    
    Endergebnis anzeigen: Nach Abschluss wird das Endergebnis in einem neuen Fenster angezeigt.
    

    Wichtige Hinweise

    Fehlerbehandlung: Die Anwendung enthält grundlegende Fehlerbehandlungen. Bei unerwarteten Fehlermeldungen überprüfen Sie bitte die Verbindung zum Ollama-Server und die Verfügbarkeit der Modelle.
    
    Anpassung des Parsers: Die Methode parse_plan erwartet, dass der Plan vom LLM im JSON-Format zurückgegeben wird. Falls Ihr LLM ein anderes Format liefert, müssen Sie den Parser entsprechend anpassen.
    
    Sicherheit: Stellen Sie sicher, dass keine sensiblen Daten in den Anwendungsbeschreibungen oder den hochgeladenen Dateien enthalten sind, da diese an das LLM gesendet werden.
    
    Leistungsfähigkeit des LLMs: Die Qualität der Ergebnisse hängt stark vom verwendeten LLM ab. Höherwertige Modelle liefern in der Regel bessere Ergebnisse.
    
    Erweiterungen: Der Code bietet eine Grundlage und kann nach Bedarf erweitert und angepasst werden. Beispielsweise können Sie die GUI verbessern, zusätzliche Funktionen hinzufügen oder die Interaktion mit dem LLM optimieren.
    

    Zusammenfassung

    Die Anwendung ermöglicht es Entwicklern, mittels eines intelligenten Assistenten und unter Verwendung von lokalen LLMs, den Entwicklungsprozess von Anwendungen zu automatisieren und zu optimieren. Durch die Integration mit der Ollama-Plattform und einer intuitiven Benutzeroberfläche können Ideen schnell in detaillierte Pläne und letztlich in fertigen Code umgesetzt werden.

    Ich hoffe, dieser ausführliche Code und die Erläuterungen helfen Ihnen weiter. Bei weiteren Fragen oder wenn Sie Hilfe bei spezifischen Anpassungen benötigen, stehe ich gerne zur Verfügung!

    entwickel die anwendung weiter und verbesser den code in den wichtigsten bereichen der anwendung um die resultate so qualitativ hochwertig wie möglich zu machen. Verbesser auch das gui um alle informationen und funktionen übersichtlich dem nutzer darzustellen.

    Gerne werde ich die Anwendung weiterentwickeln und den Code in den wichtigsten Bereichen verbessern, um qualitativ hochwertige Ergebnisse zu erzielen. Zusätzlich werde ich das GUI überarbeiten, um alle Informationen und Funktionen übersichtlich und benutzerfreundlich darzustellen. Ziele der Weiterentwicklung

    Verbesserung der Codequalität:
        Modularisierung des Codes zur besseren Wartbarkeit.
        Hinzufügen von Fehler- und Ausnahmebehandlungen.
        Optimierung der Kommunikation mit dem LLM.
        Verwendung von asynchroner Programmierung, um die GUI responsiver zu machen.
    
    Verbesserung der GUI:
        Überarbeitung des Layouts für bessere Übersichtlichkeit.
        Hinzufügen von Tabs oder Bereichen für unterschiedliche Funktionen.
        Anzeige der hochgeladenen Dateien im GUI.
        Verbesserte Fortschrittsanzeige und detailliertere Statusmeldungen.
        Hinzufügen von Menüs und Werkzeugleisten für erweiterte Funktionen.
    
    1. Verbesserung der Codequalität a) Modularisierung des Codes

    Wir extrahieren logische Teile des Codes in separate Klassen oder Funktionen, um die Wartbarkeit und Lesbarkeit zu erhöhen. Beispiel: Auslagern der LLM-Interaktion in eine eigene Klasse

    class LLMClient: def init(self, base_url='http://localhost:11434'): self.base_url = base_url

    def get_models(self):
        try:
            response = requests.get(f'{self.base_url}/models')
            response.raise_for_status()
            models = response.json()
            model_names = [model['name'] for model in models]
            return model_names
        except requests.RequestException as e:
            print(f"Fehler beim Abrufen der Modelle: {e}")
            return []
    
    def generate(self, model, prompt):
        payload = {
            "model": model,
            "prompt": prompt
        }
        try:
            response = requests.post(f'{self.base_url}/generate', json=payload)
            response.raise_for_status()
            result = response.json().get('response', '')
            return result
        except requests.RequestException as e:
            return f"Fehler bei der Kommunikation mit dem LLM: {e}"
    

    Vorteile:

    Kapselung der LLM-Interaktion, sodass Änderungen an der API nur an einer Stelle vorgenommen werden müssen.
    Verbesserung der Lesbarkeit des Hauptcodes.
    

    b) Hinzufügen von Fehler- und Ausnahmebehandlungen

    Wir stellen sicher, dass mögliche Fehler abgefangen und dem Benutzer aussagekräftige Fehlermeldungen angezeigt werden. Beispiel: Fehlerbehandlung beim Parsen des Plans

    def parse_plan(self, plan_text): try: plan = json.loads(plan_text) return plan except json.JSONDecodeError: try: # Wenn der Text kein gültiges JSON ist, versuchen wir es mit einem alternativen Parser plan = self.alternative_plan_parser(plan_text) return plan except Exception as e: print(f"Fehler beim Parsen des Plans: {e}") return []

    def alternative_plan_parser(self, text): # Implementierung eines einfachen Parsers für das vom LLM zurückgegebene Textformat # ... pass

    c) Optimierung der Kommunikation mit dem LLM

    Wir verbessern die Prompts, um qualitativ hochwertigere Ergebnisse vom LLM zu erhalten. Beispiel: Verbessertes Prompt-Engineering

    def generate_plan(self, description, llm): try: file_contents = self.get_file_contents() prompt = f""" Du bist ein erfahrener Softwarearchitekt. Bitte erstelle basierend auf der folgenden Anwendungsbeschreibung und den bereitgestellten Dateien einen detaillierten Entwicklungsplan.

        **Anwendungsbeschreibung:**
        {description}
    
        **Bereitgestellte Dateien:**
        {file_contents}
    
        **Anforderungen an den Entwicklungsplan:**
        - Strukturierte Auflistung von Teilaufgaben.
        - Jede Teilaufgabe enthält einen Titel, eine Beschreibung und klare Ziele.
        - Verwende JSON-Format für die Ausgabe.
    
        **Beispielausgabe:**
        [
            {{
                "Titel": "Teilaufgabe 1: XYZ",
                "Beschreibung": "Beschreibung der Teilaufgabe.",
                "Ziele": ["Ziel 1", "Ziel 2"]
            }},
            ...
        ]
        """
        plan_text = self.llm_client.generate(llm, prompt)
        plan = self.parse_plan(plan_text)
        return plan
    except Exception as e:
        print(f"Fehler bei der Generierung des Plans: {e}")
        return []
    

    Vorteile:

    Durch das Bereitstellen eines Beispielausgabeformats erhöhen wir die Wahrscheinlichkeit, dass das LLM die gewünschte Struktur liefert.
    Klare Anweisungen führen zu konsistenteren Ergebnissen.
    

    d) Verwendung von asynchroner Programmierung

    Wir nutzen asynchrone Programmierung, um langlaufende Aufgaben aus der Haupt-GUI-Schleife auszulagern und die Reaktionsfähigkeit der Anwendung zu verbessern. Beispiel: Verwendung von QThread für nebenläufige Aufgaben

    from PyQt5.QtCore import QThread, pyqtSignal

    class TaskProcessor(QThread): progress_updated = pyqtSignal(int) task_message = pyqtSignal(str)

    def __init__(self, tasks, llm_client, llm_model):
        super().__init__()
        self.tasks = tasks
        self.llm_client = llm_client
        self.llm_model = llm_model
        self._paused = False
        self._stopped = False
    
    def run(self):
        total_tasks = len(self.tasks)
        for i, task_item in enumerate(self.tasks):
            if self._stopped:
                break
            while self._paused:
                time.sleep(0.1)
            # Bearbeitung der Aufgabe
            self.task_message.emit(f"Assistent: Bearbeite {task_item['Titel']}")
            self.process_task(task_item)
            progress = int(((i + 1) / total_tasks) * 100)
            self.progress_updated.emit(progress)
        else:
            if not self._stopped:
                self.task_message.emit("Assistent: Alle Teilaufgaben wurden abgeschlossen.")
    
    def process_task(self, task_item):
        # Implementierung der Aufgabenbearbeitung
        # ...
        pass
    
    def pause(self):
        self._paused = True
    
    def resume(self):
        self._paused = False
    
    def stop(self):
        self._stopped = True
    

    Im MainWindow verbinden wir die Signale mit den entsprechenden Slots:

    class MainWindow(QMainWindow): # ... def start_processing(self): self.chat_area.append("Assistent: Beginne mit der Bearbeitung der Teilaufgaben.") self.task_processor = TaskProcessor( tasks=self.plan_tasks, llm_client=self.llm_client, llm_model=self.llm_combo.currentText() ) self.task_processor.progress_updated.connect(self.update_progress) self.task_processor.task_message.connect(self.append_chat_message) self.task_processor.start()

    def append_chat_message(self, message):
        self.chat_area.append(f"<b>{message}</b>")
    

    Vorteile:

    Asynchrone Verarbeitung verhindert, dass die GUI während der Bearbeitung einfriert.
    Verbesserte Benutzererfahrung durch eine responsive Benutzeroberfläche.
    

    2. Verbesserung der GUI a) Überarbeitung des Layouts

    Wir strukturieren das GUI neu, um die Informationen besser zu organisieren. Beispiel: Verwendung von Tabs

    from PyQt5.QtWidgets import QTabWidget

    class MainWindow(QMainWindow): # ... def init_ui(self): # Erstellen von Tabs self.tabs = QTabWidget() self.tabs.addTab(self.create_configuration_tab(), "Konfiguration") self.tabs.addTab(self.create_plan_tab(), "Planung") self.tabs.addTab(self.create_chat_tab(), "Assistent") self.setCentralWidget(self.tabs)

    def create_configuration_tab(self):
        # Tab für Konfiguration (LLM-Auswahl, Server-Management)
        # ...
        return config_widget
    
    def create_plan_tab(self):
        # Tab für Planerstellung und Anzeige
        # ...
        return plan_widget
    
    def create_chat_tab(self):
        # Tab für Chat-Bereich und Ergebnisse
        # ...
        return chat_widget
    

    Vorteile:

    Trennung von Konfiguration, Planung und Interaktion erleichtert die Navigation.
    Bessere Übersichtlichkeit durch Gruppierung verwandter Funktionen.
    

    b) Anzeige der hochgeladenen Dateien

    Wir fügen eine Liste hinzu, die die hochgeladenen Dateien anzeigt.

    from PyQt5.QtWidgets import QListWidget

    class MainWindow(QMainWindow): # ... def create_configuration_tab(self): # ... self.file_list = QListWidget() v_layout.addWidget(QLabel('Hochgeladene Dateien:')) v_layout.addWidget(self.file_list) # ...

    def upload_files(self):
        # ...
        if files:
            self.uploaded_files.extend(files)
            for file in files:
                self.file_list.addItem(file)
    

    c) Verbesserte Fortschrittsanzeige

    Zusätzlich zur Fortschrittsleiste fügen wir detailliertere Statusmeldungen hinzu.

    class MainWindow(QMainWindow): # ... def init_ui(self): # ... self.status_bar = self.statusBar() # ...

    def update_progress(self, value):
        self.progress_bar.setValue(value)
        self.status_bar.showMessage(f'Fortschritt: {value}%')
    

    d) Hinzufügen von Menüs und Werkzeugleisten

    Wir fügen eine Menüleiste und eine Werkzeugleiste hinzu, um zusätzliche Funktionen bereitzustellen.

    class MainWindow(QMainWindow): # ... def init_ui(self): # Erstellen der Menüleiste menu_bar = self.menuBar()

        # Datei-Menü
        file_menu = menu_bar.addMenu('Datei')
        exit_action = QAction('Beenden', self)
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
    
        # Hilfe-Menü
        help_menu = menu_bar.addMenu('Hilfe')
        about_action = QAction('Über', self)
        about_action.triggered.connect(self.show_about_dialog)
        help_menu.addAction(about_action)
    
        # Werkzeugleiste
        tool_bar = self.addToolBar('Werkzeuge')
        start_action = QAction('Start', self)
        start_action.triggered.connect(self.start_processing)
        tool_bar.addAction(start_action)
        pause_action = QAction('Pause', self)
        pause_action.triggered.connect(self.pause_processing)
        tool_bar.addAction(pause_action)
        stop_action = QAction('Stop', self)
        stop_action.triggered.connect(self.stop_processing)
        tool_bar.addAction(stop_action)
    

    Vorteile:

    Schnellzugriff auf häufig verwendete Funktionen.
    Verbesserte Benutzerfreundlichkeit durch bekannte Interface-Elemente.
    

    e) Zusätzliche Einstellungen

    Wir bieten dem Benutzer mehr Kontrolle durch erweiterte Einstellungsmöglichkeiten.

    class MainWindow(QMainWindow): # ... def create_configuration_tab(self): # ... # Einstellungen settings_group = QGroupBox('Einstellungen') settings_layout = QFormLayout() self.token_limit_spin = QSpinBox() self.token_limit_spin.setRange(100, 10000) self.token_limit_spin.setValue(1000) settings_layout.addRow('Token-Limit:', self.token_limit_spin) settings_group.setLayout(settings_layout) v_layout.addWidget(settings_group) # ...

    1. Gesamtcode mit Verbesserungen

    Da der aktualisierte Code sehr umfangreich ist, werde ich hier einen Auszug der wichtigsten Änderungen präsentieren. Der vollständige Code sollte entsprechend den obigen Beispielen aktualisiert werden. Zusammenfassung der Verbesserungen

    Codequalität:
        Kapselung der LLM-Interaktion in eine eigene Klasse (LLMClient).
        Verbesserung der Prompts für bessere Ergebnisse vom LLM.
        Verwendung von QThread für asynchrone Verarbeitung.
        Hinzufügen von Fehler- und Ausnahmebehandlungen.
    
    GUI-Verbesserungen:
        Einführung von Tabs (Konfiguration, Planung, Assistent) für bessere Übersichtlichkeit.
        Anzeige der hochgeladenen Dateien in einer Liste.
        Verbesserte Fortschritts- und Statusanzeigen.
        Hinzufügen von Menü- und Werkzeugleisten.
        Erweiterte Einstellungsmöglichkeiten für den Benutzer.
    

    Weiterführende Schritte

    Testen Sie die Anwendung gründlich, um sicherzustellen, dass alle Funktionen wie erwartet funktionieren.
    Sammeln Sie Feedback von Benutzern, um weitere Verbesserungen vorzunehmen.
    Dokumentieren Sie den Code und die Funktionen, um die Wartung und Erweiterung der Anwendung zu erleichtern.
    Erwägen Sie die Umstellung auf neuere Technologien oder Frameworks, falls dies die Leistung oder Benutzererfahrung verbessert.
    

    Schlusswort

    Durch die vorgenommenen Verbesserungen sollte die Anwendung nun effizienter arbeiten und dem Benutzer eine bessere Erfahrung bieten. Die Codequalität wurde erhöht, was die Wartbarkeit und Erweiterbarkeit der Anwendung verbessert. Das überarbeitete GUI bietet eine klarere Darstellung aller Informationen und Funktionen, was die Bedienung erleichtert.

    Wenn Sie weitere Unterstützung benötigen oder spezifische Anpassungen wünschen, stehe ich Ihnen gerne zur Verfügung!

    import sys import subprocess import threading import time import requests import json import logging import asyncio import aiohttp

    from PyQt5.QtWidgets import ( QApplication, QMainWindow, QLabel, QPushButton, QComboBox, QAction, QHBoxLayout, QVBoxLayout, QWidget, QTextEdit, QFileDialog, QTreeWidget, QTreeWidgetItem, QTextBrowser, QProgressBar, QTabWidget, QListWidget, QStatusBar, QMenuBar, QToolBar, QDialog, QGroupBox, QFormLayout, QSpinBox, QPlainTextEdit ) from PyQt5.QtCore import QTimer, Qt, QThread, pyqtSignal

    Konfiguration des Loggings

    logging.basicConfig(level=logging.INFO, filename='app.log', filemode='w', format='%(asctime)s - %(levelname)s - %(message)s')

    class LLMClient: def init(self, base_url='http://localhost:11434'): self.base_url = base_url self.cache = {}

    def get_models(self):
        try:
            response = requests.get(f'{self.base_url}/models')
            response.raise_for_status()
            models = response.json()
            model_names = [model['name'] for model in models]
            return model_names
        except requests.RequestException as e:
            logging.error(f"Fehler beim Abrufen der Modelle: {e}")
            return []
    
    def generate(self, model, prompt):
        cache_key = (model, prompt)
        if cache_key in self.cache:
            return self.cache[cache_key]
        payload = {
            "model": model,
            "prompt": prompt
        }
        try:
            response = requests.post(f'{self.base_url}/generate', json=payload)
            response.raise_for_status()
            result = response.json().get('response', '')
            self.cache[cache_key] = result
            return result
        except requests.RequestException as e:
            logging.error(f"Fehler bei der Kommunikation mit dem LLM: {e}")
            return f"Fehler bei der Kommunikation mit dem LLM: {e}"
    

    class TaskProcessor(QThread): progress_updated = pyqtSignal(int) task_message = pyqtSignal(str) task_result = pyqtSignal(str)

    def __init__(self, tasks, llm_client, llm_model):
        super().__init__()
        self.tasks = tasks
        self.llm_client = llm_client
        self.llm_model = llm_model
        self._paused = False
        self._stopped = False
    
    def run(self):
        total_tasks = len(self.tasks)
        for i, task in enumerate(self.tasks):
            if self._stopped:
                break
            while self._paused:
                time.sleep(0.1)
            self.task_message.emit(f"Assistent: Bearbeite {task['Titel']}")
            result = self.process_task(task)
            self.task_result.emit(f"Ergebnis für {task['Titel']}:\n{result}")
            progress = int(((i + 1) / total_tasks) * 100)
            self.progress_updated.emit(progress)
        else:
            if not self._stopped:
                self.task_message.emit("Assistent: Alle Teilaufgaben wurden abgeschlossen.")
    
    def process_task(self, task):
        prompt = f"""
        Bearbeite die folgende Teilaufgabe:
    
        **Titel:**
        {task['Titel']}
    
        **Beschreibung:**
        {task['Beschreibung']}
    
        **Ziele:**
        {', '.join(task['Ziele'])}
    
        Liefere ausführlichen Code oder eine detaillierte Beschreibung, die das Ziel erfüllt.
        """
        result = self.llm_client.generate(self.llm_model, prompt)
        return result
    
    def pause(self):
        self._paused = True
    
    def resume(self):
        self._paused = False
    
    def stop(self):
        self._stopped = True
    

    class MainWindow(QMainWindow): def init(self): super().init() self.setWindowTitle('Intelligenter Assistent für Entwickler') self.setGeometry(100, 100, 1200, 800) self.llm_client = LLMClient() self.paused = False self.stopped = False self.plan_data = [] self.uploaded_files = [] self.init_ui() self.update_llm_list() self.apply_styles()

    def init_ui(self):
        self.create_menu()
        self.create_toolbar()
        self.status_bar = self.statusBar()
        self.status_bar.showMessage('Bereit')
    
        self.tabs = QTabWidget()
        self.tabs.addTab(self.create_configuration_tab(), "Konfiguration")
        self.tabs.addTab(self.create_plan_tab(), "Planung")
        self.tabs.addTab(self.create_chat_tab(), "Assistent")
        self.setCentralWidget(self.tabs)
    
        # Timer zum Überprüfen des Serverstatus
        self.timer = QTimer()
        self.timer.timeout.connect(self.check_server_status)
        self.timer.start(5000)  # Alle 5 Sekunden
    
    def create_menu(self):
        menu_bar = self.menuBar()
    
        # Datei-Menü
        file_menu = menu_bar.addMenu('Datei')
        save_action = QAction('Speichern', self)
        save_action.triggered.connect(self.save_project)
        file_menu.addAction(save_action)
        load_action = QAction('Laden', self)
        load_action.triggered.connect(self.load_project)
        file_menu.addAction(load_action)
        settings_action = QAction('Einstellungen', self)
        settings_action.triggered.connect(self.open_settings_dialog)
        file_menu.addAction(settings_action)
        exit_action = QAction('Beenden', self)
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
    
        # Hilfe-Menü
        help_menu = menu_bar.addMenu('Hilfe')
        about_action = QAction('Über', self)
        about_action.triggered.connect(self.show_about_dialog)
        help_menu.addAction(about_action)
    
    def create_toolbar(self):
        tool_bar = self.addToolBar('Werkzeuge')
        start_action = QAction('Start', self)
        start_action.triggered.connect(self.start_processing)
        tool_bar.addAction(start_action)
        pause_action = QAction('Pause', self)
        pause_action.triggered.connect(self.pause_processing)
        tool_bar.addAction(pause_action)
        stop_action = QAction('Stop', self)
        stop_action.triggered.connect(self.stop_processing)
        tool_bar.addAction(stop_action)
    
    def create_configuration_tab(self):
        config_widget = QWidget()
        v_layout = QVBoxLayout()
    
        llm_label = QLabel('Wählen Sie ein LLM:')
        self.llm_combo = QComboBox()
    
        self.server_status_label = QLabel('Serverstatus: Gestoppt')
        self.server_status_indicator = QLabel('🔴')
    
        self.start_server_btn = QPushButton('Server starten')
        self.stop_server_btn = QPushButton('Server stoppen')
    
        h_layout = QHBoxLayout()
        h_layout.addWidget(llm_label)
        h_layout.addWidget(self.llm_combo)
    
        h_layout2 = QHBoxLayout()
        h_layout2.addWidget(self.server_status_label)
        h_layout2.addWidget(self.server_status_indicator)
        h_layout2.addWidget(self.start_server_btn)
        h_layout2.addWidget(self.stop_server_btn)
    
        # Anwendungsbeschreibung
        description_label = QLabel('Anwendungsbeschreibung:')
        self.description_text = QTextEdit()
    
        # Datei-Upload
        self.upload_btn = QPushButton('Dateien hochladen')
        self.file_list = QListWidget()
    
        # Einstellungen
        settings_group = QGroupBox('Einstellungen')
        settings_layout = QFormLayout()
        self.token_limit_spin = QSpinBox()
        self.token_limit_spin.setRange(100, 10000)
        self.token_limit_spin.setValue(1000)
        settings_layout.addRow('Token-Limit:', self.token_limit_spin)
        settings_group.setLayout(settings_layout)
    
        v_layout.addLayout(h_layout)
        v_layout.addLayout(h_layout2)
        v_layout.addWidget(description_label)
        v_layout.addWidget(self.description_text)
        v_layout.addWidget(self.upload_btn)
        v_layout.addWidget(QLabel('Hochgeladene Dateien:'))
        v_layout.addWidget(self.file_list)
        v_layout.addWidget(settings_group)
    
        config_widget.setLayout(v_layout)
    
        # Verbindungen
        self.start_server_btn.clicked.connect(self.start_server)
        self.stop_server_btn.clicked.connect(self.stop_server)
        self.upload_btn.clicked.connect(self.upload_files)
    
        return config_widget
    
    def create_plan_tab(self):
        plan_widget = QWidget()
        v_layout = QVBoxLayout()
    
        # Analyse-Button
        self.analyse_btn = QPushButton('Analyse starten')
    
        # Plan anzeigen
        self.plan_tree = QTreeWidget()
        self.plan_tree.setHeaderLabels(['Teilaufgabe', 'Details'])
    
        v_layout.addWidget(self.analyse_btn)
        v_layout.addWidget(self.plan_tree)
    
        plan_widget.setLayout(v_layout)
    
        # Verbindung
        self.analyse_btn.clicked.connect(self.start_analysis)
    
        return plan_widget
    
    def create_chat_tab(self):
        chat_widget = QWidget()
        chat_layout = QVBoxLayout()
    
        # Chat-Bereich
        self.chat_area = QTextBrowser()
    
        # Verlaufsbereich
        self.history_area = QTextEdit()
        self.history_area.setReadOnly(True)
    
        # Fortschrittsanzeige
        self.progress_bar = QProgressBar()
        self.progress_bar.setValue(0)
    
        chat_layout.addWidget(QLabel('Chat-Bereich:'))
        chat_layout.addWidget(self.chat_area)
        chat_layout.addWidget(QLabel('Verlauf:'))
        chat_layout.addWidget(self.history_area)
        chat_layout.addWidget(self.progress_bar)
    
        chat_widget.setLayout(chat_layout)
    
        return chat_widget
    
    def apply_styles(self):
        try:
            with open("style.qss", "r") as f:
                self.setStyleSheet(f.read())
        except Exception as e:
            logging.error(f"Fehler beim Laden des Stylesheets: {e}")
    
    def update_llm_list(self):
        models = self.llm_client.get_models()
        self.llm_combo.clear()
        self.llm_combo.addItems(models)
    
    def start_server(self):
        # Implementierung wie zuvor
        pass
    
    def stop_server(self):
        # Implementierung wie zuvor
        pass
    
    def check_server_status(self):
        # Implementierung wie zuvor
        pass
    
    def upload_files(self):
        options = QFileDialog.Options()
        files, _ = QFileDialog.getOpenFileNames(
            self, "Dateien auswählen", "", 
            "Alle Dateien (*)", options=options
        )
        if files:
            self.uploaded_files.extend(files)
            self.display_uploaded_files()
    
    def display_uploaded_files(self):
        self.file_list.clear()
        for file in self.uploaded_files:
            self.file_list.addItem(file)
    
    def start_analysis(self):
        self.chat_area.append("<b>Assistent:</b> Starte die Analyse der Anwendungsbeschreibung...")
        threading.Thread(target=self.perform_analysis).start()
    
    def perform_analysis(self):
        description = self.description_text.toPlainText()
        selected_llm = self.llm_combo.currentText()
        file_contents = self.get_file_contents()
        prompt = self.generate_plan_prompt(description, file_contents)
        plan_text = self.llm_client.generate(selected_llm, prompt)
        self.plan_data = self.parse_plan(plan_text)
        if self.plan_data:
            self.display_plan(self.plan_data)
            self.chat_area.append("<b>Assistent:</b> Analyse abgeschlossen. Der Plan wurde erstellt.")
        else:
            self.chat_area.append("<b>Assistent:</b> Fehler bei der Analyse.")
    
    def get_file_contents(self):
        content = ""
        for file_path in self.uploaded_files:
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    content += f"\nInhalt von {file_path}:\n{f.read()}"
            except Exception as e:
                logging.error(f"Fehler beim Lesen der Datei {file_path}: {e}")
        return content
    
    def generate_plan_prompt(self, description, file_contents):
        return f"""
        Als erfahrener Softwarearchitekt sollst du basierend auf der folgenden Anwendungsbeschreibung einen detaillierten Entwicklungsplan erstellen.
    
        **Anwendungsbeschreibung:**
        {description}
    
        **Zusätzliche Dateien:**
        {file_contents}
    
        **Anforderungen an den Plan:**
        - Strukturierte JSON-Ausgabe.
        - Enthält Teilaufgaben mit Titel, Beschreibung und Zielen.
        - Verwende klare und präzise Sprache.
        """
    
    def parse_plan(self, plan_text):
        try:
            plan = json.loads(plan_text)
            return plan
        except json.JSONDecodeError as e:
            logging.error(f"Fehler beim Parsen des Plans: {e}")
            return []
    
    def display_plan(self, plan):
        self.plan_tree.clear()
        for task in plan:
            task_item = QTreeWidgetItem([task['Titel']])
            description_item = QTreeWidgetItem(['Beschreibung', task['Beschreibung']])
            task_item.addChild(description_item)
    
            goals_item = QTreeWidgetItem(['Ziele'])
            for goal in task['Ziele']:
                goal_item = QTreeWidgetItem([goal])
                goals_item.addChild(goal_item)
            task_item.addChild(goals_item)
    
            self.plan_tree.addTopLevelItem(task_item)
    
    def start_processing(self):
        self.chat_area.append("<b>Assistent:</b> Beginne mit der Bearbeitung der Teilaufgaben.")
        self.task_processor = TaskProcessor(
            tasks=self.plan_data,
            llm_client=self.llm_client,
            llm_model=self.llm_combo.currentText()
        )
        self.task_processor.progress_updated.connect(self.update_progress)
        self.task_processor.task_message.connect(self.append_chat_message)
        self.task_processor.task_result.connect(self.append_chat_message)
        self.task_processor.start()
    
    def append_chat_message(self, message):
        self.chat_area.append(f"<b>{message}</b>")
        self.history_area.append(message)
    
    def update_progress(self, value):
        self.progress_bar.setValue(value)
        self.status_bar.showMessage(f'Fortschritt: {value}%')
    
    def pause_processing(self):
        if hasattr(self, 'task_processor'):
            self.task_processor.pause()
            self.chat_area.append("<b>System:</b> Der Prozess wurde pausiert.")
    
    def resume_processing(self):
        if hasattr(self, 'task_processor'):
            self.task_processor.resume()
            self.chat_area.append("<b>System:</b> Der Prozess wird fortgesetzt.")
    
    def stop_processing(self):
        if hasattr(self, 'task_processor'):
            self.task_processor.stop()
            self.chat_area.append("<b>System:</b> Der Prozess wurde gestoppt.")
    
    def save_project(self):
        # Implementierung wie oben beschrieben
        pass
    
    def load_project(self):
        # Implementierung wie oben beschrieben
        pass
    
    def open_settings_dialog(self):
        # Öffnen des Einstellungsdialogs
        pass
    
    def show_about_dialog(self):
        QMessageBox.about(self, "Über", "Intelligenter Assistent für Entwickler\nVersion 2.0")
    

    if name == 'main': app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(app.exec_())"

  2. Assistant

    Natürlich! Hier ist das vollständige und verbesserte Skript für die Anwendung. Ich habe den Code entsprechend Ihren Vorgaben überarbeitet, die wichtigsten Bereiche verbessert und das GUI optimiert, um alle Informationen und Funktionen übersichtlich darzustellen.

    import sys
    import subprocess
    import threading
    import time
    import requests
    import json
    import logging
    from datetime import datetime
    
    from PyQt5.QtWidgets import (
        QApplication, QMainWindow, QLabel, QPushButton, QComboBox, QAction,
        QHBoxLayout, QVBoxLayout, QWidget, QTextEdit, QFileDialog,
        QTreeWidget, QTreeWidgetItem, QTextBrowser, QProgressBar, QTabWidget,
        QListWidget, QStatusBar, QMenuBar, QToolBar, QDialog, QGroupBox, QFormLayout,
        QSpinBox, QPlainTextEdit, QMessageBox
    )
    from PyQt5.QtCore import QTimer, Qt, QThread, pyqtSignal
    
    # Konfiguration des Loggings
    logging.basicConfig(level=logging.INFO, filename='app.log', filemode='w',
                        format='%(asctime)s - %(levelname)s - %(message)s')
    
    class LLMClient:
        def __init__(self, base_url='http://localhost:11434'):
            self.base_url = base_url
            self.cache = {}
    
        def get_models(self):
            try:
                response = requests.get(f'{self.base_url}/models')
                response.raise_for_status()
                models = response.json()
                model_names = [model['name'] for model in models]
                return model_names
            except requests.RequestException as e:
                logging.error(f"Fehler beim Abrufen der Modelle: {e}")
                return []
    
        def generate(self, model, prompt):
            cache_key = (model, prompt)
            if cache_key in self.cache:
                return self.cache[cache_key]
            payload = {
                "model": model,
                "prompt": prompt
            }
            try:
                response = requests.post(f'{self.base_url}/generate', json=payload)
                response.raise_for_status()
                result = response.json().get('response', '')
                self.cache[cache_key] = result
                return result
            except requests.RequestException as e:
                logging.error(f"Fehler bei der Kommunikation mit dem LLM: {e}")
                return f"Fehler bei der Kommunikation mit dem LLM: {e}"
    
    class TaskProcessor(QThread):
        progress_updated = pyqtSignal(int)
        task_message = pyqtSignal(str)
        task_result = pyqtSignal(str)
    
        def __init__(self, tasks, llm_client, llm_model, parent=None):
            super().__init__(parent)
            self.tasks = tasks
            self.llm_client = llm_client
            self.llm_model = llm_model
            self._paused = False
            self._stopped = False
    
        def run(self):
            total_tasks = len(self.tasks)
            for i, task in enumerate(self.tasks):
                if self._stopped:
                    break
                while self._paused:
                    time.sleep(0.1)
                self.task_message.emit(f"Assistent: Bearbeite {task['Titel']}")
                result = self.process_task(task)
                self.task_result.emit(f"Ergebnis für {task['Titel']}:\n{result}")
                progress = int(((i + 1) / total_tasks) * 100)
                self.progress_updated.emit(progress)
            else:
                if not self._stopped:
                    self.task_message.emit("Assistent: Alle Teilaufgaben wurden abgeschlossen.")
    
        def process_task(self, task):
            prompt = f"""
    Bearbeite die folgende Teilaufgabe:
    
    **Titel:**
    {task['Titel']}
    
    **Beschreibung:**
    {task['Beschreibung']}
    
    **Ziele:**
    {', '.join(task['Ziele'])}
    
    Liefere ausführlichen Code oder eine detaillierte Beschreibung, die das Ziel erfüllt.
    """
            result = self.llm_client.generate(self.llm_model, prompt)
            return result
    
        def pause(self):
            self._paused = True
    
        def resume(self):
            self._paused = False
    
        def stop(self):
            self._stopped = True
    
    class MainWindow(QMainWindow):
        def __init__(self):
            super().__init__()
            self.setWindowTitle('Intelligenter Assistent für Entwickler')
            self.setGeometry(100, 100, 1200, 800)
            self.llm_client = LLMClient()
            self.paused = False
            self.stopped = False
            self.plan_data = []
            self.uploaded_files = []
            self.init_ui()
            self.update_llm_list()
            self.apply_styles()
    
        def init_ui(self):
            self.create_menu()
            self.create_toolbar()
            self.status_bar = self.statusBar()
            self.status_bar.showMessage('Bereit')
    
            self.tabs = QTabWidget()
            self.tabs.addTab(self.create_configuration_tab(), "Konfiguration")
            self.tabs.addTab(self.create_plan_tab(), "Planung")
            self.tabs.addTab(self.create_chat_tab(), "Assistent")
            self.setCentralWidget(self.tabs)
    
            # Timer zum Überprüfen des Serverstatus
            self.timer = QTimer()
            self.timer.timeout.connect(self.check_server_status)
            self.timer.start(5000)  # Alle 5 Sekunden
    
        def create_menu(self):
            menu_bar = self.menuBar()
    
            # Datei-Menü
            file_menu = menu_bar.addMenu('Datei')
            save_action = QAction('Speichern', self)
            save_action.triggered.connect(self.save_project)
            file_menu.addAction(save_action)
            load_action = QAction('Laden', self)
            load_action.triggered.connect(self.load_project)
            file_menu.addAction(load_action)
            settings_action = QAction('Einstellungen', self)
            settings_action.triggered.connect(self.open_settings_dialog)
            file_menu.addAction(settings_action)
            exit_action = QAction('Beenden', self)
            exit_action.triggered.connect(self.close)
            file_menu.addAction(exit_action)
    
            # Hilfe-Menü
            help_menu = menu_bar.addMenu('Hilfe')
            about_action = QAction('Über', self)
            about_action.triggered.connect(self.show_about_dialog)
            help_menu.addAction(about_action)
    
        def create_toolbar(self):
            tool_bar = self.addToolBar('Werkzeuge')
            start_action = QAction('Start', self)
            start_action.triggered.connect(self.start_processing)
            tool_bar.addAction(start_action)
            pause_action = QAction('Pause', self)
            pause_action.triggered.connect(self.pause_processing)
            tool_bar.addAction(pause_action)
            resume_action = QAction('Weiter', self)
            resume_action.triggered.connect(self.resume_processing)
            tool_bar.addAction(resume_action)
            stop_action = QAction('Stop', self)
            stop_action.triggered.connect(self.stop_processing)
            tool_bar.addAction(stop_action)
    
        def create_configuration_tab(self):
            config_widget = QWidget()
            v_layout = QVBoxLayout()
    
            llm_label = QLabel('Wählen Sie ein LLM:')
            self.llm_combo = QComboBox()
    
            self.server_status_label = QLabel('Serverstatus: Gestoppt')
            self.server_status_indicator = QLabel('🔴')
    
            self.start_server_btn = QPushButton('Server starten')
            self.stop_server_btn = QPushButton('Server stoppen')
    
            h_layout = QHBoxLayout()
            h_layout.addWidget(llm_label)
            h_layout.addWidget(self.llm_combo)
    
            h_layout2 = QHBoxLayout()
            h_layout2.addWidget(self.server_status_label)
            h_layout2.addWidget(self.server_status_indicator)
            h_layout2.addWidget(self.start_server_btn)
            h_layout2.addWidget(self.stop_server_btn)
    
            # Anwendungsbeschreibung
            description_label = QLabel('Anwendungsbeschreibung:')
            self.description_text = QTextEdit()
    
            # Datei-Upload
            self.upload_btn = QPushButton('Dateien hochladen')
            self.file_list = QListWidget()
    
            # Einstellungen
            settings_group = QGroupBox('Einstellungen')
            settings_layout = QFormLayout()
            self.token_limit_spin = QSpinBox()
            self.token_limit_spin.setRange(100, 10000)
            self.token_limit_spin.setValue(1000)
            settings_layout.addRow('Token-Limit:', self.token_limit_spin)
            settings_group.setLayout(settings_layout)
    
            v_layout.addLayout(h_layout)
            v_layout.addLayout(h_layout2)
            v_layout.addWidget(description_label)
            v_layout.addWidget(self.description_text)
            v_layout.addWidget(self.upload_btn)
            v_layout.addWidget(QLabel('Hochgeladene Dateien:'))
            v_layout.addWidget(self.file_list)
            v_layout.addWidget(settings_group)
    
            config_widget.setLayout(v_layout)
    
            # Verbindungen
            self.start_server_btn.clicked.connect(self.start_server)
            self.stop_server_btn.clicked.connect(self.stop_server)
            self.upload_btn.clicked.connect(self.upload_files)
    
            return config_widget
    
        def create_plan_tab(self):
            plan_widget = QWidget()
            v_layout = QVBoxLayout()
    
            # Analyse-Button
            self.analyse_btn = QPushButton('Analyse starten')
    
            # Plan anzeigen
            self.plan_tree = QTreeWidget()
            self.plan_tree.setHeaderLabels(['Teilaufgabe', 'Details'])
    
            v_layout.addWidget(self.analyse_btn)
            v_layout.addWidget(self.plan_tree)
    
            plan_widget.setLayout(v_layout)
    
            # Verbindung
            self.analyse_btn.clicked.connect(self.start_analysis)
    
            return plan_widget
    
        def create_chat_tab(self):
            chat_widget = QWidget()
            chat_layout = QVBoxLayout()
    
            # Chat-Bereich
            self.chat_area = QTextBrowser()
    
            # Verlaufsbereich
            self.history_area = QTextEdit()
            self.history_area.setReadOnly(True)
    
            # Fortschrittsanzeige
            self.progress_bar = QProgressBar()
            self.progress_bar.setValue(0)
    
            chat_layout.addWidget(QLabel('Chat-Bereich:'))
            chat_layout.addWidget(self.chat_area)
            chat_layout.addWidget(QLabel('Verlauf:'))
            chat_layout.addWidget(self.history_area)
            chat_layout.addWidget(self.progress_bar)
    
            chat_widget.setLayout(chat_layout)
    
            return chat_widget
    
        def apply_styles(self):
            # Hier können Sie ein Stylesheet laden, um das Aussehen der Anwendung anzupassen
            pass  # Für jetzt leeren lassen oder eigenes Stylesheet laden
    
        def update_llm_list(self):
            models = self.llm_client.get_models()
            self.llm_combo.clear()
            self.llm_combo.addItems(models)
    
        def start_server(self):
            try:
                # Prüfen, ob der Server bereits läuft
                response = requests.get('http://localhost:11434/models')
                if response.status_code == 200:
                    self.server_status_label.setText('Serverstatus: Laufend')
                    self.server_status_indicator.setText('🟢')
                    return
            except:
                pass  # Server läuft nicht
    
            try:
                # Starten des Ollama-Servers
                self.ollama_process = subprocess.Popen(['ollama', 'serve'])
                # Warten, bis der Server verfügbar ist
                time.sleep(2)
                self.server_status_label.setText('Serverstatus: Laufend')
                self.server_status_indicator.setText('🟢')
                self.update_llm_list()
            except Exception as e:
                logging.error(f"Fehler beim Starten des Servers: {e}")
                self.server_status_label.setText('Serverstatus: Fehler')
                self.server_status_indicator.setText('⚠️')
    
        def stop_server(self):
            try:
                # Beenden des Ollama-Servers
                self.ollama_process.terminate()
                self.ollama_process.wait()
                self.server_status_label.setText('Serverstatus: Gestoppt')
                self.server_status_indicator.setText('🔴')
            except Exception as e:
                logging.error(f"Fehler beim Stoppen des Servers: {e}")
                self.server_status_label.setText('Serverstatus: Fehler')
                self.server_status_indicator.setText('⚠️')
    
        def check_server_status(self):
            try:
                response = requests.get('http://localhost:11434/models')
                if response.status_code == 200:
                    self.server_status_label.setText('Serverstatus: Laufend')
                    self.server_status_indicator.setText('🟢')
                else:
                    self.server_status_label.setText('Serverstatus: Fehler')
                    self.server_status_indicator.setText('⚠️')
            except:
                self.server_status_label.setText('Serverstatus: Gestoppt')
                self.server_status_indicator.setText('🔴')
    
        def upload_files(self):
            options = QFileDialog.Options()
            files, _ = QFileDialog.getOpenFileNames(
                self, "Dateien auswählen", "",
                "Alle Dateien (*)", options=options
            )
            if files:
                self.uploaded_files.extend(files)
                self.display_uploaded_files()
    
        def display_uploaded_files(self):
            self.file_list.clear()
            for file in self.uploaded_files:
                self.file_list.addItem(file)
    
        def start_analysis(self):
            self.chat_area.append("<b>Assistent:</b> Starte die Analyse der Anwendungsbeschreibung...")
            threading.Thread(target=self.perform_analysis).start()
    
        def perform_analysis(self):
            description = self.description_text.toPlainText()
            selected_llm = self.llm_combo.currentText()
            file_contents = self.get_file_contents()
            prompt = self.generate_plan_prompt(description, file_contents)
            plan_text = self.llm_client.generate(selected_llm, prompt)
            self.plan_data = self.parse_plan(plan_text)
            if self.plan_data:
                self.display_plan(self.plan_data)
                self.chat_area.append("<b>Assistent:</b> Analyse abgeschlossen. Der Plan wurde erstellt.")
            else:
                self.chat_area.append("<b>Assistent:</b> Fehler bei der Analyse.")
    
        def get_file_contents(self):
            content = ""
            for file_path in self.uploaded_files:
                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        content += f"\nInhalt von {file_path}:\n{f.read()}"
                except Exception as e:
                    logging.error(f"Fehler beim Lesen der Datei {file_path}: {e}")
            return content
    
        def generate_plan_prompt(self, description, file_contents):
            return f"""
    Als erfahrener Softwarearchitekt sollst du basierend auf der folgenden Anwendungsbeschreibung einen detaillierten Entwicklungsplan erstellen.
    
    **Anwendungsbeschreibung:**
    {description}
    
    **Zusätzliche Dateien:**
    {file_contents}
    
    **Anforderungen an den Plan:**
    - Strukturierte JSON-Ausgabe.
    - Enthält Teilaufgaben mit Titel, Beschreibung und Zielen.
    - Verwende klare und präzise Sprache.
    
    **Beispielausgabe:**
    [
        {{
            "Titel": "Teilaufgabe 1: XYZ",
            "Beschreibung": "Beschreibung der Teilaufgabe.",
            "Ziele": ["Ziel 1", "Ziel 2"]
        }},
        ...
    ]
    """
    
        def parse_plan(self, plan_text):
            try:
                plan = json.loads(plan_text)
                return plan
            except json.JSONDecodeError as e:
                logging.error(f"Fehler beim Parsen des Plans: {e}")
                return []
    
        def display_plan(self, plan):
            self.plan_tree.clear()
            for task in plan:
                task_item = QTreeWidgetItem([task['Titel']])
                description_item = QTreeWidgetItem(['Beschreibung', task['Beschreibung']])
                task_item.addChild(description_item)
    
                goals_item = QTreeWidgetItem(['Ziele'])
                for goal in task['Ziele']:
                    goal_item = QTreeWidgetItem([goal])
                    goals_item.addChild(goal_item)
                task_item.addChild(goals_item)
    
                self.plan_tree.addTopLevelItem(task_item)
    
        def start_processing(self):
            if not self.plan_data:
                QMessageBox.warning(self, "Warnung", "Bitte erstellen Sie zuerst einen Plan.")
                return
            self.chat_area.append("<b>Assistent:</b> Beginne mit der Bearbeitung der Teilaufgaben.")
            self.task_processor = TaskProcessor(
                tasks=self.plan_data,
                llm_client=self.llm_client,
                llm_model=self.llm_combo.currentText()
            )
            self.task_processor.progress_updated.connect(self.update_progress)
            self.task_processor.task_message.connect(self.append_chat_message)
            self.task_processor.task_result.connect(self.append_chat_message)
            self.task_processor.start()
    
        def append_chat_message(self, message):
            self.chat_area.append(f"<b>{message}</b>")
            self.history_area.append(f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')} - {message}")
    
        def update_progress(self, value):
            self.progress_bar.setValue(value)
            self.status_bar.showMessage(f'Fortschritt: {value}%')
    
        def pause_processing(self):
            if hasattr(self, 'task_processor'):
                self.task_processor.pause()
                self.chat_area.append("<b>System:</b> Der Prozess wurde pausiert.")
    
        def resume_processing(self):
            if hasattr(self, 'task_processor'):
                self.task_processor.resume()
                self.chat_area.append("<b>System:</b> Der Prozess wird fortgesetzt.")
    
        def stop_processing(self):
            if hasattr(self, 'task_processor'):
                self.task_processor.stop()
                self.chat_area.append("<b>System:</b> Der Prozess wurde gestoppt.")
                self.progress_bar.setValue(0)
    
        def save_project(self):
            options = QFileDialog.Options()
            file_name, _ = QFileDialog.getSaveFileName(self, "Projekt speichern", "", "JSON Dateien (*.json)", options=options)
            if file_name:
                project_data = {
                    'description': self.description_text.toPlainText(),
                    'uploaded_files': self.uploaded_files,
                    'plan_data': self.plan_data
                }
                try:
                    with open(file_name, 'w', encoding='utf-8') as f:
                        json.dump(project_data, f, ensure_ascii=False, indent=4)
                    QMessageBox.information(self, "Erfolg", "Projekt erfolgreich gespeichert.")
                except Exception as e:
                    logging.error(f"Fehler beim Speichern des Projekts: {e}")
                    QMessageBox.critical(self, "Fehler", "Fehler beim Speichern des Projekts.")
    
        def load_project(self):
            options = QFileDialog.Options()
            file_name, _ = QFileDialog.getOpenFileName(self, "Projekt laden", "", "JSON Dateien (*.json)", options=options)
            if file_name:
                try:
                    with open(file_name, 'r', encoding='utf-8') as f:
                        project_data = json.load(f)
                    self.description_text.setPlainText(project_data.get('description', ''))
                    self.uploaded_files = project_data.get('uploaded_files', [])
                    self.display_uploaded_files()
                    self.plan_data = project_data.get('plan_data', [])
                    if self.plan_data:
                        self.display_plan(self.plan_data)
                    QMessageBox.information(self, "Erfolg", "Projekt erfolgreich geladen.")
                except Exception as e:
                    logging.error(f"Fehler beim Laden des Projekts: {e}")
                    QMessageBox.critical(self, "Fehler", "Fehler beim Laden des Projekts.")
    
        def open_settings_dialog(self):
            # Öffnen des Einstellungsdialogs
            settings_dialog = QDialog(self)
            settings_dialog.setWindowTitle('Einstellungen')
            layout = QFormLayout()
            # Hier können Sie zusätzliche Einstellungen hinzufügen
            layout.addRow('Token-Limit:', self.token_limit_spin)
            settings_dialog.setLayout(layout)
            settings_dialog.exec_()
    
        def show_about_dialog(self):
            QMessageBox.about(self, "Über", "Intelligenter Assistent für Entwickler\nVersion 2.0")
    
    if __name__ == '__main__':
        app = QApplication(sys.argv)
        window = MainWindow()
        window.show()
        sys.exit(app.exec_())
    

    Erläuterungen zum verbesserten Code

    1. Modularisierung des Codes

    • LLMClient-Klasse: Diese Klasse kapselt die gesamte Interaktion mit dem LLM, einschließlich Modellabfrage und Textgenerierung. Dies erleichtert die Wartung und Anpassung der LLM-Kommunikation.

    2. Verwendung von QThread für asynchrone Aufgaben

    • TaskProcessor-Klasse: Diese Klasse ermöglicht die asynchrone Bearbeitung der Aufgaben, ohne die GUI zu blockieren. Signale werden verwendet, um die GUI über Fortschritte und Ergebnisse zu informieren.

    3. Verbesserte Fehler- und Ausnahmebehandlung

    • Logging: Über das logging-Modul werden Fehler protokolliert, was die Fehlerdiagnose erleichtert.
    • Fehlerbehandlung: Bei potenziellen Fehlern werden Ausnahmen abgefangen und der Benutzer wird über Dialoge informiert.

    4. Verbesserte GUI-Struktur

    • Tabs: Die Anwendung verwendet jetzt Tabs, um die Bereiche Konfiguration, Planung und Assistent zu trennen, was die Übersichtlichkeit erhöht.
    • Menüleiste und Werkzeugleiste: Diese bieten schnellen Zugriff auf wichtige Funktionen und Einstellungen.
    • Fortschrittsanzeige und Statusleiste: Bieten dem Benutzer Feedback über den aktuellen Stand der Aufgabenbearbeitung.

    5. Verbesserte Nutzererfahrung

    • Stylesheet: Platzhalter für ein Stylesheet hinzugefügt, um das Aussehen der Anwendung anzupassen.
    • Zeitstempel im Verlauf: Jeder Eintrag im Verlaufsbereich enthält nun einen Zeitstempel.

    Hinweise zur Verwendung

    • Ollama installieren: Stellen Sie sicher, dass Ollama korrekt installiert ist und mindestens ein Modell verfügbar ist.
    • Anwendung starten:
      python main.py
      
    • LLM auswählen: Wählen Sie im Dropdown-Menü das gewünschte LLM aus.
    • Server starten: Klicken Sie auf "Server starten", um den Ollama-Server zu starten.
    • Anwendungsbeschreibung eingeben: Geben Sie im entsprechenden Feld die Beschreibung Ihrer Anwendung ein.
    • Dateien hochladen: Fügen Sie relevante Dateien hinzu, um den Kontext für das LLM zu erweitern.
    • Analyse starten: Wechseln Sie zum Tab "Planung" und klicken Sie auf "Analyse starten".
    • Plan überprüfen: Der generierte Plan wird angezeigt und kann eingesehen werden.
    • Bearbeitung starten: Wechseln Sie zum Tab "Assistent" oder verwenden Sie die Werkzeugleiste, um die Bearbeitung zu starten.
    • Fortschritt verfolgen: Beobachten Sie den Fortschritt über die Fortschrittsleiste und den Chat-Bereich.
    • Prozess steuern: Verwenden Sie die Werkzeugleiste oder die entsprechenden Schaltflächen, um den Prozess zu pausieren, fortzusetzen oder zu stoppen.
    • Projekt speichern/laden: Über das Menü "Datei" können Projekte gespeichert und geladen werden.

    Abschließende Bemerkungen

    Die Anwendung bietet nun eine verbesserte Benutzererfahrung und qualitativ hochwertige Ergebnisse durch optimierten Code und ein übersichtliches GUI. Sie können den Code weiter anpassen oder erweitern, um spezifischen Anforderungen gerecht zu werden.

    Ich hoffe, die bereitgestellte Anwendung erfüllt Ihre Erwartungen und unterstützt Sie effektiv bei Ihrer Arbeit als Entwickler!

Erstelle das vollständige skript für die anwendung, nutze… · The Chat Archive