Skip to content
The Chat Archive
gemini-2.5-pro· Google LMArena Human Preference 140K

Hey, ich schreibe gerade an einem Python-Tool mit CustomTkinter und bräuchte etwas…

  1. User

    Hey, ich schreibe gerade an einem Python-Tool mit CustomTkinter und bräuchte etwas Hilfe. Das Tool soll ein OCR-basierter Scanner werden, der schnell sequentiell Items aus einem Spiel scannt und danach in das gewünschte JSON-Format exportiert. Ich habe den Code im MVC-Pattern geschrieben und arbeite gerade am "Scanner-Controller". Dieser soll nach dem Drücken des Start-Buttons alles vorbereiten und den Scan-Prozess beginnen. Jetzt frage ich mich, wie ich den Scan-Prozess starten soll, da ein gewöhnlicher Funktionsaufruf das Programm blockiert.

  2. Assistant

    Hallo! Super, dass du dein Tool mit dem MVC-Pattern strukturierst. Das ist ein sehr guter Ansatz für sauberen und wartbaren Code.

    Deine Frage ist ein klassisches Problem in der GUI-Programmierung. Ein direkter Funktionsaufruf für einen langen Prozess wie OCR würde den Main-Thread von Tkinter blockieren, der für das Zeichnen der Benutzeroberfläche und die Reaktion auf Benutzereingaben zuständig ist. Das Ergebnis: Das Fenster friert ein und zeigt "Keine Rückmeldung".

    Die Lösung besteht darin, den langlaufenden Scan-Prozess in einem separaten Thread auszuführen.

    Hier ist der empfohlene Ansatz, integriert in deine MVC-Struktur:

    Das Konzept: Threading im Controller

    1. View (Benutzeroberfläche): Der Benutzer klickt auf den "Start"-Button. Der Button-Klick ruft eine Methode im Controller auf (z. B. start_scan_button_pressed).
    2. Controller (Steuerung):
      • Diese Methode (start_scan_button_pressed) führt sofort einige vorbereitende UI-Änderungen durch (z. B. den "Start"-Button deaktivieren, eine Statusmeldung wie "Scanne..." anzeigen). Diese Aktionen sind kurz und blockieren die GUI nicht.
      • Anschließend erstellt und startet der Controller einen neuen Worker-Thread. Die eigentliche, langlaufende Scan-Logik (_run_scan_process) wird diesem Thread als Ziel (target) übergeben.
      • Da der Thread nun im Hintergrund läuft, kehrt die start_scan_button_pressed-Methode sofort zurück und der GUI-Thread ist wieder frei, um auf weitere Eingaben zu reagieren.
    3. Worker-Thread (im Controller):
      • Dieser Thread führt die Scan-Schleife aus: Screenshot machen, OCR anwenden, Daten verarbeiten.
      • Nachdem ein Item gescannt wurde, müssen die Ergebnisse (z. B. der erkannte Text oder der Fortschritt) in der GUI angezeigt werden. Wichtig: Du darfst GUI-Elemente (Widgets) niemals direkt aus einem anderen Thread als dem Main-Thread heraus verändern. Tkinter ist nicht "thread-safe".
      • Die Lösung hierfür ist die after()-Methode von Tkinter. Der Worker-Thread übergibt die Aktualisierungsaufgabe über view.after(0, ...) an den Main-Thread. Der Main-Thread führt diese Aufgabe dann sicher aus, sobald er dazu Zeit hat.
    4. Model (Datenhaltung): Der Worker-Thread kann die gescannten Daten direkt dem Model hinzufügen, wenn dein Model thread-sicher gestaltet ist (z. B. durch Locks) oder wenn die Daten nur am Ende des gesamten Prozesses auf einmal hinzugefügt werden.

    Konkretes Code-Beispiel

    Stellen wir uns eine vereinfachte Struktur vor:

    • model.py: Hält die Liste der gescannten Items.
    • view.py: Baut das CustomTkinter-Fenster mit Buttons und einem Statuslabel.
    • controller.py: Enthält die Logik.

    controller.py

    import threading
    import time  # Zur Simulation des OCR-Prozesses
    
    class ScannerController:
        def __init__(self, model, view):
            self.model = model
            self.view = view
            self.is_scanning = False
            self.scan_thread = None
    
        def start_scan_button_pressed(self):
            """
            Wird vom Start-Button in der View aufgerufen.
            Bereitet alles vor und startet den Scan-Prozess in einem neuen Thread.
            """
            if self.is_scanning:
                return  # Verhindert mehrere Scan-Prozesse gleichzeitig
    
            self.is_scanning = True
            self.view.start_button.configure(state="disabled", text="Scanne...")
            self.view.stop_button.configure(state="normal")
            
            # Erstelle und starte den Worker-Thread
            self.scan_thread = threading.Thread(target=self._run_scan_process, daemon=True)
            self.scan_thread.start()
    
        def stop_scan_button_pressed(self):
            """
    
            Wird vom Stop-Button aufgerufen. Setzt ein Flag, um den Thread zu beenden.
            """
            if self.is_scanning:
                self.is_scanning = False # Das Flag wird vom Thread geprüft
                # UI wird im Thread nach Beendigung der Schleife aktualisiert
    
        def _run_scan_process(self):
            """
            Diese Funktion läuft im Hintergrund-Thread.
            Sie enthält die eigentliche Scan-Schleife.
            """
            print("Scan-Prozess gestartet.")
            item_count = 0
            
            # Die Schleife läuft, solange das Flag gesetzt ist
            while self.is_scanning:
                # --- Hier ist deine eigentliche Scan-Logik ---
                # 1. Screenshot/Bildaufnahme
                # 2. OCR auf dem Bild
                # 3. Daten extrahieren
                # -----------------------------------------------
    
                # Simuliere einen Scan-Vorgang
                time.sleep(1.5) 
                item_count += 1
                scanned_item_name = f"Item #{item_count}"
    
                # Füge die Daten dem Model hinzu
                self.model.add_item({"name": scanned_item_name, "value": item_count * 10})
    
                # Sende eine UI-Update-Anfrage an den Main-Thread
                # WICHTIG: Widgets dürfen nur vom Main-Thread aktualisiert werden!
                # view.after() stellt sicher, dass die Funktion im Main-Thread ausgeführt wird.
                self.view.after(0, self._update_ui_progress, f"Gescanned: {item_count} Items")
            
            # Nach Beendigung der Schleife (durch Klick auf Stop oder andere Bedingung)
            print("Scan-Prozess beendet.")
            self.view.after(0, self._finalize_scan_ui)
    
        def _update_ui_progress(self, message):
            """
            Diese Methode wird SICHER vom Main-Thread über `view.after()` aufgerufen.
            Sie aktualisiert das Status-Label.
            """
            self.view.status_label.configure(text=message)
    
        def _finalize_scan_ui(self):
            """
            Setzt die UI nach dem Scan wieder in den Ursprungszustand.
            Wird auch sicher über `view.after()` aufgerufen.
            """
            self.view.start_button.configure(state="normal", text="Start Scan")
            self.view.stop_button.configure(state="disabled")
            self.view.status_label.configure(text="Scan beendet. Bereit.")
            # Optional: Exportiere die Daten jetzt
            self.model.export_to_json("scanned_items.json")
    
    

    Wichtige Punkte im Code erklärt:

    1. threading.Thread(target=self._run_scan_process, daemon=True):

      • target: Die Funktion, die im neuen Thread ausgeführt werden soll.
      • daemon=True: Das ist sehr wichtig! Ein Daemon-Thread wird automatisch beendet, wenn das Hauptprogramm (deine GUI) geschlossen wird. Andernfalls könnte der Thread im Hintergrund weiterlaufen und das Programm am sauberen Beenden hindern.
    2. self.is_scanning Flag:

      • Dies ist eine einfache und effektive Methode, um den Thread von außen (über den "Stop"-Button) sauber zu beenden. Die while-Schleife im Thread prüft bei jeder Iteration, ob das Flag noch True ist.
    3. self.view.after(0, self._update_ui_progress, ...):

      • Dies ist der entscheidende Teil für die thread-sichere Kommunikation mit der GUI.
      • self.view ist eine Instanz deines CustomTkinter-Fensters oder Frames.
      • after(milliseconds, function, *args) plant die Ausführung einer Funktion (function) nach einer bestimmten Zeit im Main-Thread.
      • Mit 0 Millisekunden wird die Funktion so schnell wie möglich ausgeführt, sobald der Main-Thread frei ist.
      • Alle Argumente nach der Funktion werden an diese übergeben (hier die Status-Nachricht).

    Zusammenfassend für deine Implementierung:

    1. Erstelle im Controller eine Methode, die vom "Start"-Button getriggert wird.
    2. In dieser Methode: Deaktiviere den Button, erstelle und starte einen threading.Thread.
    3. Packe deine while True: Scan-Schleife in eine separate "Worker"-Methode (_run_scan_process).
    4. Füge eine self.is_scanning-Variable hinzu, um die Schleife kontrolliert beenden zu können (essentiell für einen "Stop"-Button).
    5. Immer wenn du die GUI aus dem Worker-Thread aktualisieren willst (z.B. Fortschrittsanzeige), rufe self.view.after(0, deine_update_funktion, daten) auf.
    6. Nachdem die Schleife beendet ist, nutze ebenfalls self.view.after() um die GUI final zu aktualisieren (z.B. "Start"-Button wieder aktivieren).

    Dieser Ansatz hält deine Anwendung reaktionsfähig und sorgt für eine saubere Trennung zwischen der Benutzeroberfläche und der rechenintensiven Hintergrundaufgabe. Viel Erfolg bei deinem Projekt!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.