Erstelle das vollständige skript für die anwendung, nutze dafür den folgenden…
- 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.- 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 = TrueIm 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_widgetVorteile:
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) # ...
- 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 = Trueclass 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_())"
- 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!