From 937379935266b8792216b466e022674145114cb9 Mon Sep 17 00:00:00 2001 From: Floke Date: Thu, 19 Jun 2025 19:22:55 +0000 Subject: [PATCH] Refactor: Robuste Initialisierungs- und Konfigurationslogik in main() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Umstrukturierung der `main()`-Funktion für eine saubere und robuste Initialisierungsreihenfolge: 1. Argumente parsen, 2. Logging einrichten, 3. Konfigurationsdaten laden, 4. Klassen initialisieren, 5. Modus ausführen. - Fehlerbehebung `NameError`: Die Funktion `parse_arguments()` wurde außerhalb von `main()` platziert und greift für Default-Werte nun korrekt auf die zuvor definierte `Config`-Klasse zu. Alle Aufrufe im Skript sind auf die zentrale `Config`-Klasse umgestellt. - Fehlerbehebung `TypeError`: Die Funktionen `load_target_schema()` und `load_branch_mapping()` geben jetzt in Fehlerfällen leere, aber typkorrekte Tupel/Dictionaries zurück, um Abstürze beim Entpacken der Rückgabewerte zu verhindern. - Verbessertes Logging: Das Logging wird nun zweistufig initialisiert, um auch die interaktive Modus- und Limit-Auswahl korrekt zu protokollieren. - Code-Konsolidierung: Die gesamte Logik zur Modus- und Parameter-Verarbeitung wurde innerhalb der neuen `main()`-Struktur bereinigt und zentralisiert. --- brancheneinstufung.py | 797 ++++++++---------------------------------- 1 file changed, 154 insertions(+), 643 deletions(-) diff --git a/brancheneinstufung.py b/brancheneinstufung.py index c2d7769c8..5522e0c70 100644 --- a/brancheneinstufung.py +++ b/brancheneinstufung.py @@ -10314,680 +10314,191 @@ def parse_arguments(): def main(): + """ + Haupteinstiegspunkt des Skripts. + Verarbeitet Kommandozeilen-Argumente, richtet Logging ein, + initialisiert Komponenten und dispatchet zu den passenden Modi. + """ # 1. Argumente parsen args = parse_arguments() - # 2. Logging konfigurieren + # 2. Temporäres Logging für interaktive Auswahl einrichten global LOG_FILE log_level = logging.DEBUG if getattr(Config, 'DEBUG', False) else logging.INFO log_format = '%(asctime)s - %(levelname)-8s - %(name)-25s - %(message)s' - logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()]) + + temp_console_handler = logging.StreamHandler() + temp_console_handler.setFormatter(logging.Formatter(log_format)) + root_logger = logging.getLogger('') + root_logger.setLevel(log_level) + root_logger.addHandler(temp_console_handler) logger = logging.getLogger(__name__) - # 3. Globale Konfigurationsdaten laden + # 3. Modusauswahl (interaktiv, falls nicht per CLI gesetzt) + selected_mode = args.mode + if not selected_mode: + mode_categories = { + "Sequentielle Verarbeitung (Zeilenweise)": ["full_run"], + "Re-Evaluate Markierte Zeilen (Spalte A='x')": ["reeval"], + "Einzelne Dienstprogramme / Suchen": [ + "find_wiki_serp", "website_lookup", "check_urls", "contacts", "update_wiki_suggestions", + "wiki_reextract_missing_an", "website_details", "train_technician_model", "alignment", + "reparatur_sitz", "plausi_check_data", "branch_eval", "suggest_parents", "analyze_ml_by_branch" + ], + "Kombinierte Laeufe (Vordefiniert)": ["combined_all"] + } + valid_modes = [mode for modes in mode_categories.values() for mode in modes] + print("\nVerfügbare Betriebsmodi:") + mode_number = 1 + mode_map = {} + for category, modes in mode_categories.items(): + print(f"\n{category}:") + for mode in modes: + print(f" {mode_number}: {mode}") + mode_map[mode_number] = mode + mode_number += 1 + print("\n 0: Abbrechen") + while True: + try: + choice_str = input("\nGeben Sie den Modusnamen oder die Zahl ein: ").strip().lower() + if choice_str in ['0', 'abbrechen']: + print("Vorgang abgebrochen.") + return + if choice_str.isdigit() and int(choice_str) in mode_map: + selected_mode = mode_map[int(choice_str)] + break + elif choice_str in valid_modes: + selected_mode = choice_str + break + else: + print("Ungültige Eingabe. Bitte versuchen Sie es erneut.") + except (KeyboardInterrupt, EOFError): + print("\nVorgang abgebrochen.") + return + + # 4. Finales Logging (mit Datei) einrichten + root_logger.removeHandler(temp_console_handler) + log_directory = Config.LOG_DIR + if not os.path.exists(log_directory): os.makedirs(log_directory) + timestamp = datetime.now().strftime("%d-%m-%Y_%H-%M") + log_filename = f"{timestamp}_v{Config.VERSION.replace('.', '')}_Modus{selected_mode}.txt" + LOG_FILE = os.path.join(log_directory, log_filename) + final_console_handler = logging.StreamHandler() + final_console_handler.setFormatter(logging.Formatter(log_format)) + file_handler = logging.FileHandler(LOG_FILE, 'w', 'utf-8') + file_handler.setFormatter(logging.Formatter(log_format)) + logging.basicConfig(level=log_level, format=log_format, handlers=[final_console_handler, file_handler]) + + logger.info(f"Logging wird jetzt auch in Datei geschrieben: {LOG_FILE}") + logger.info("===== Skript gestartet =====") + logger.info(f"Version: {Config.VERSION}") + logger.info(f"CLI Argumente: {args}") + + # 5. Globale Konfigurationsdaten laden logger.info("Lade Konfigurationsdateien...") Config.load_api_keys() ziel_schema, fokus_branchen = load_target_schema() branch_mapping_dict = load_branch_mapping() if not ziel_schema or not branch_mapping_dict: - logger.critical("Fehler beim Laden von Konfigurationsdateien (Schema oder Mapping). Skriptabbruch.") + logger.critical("Fehler beim Laden von Konfigurationsdateien. Skriptabbruch.") return - # 4. Hauptkomponenten initialisieren + # 6. Hauptkomponenten initialisieren logger.info("Initialisiere Hauptkomponenten...") sheet_handler = GoogleSheetHandler(Config.SHEET_ID, Config.SERVICE_ACCOUNT_FILE, Config.TOKEN_FILE) wiki_scraper = WikipediaScraper() data_processor = DataProcessor(sheet_handler, wiki_scraper, ziel_schema, fokus_branchen, branch_mapping_dict) - logger.info("DataProcessor erfolgreich initialisiert.") - - # 5. Modus-Dispatching (der Rest Ihrer main-Funktion) + + # 7. Modus-Dispatching start_time = time.time() - - # Liste der gueltigen Modi - MUSS mit den elif-Zweigen unten uebereinstimmen! - # Kategorisiert fuer die Menue-Ausgabe - mode_categories = { - "Batch-Verarbeitung (Schritt-Optimiert)": [ - "wiki_verify", # Uebereinstimmend mit process_verification_batch (Block 26) - "website_scraping", # Uebereinstimmend mit process_website_scraping_batch (Block 27) - "summarize_website", # Uebereinstimmend mit process_summarization_batch (Block 28) - "branch_eval", # Uebereinstimmend mit process_branch_batch (Block 29) - "suggest_parents", - ], - "Sequentielle Verarbeitung (Zeilenweise)": [ - "full_run", # Nutzt process_rows_sequentially (Block 24) - ], - "Re-Evaluate Markierte Zeilen (Spalte A='x')": [ - "reeval", # Nutzt process_reevaluation_rows (Block 25) - ], - "Einzelne Dienstprogramme / Suchen": [ - "find_wiki_serp", # Nutzt process_find_wiki_serp (Block 30) - "website_lookup", # Nutzt process_serp_website_lookup (Block 30) - "check_urls", # <<< NEUER MODUS HIER EINFÜGEN - "contacts", # Nutzt process_contact_search (Block 30) - "update_wiki_suggestions", # Nutzt process_wiki_updates_from_chatgpt (Block 32) - "wiki_reextract_missing_an", # Nutzt process_wiki_reextract_missing_an (Block 32) - "website_details", # EXPERIMENTELL - Nutzt process_website_details (Block 32) - "train_technician_model", # Nutzt train_technician_model (Block 31) - "alignment", # Nutzt globale alignment_demo (Block 14) - "reparatur_sitz", - "plausi_check_data" # NEUER MODUS HIER - ], - "Kombinierte Laeufe (Vordefiniert)": [ - "combined_all", # Definiert eine Sequenz von Batch-Modi - ] - } - # Erstellen Sie eine flache Liste aller validen Modi fuer die Validierung - valid_modes = [mode for modes in mode_categories.values() for mode in modes] - - - # Dynamisch generieren des Help-Textes fuer den Modus - mode_help_text = "Betriebsmodus. Waehlen Sie einen der folgenden:\n" - for category, modes in mode_categories.items(): - mode_help_text += f"\n{category}:\n" - for mode in modes: - mode_help_text += f" - {mode}\n" - - parser.add_argument("--mode", type=str, help=mode_help_text) - # Hilfsargument fuer die CLI-basierte Modusauswahl (wenn --mode gesetzt ist) - parser.add_argument("-m", "--cli-mode", dest="mode", action="store_const", const=valid_modes[0] if valid_modes else None, help=argparse.SUPPRESS) # Unterdruecke in --help - - parser.add_argument("--limit", type=int, help="Maximale Anzahl zu verarbeitender Zeilen in den meisten Modi (prueft Zeilen VOR Ueberspringung/Filterung).", default=None) - # start_sheet_row wird primaer fuer full_run verwendet, kann aber auch fuer Bereiche in Batch nuetzlich sein - parser.add_argument("--start_sheet_row", type=int, help="Startzeile im Sheet (1-basiert) fuer 'full_run' und einige Batch-Modi. Standard: Automatische Ermittlung basierend auf Timestamp.", default=None) - # end_sheet_row fuer Bereiche - parser.add_argument("--end_sheet_row", type=int, help="Endzeile im Sheet (1-basiert) fuer 'full_run' und einige Batch-Modi. Standard: Ende des Sheets.", default=None) - - - # Argument fuer den Re-Eval und Full-Run Modus zur Auswahl der Schritte - # Moegliche Werte fuer die Schritte: 'wiki', 'chat', 'web', 'ml_predict', etc. (entsprechend den step_type Schluesseln in _process_single_row Block 19) - # Default ist 'all' fuer alle Schritte, oder eine spezifische Liste - # Dies sind die Schluessel, die _process_single_row (Block 19) in steps_to_run Set erwartet. - valid_single_row_steps = ['wiki', 'chat', 'web', 'ml_predict'] # Fuegen Sie hier weitere Schritt-Schluessel hinzu, die _process_single_row versteht - single_row_steps_help = f"Komma-getrennte Liste der Schritte im 'reeval' und 'full_run' Modus (z.B. 'wiki,chat').\nMögliche Schritte: {', '.join(valid_single_row_steps)}.\nStandard: {'all' if valid_single_row_steps else 'keine'}" # Standard: alle verfuegbaren Schritte - - # Standardwert fuer --steps: Alle gueltigen Single-Row Schritte, wenn es welche gibt - default_steps_arg = ','.join(valid_single_row_steps) if valid_single_row_steps else '' - parser.add_argument("--steps", type=str, help=single_row_steps_help, default=default_steps_arg) - - - # Argumente fuer find_wiki_serp (falls ueber CLI gesteuert) - parser.add_argument("--min_umsatz", type=float, help="Mindestumsatz in MIO € (CRM Spalte J) fuer find_wiki_serp Filter.", default=200.0) # Float fuer Konsistenz - parser.add_argument("--min_employees", type=int, help="Mindestmitarbeiterzahl (CRM Spalte K) fuer find_wiki_serp Filter.", default=500) - - - # Argumente fuer train_technician_model (Pfade fuer Output-Dateien) - parser.add_argument("--model_out", type=str, default=MODEL_FILE, help=f"Pfad fuer das trainierte Modell (.pkl). Standard: {MODEL_FILE}") # Block 1 Konstante - parser.add_argument("--imputer_out", type=str, default=IMPUTER_FILE, help=f"Pfad fuer den trainierten Imputer (.pkl). Standard: {IMPUTER_FILE}") # Block 1 Konstante - parser.add_argument("--patterns_out", type=str, default=PATTERNS_FILE_JSON, help=f"Pfad fuer die Feature-Spaltenliste (.json). Standard: {PATTERNS_FILE_JSON}") # Block 1 Konstante - - # TODO: Fuegen Sie hier weitere CLI-Argumente hinzu, falls andere Modi Parameter benoetigen - - args = parser.parse_args() - - - # --- Konfiguration laden --- - Config.load_api_keys() # Nutzt jetzt logging intern (print am Anfang Block 1) - - - # --- Logdatei-Konfiguration abschliessen --- - # Bestimmen Sie den Log-Modus Namen basierend auf CLI oder Interaktion - # Wir nutzen den CLI Modus Namen, wenn --mode gesetzt ist, sonst "interactive". - log_mode_name = args.mode if args.mode else "interactive" - LOG_FILE = create_log_filename(log_mode_name) # Nutzt globale Funktion (Block 3) - - # Wenn die Logdatei erfolgreich erstellt wurde - if LOG_FILE: - try: - # Erstellen Sie den FileHandler fuer die Logdatei - # mode='a' zum Anhaengen, encoding='utf-8' fuer Unicode - file_handler = logging.FileHandler(LOG_FILE, mode='a', encoding='utf-8') - file_handler.setLevel(log_level) # Nimm das globale Level - # Verwenden Sie denselben Formatter wie fuer den Console Handler - file_handler.setFormatter(logging.Formatter(log_format)) - # Fuege FileHandler zum Root-Logger hinzu - # Pruefen, ob nicht schon ein File Handler mit demselben Pfad vorhanden ist (z.B. bei wiederholten Aufrufen in Tests) - if not any(isinstance(h, logging.FileHandler) and h.baseFilename == os.path.abspath(LOG_FILE) for h in logging.getLogger('').handlers): - logging.getLogger('').addHandler(file_handler) - logger.info(f"Logging wird jetzt auch in Datei geschrieben: {LOG_FILE}") - except Exception as e: - # Logge Fehler nur auf Konsole, da FileHandler fehlgeschlagen ist - # logger.exception loggt auch an die Konsole, wenn kein FileHandler da ist - logger.error(f"Konnte FileHandler fuer Logdatei '{LOG_FILE}' nicht erstellen: {e}") - # Optional: Entfernen Sie evtl. den fehlerhaften Handler aus der Liste - logging.getLogger('').handlers = [h for h in logging.getLogger('').handlers if not isinstance(h, logging.FileHandler) or h.baseFilename == os.path.abspath(LOG_FILE)] # Entferne nur den fehlerhaften Handler - - - # --- JETZT die Startmeldungen loggen (gehen jetzt in Konsole UND Datei) --- - logger.info(f"===== Skript gestartet =====") - logger.info(f"Version: {current_script_version}") - # Logge den tatsaechlichen Pfad der Logdatei oder die Fehlermeldung - logger.info(f"Logdatei: {LOG_FILE if LOG_FILE else 'FEHLER - Keine Logdatei erstellt'}") - # Loggen Sie relevante CLI Argumente zur Dokumentation des Laufs - logger.info(f"CLI Argumente: {args}") - - - # --- Vorbereitung (Schema, Handler etc.) --- - # Laden Sie das Ziel-Branchenschema (Block 6) - # load_target_schema ist mit retry_on_failure dekoriert (Block 2). - load_target_schema() - - - # Initialisiere GoogleSheetHandler (Block 14) - sheet_handler = None # Initialisiere Variable - try: - # Der GoogleSheetHandler Init (_init_ Methode) baut die Verbindung auf und laedt Daten. - # Fehler werden dort gefangen und als ConnectionError erneut geworfen. - sheet_handler = GoogleSheetHandler() #<- Zeile 11362 - logger.info("GoogleSheetHandler erfolgreich initialisiert.") - except ConnectionError as e: - # Wenn die Initialisierung des SheetHandlers fehlschlaegt (Verbindungs-/Ladefehler) - logger.critical(f"FATAL: Initialisierung des GoogleSheetHandlers fehlgeschlagen: {e}") - logger.critical(f"Bitte ueberpruefen Sie Ihre Google Sheets URL, Credentials und Berechtigungen.") - logger.critical(f"Bitte Logdatei pruefen fuer Details: {LOG_FILE}") - return # Beende Skript, wenn Sheet nicht geladen werden kann - except Exception as e: - # Fangen Sie andere unerwartete Fehler bei der Initialisierung ab - logger.critical(f"FATAL: Unerwarteter Fehler bei Initialisierung von GoogleSheetHandler: {e}") - logger.debug(traceback.format_exc()) - logger.critical(f"Bitte Logdatei pruefen fuer Details: {LOG_FILE}") - return # Beende Skript - - - # Initialisiere WikipediaScraper (Block 14) - wiki_scraper = None # Initialisiere Variable - try: - # Der WikipediaScraper Init (_init_ Methode) konfiguriert die Bibliothek und Requests. - # Fehler werden dort gefangen und erneut geworfen. - wiki_scraper = WikipediaScraper() - logger.info("WikipediaScraper erfolgreich initialisiert.") - except Exception as e: - # Wenn die Initialisierung des WikipediaScrapers fehlschlaegt - logger.critical(f"FATAL: Initialisierung des WikipediaScrapers fehlgeschlagen: {e}") - logger.debug(traceback.format_exc()) - logger.critical(f"Bitte Logdatei pruefen fuer Details: {LOG_FILE}") - # Das Skript kann ohne Wiki Scraper viele Modi nicht sinnvoll laufen - return # Beende Skript - - - # TODO: Initialisieren Sie hier weitere Worker-Instanzen, falls Sie separate Klassen haben (z.B. OpenAIHandler, SerpAPIHandler) - # openai_handler = OpenAIHandler() - # serpapi_handler = SerpAPIHandler() - - logger.info("===== Spalten-Alignment Check =====") - if sheet_handler and sheet_handler.sheet_values and len(sheet_handler.sheet_values) > 0: - sheet_headers = sheet_handler.sheet_values[0] - logger.info(f"Header aus Google Sheet (erste {len(sheet_headers)} Spalten): {sheet_headers}") - - # Ausgabe der COLUMN_MAP für den Abgleich (gekürzt für Lesbarkeit im Log) - logger.info("Aktuelle COLUMN_MAP (Auszug):") - for i, (key, value) in enumerate(COLUMN_MAP.items()): - if i < 5 or i > len(COLUMN_MAP) - 6 : # Zeige erste 5 und letzte 5 - logger.info(f" '{key}': {value}") - elif i == 5: - logger.info(" ...") - else: - logger.warning("Konnte Header nicht aus Google Sheet laden für Alignment Check.") - logger.info("===================================") - - # Initialisiere DataProcessor Instanz (Block 15) mit Handlern - # Uebergeben Sie alle benoetigten Handler an den DataProcessor. - # Die __init__ Methode des DataProcessor (Block 15) prueft die Typen und wirft Value Error, wenn falsch. - try: - data_processor = DataProcessor(sheet_handler=sheet_handler, wiki_scraper=wiki_scraper) - logger.info("DataProcessor erfolgreich initialisiert.") - except Exception as e: - # Fangen Sie Fehler bei der DataProcessor Initialisierung ab. - logger.critical(f"FATAL: Initialisierung des DataProcessors fehlgeschlagen: {e}") - logger.debug(traceback.format_exc()) - logger.critical(f"Bitte Logdatei pruefen fuer Details: {LOG_FILE}") - return # Beende Skript - - - # --- Modusauswahl und Ausfuehrung --- - start_process_time = time.time() # Zeitmessung fuer die Verarbeitung starten logger.info(f"Starte Verarbeitung um {datetime.now().strftime('%H:%M:%S')}...") - - - selected_mode = None # Variable fuer den tatsaechlich auszufuehrenden Modus - - # --- Ermitteln des zu fuehrenden Modus (CLI hat Prioritaet vor interaktiver Auswahl) --- - # Wenn das --mode Argument ueber die Kommandozeile gesetzt wurde - if args.mode: - selected_mode = args.mode.lower() # Konvertiere zu Kleinbuchstaben - # Pruefen Sie, ob der gewaehlte Modus in der Liste der validen Modi enthalten ist - if selected_mode not in valid_modes: - # Logge einen Fehler und beende das Skript, wenn der Modus ungueltig ist. - logger.error(f"Ungueltiger Modus '{args.mode}' ueber Kommandozeile angegeben. Gueltige Modi: {', '.join(valid_modes)}") - print(f"Fehler: Ungueltiger Modus '{args.mode}'. Bitte ueberpruefen Sie die Liste der gueltigen Modi (siehe --help).") - return # Skript beenden - logger.info(f"Betriebsmodus (CLI gewaehlt): {selected_mode}") - - # Wenn das --mode Argument NICHT ueber die Kommandozeile gesetzt wurde - else: - # --- Interaktive Modusauswahl ueber die Konsole --- - print("\nBitte waehlen Sie den Betriebsmodus:") - # Zeigen Sie die Liste der validen Modi kategorisiert an, mit Nummern. - mode_options_map = {} # Dictionary zum Abbilden von Zahl/Name auf Modusname - option_counter = 1 # Zaehler fuer die numerischen Optionen - # Iteriere durch die Kategorien und Modi - for category, modes in mode_categories.items(): - print(f"\n{category}:") - for mode in modes: - print(f" {option_counter}: {mode}") - mode_options_map[str(option_counter)] = mode # Bilde die numerische Option auf den Modusnamen ab - mode_options_map[mode] = mode # Bilde den Modusnamen (kleingeschrieben) auf sich selbst ab (fuer direkte Eingabe) - option_counter += 1 # Erhoehe den Zaehler - - - # Fuegen Sie eine Option zum Abbrechen hinzu - print(f"\n 0: Abbrechen") - mode_options_map['0'] = 'exit' # Bilde 0 auf den speziellen 'exit' Modus ab - - - # Schleife, bis ein gueltiger Modus gewaehlt wurde oder der Benutzer abbricht - while selected_mode is None: - try: - # Lesen Sie die Eingabe vom Benutzer - mode_input = input(f"Geben Sie den Modusnamen oder die Zahl ein: ").strip().lower() - - # Pruefen Sie, ob die Eingabe einer Option in der Map entspricht - if mode_input in mode_options_map: - selected_mode = mode_options_map[mode_input] # Setzen Sie den gewaehlten Modusnamen - - # Wenn der 'exit' Modus gewaehlt wurde - if selected_mode == 'exit': - logger.info("Modus 'exit' gewaehlt. Skript wird beendet.") - print("Abgebrochen durch Benutzer.") - return # Beende das Skript - - # Logge den gewaehlten Modus - logger.info(f"Betriebsmodus (interaktiv gewaehlt): {selected_mode}") - - else: - # Wenn die Eingabe keinem gueltigen Modus entspricht - print("Ungueltige Eingabe. Bitte waehlen Sie eine gueltige Option aus der Liste.") - - # Wenn selected_mode immer noch None ist, laeuft die Schleife weiter - - - except EOFError: # Benutzer hat Ctrl+D gedrueckt (End-of-File) - # Fangen Sie das EOFError ab und beenden Sie das Skript sauber. - logger.warning("Interaktive Modus-Eingabe abgebrochen (EOFError). Skript wird beendet.") - print("\nEingabe abgebrochen.") - return # Beende das Skript - except Exception as e: - # Fangen Sie andere unerwartete Fehler bei der Eingabe ab - logger.error(f"Fehler bei interaktiver Modus-Eingabe: {e}") - logger.debug(traceback.format_exc()) - print(f"Ein Fehler ist bei der Modus-Eingabe aufgetreten ({e}). Bitte pruefen Sie die Logdatei.") - return # Beende das Skript bei unerwartetem Fehler - - # ============================================================================== - # === NEUER BLOCK: Interaktive Limit-Abfrage === - # ============================================================================== - limit_arg_cli = args.limit # ursprüngliches Limit vom CLI Argument - final_limit_to_use = limit_arg_cli # Standardmäßig das CLI-Limit verwenden - - # Wenn kein Limit über CLI gesetzt wurde UND der Modus nicht einer der ist, - # bei denen ein Zeilenlimit typischerweise keinen Sinn macht. - # (Für 'alignment' und 'train_technician_model' ist ein Zeilen-Durchlauf-Limit meist nicht relevant) - # 'check_urls' und andere Batch-Modi können aber von einem Limit profitieren. - skippable_limit_modes = ['alignment', 'train_technician_model'] - - if final_limit_to_use is None and selected_mode not in skippable_limit_modes: - while True: - try: - limit_input_str = input(f"Maximale Anzahl zu verarbeitender Zeilen für Modus '{selected_mode}' (Enter für Unbegrenzt, aktuell: Unbegrenzt): ").strip() - if not limit_input_str: # Benutzer drückt Enter - final_limit_to_use = None - logger.info("Kein Limit für Zeilenverarbeitung gesetzt (interaktiv).") - break - - # Versuche, in Integer umzuwandeln - temp_limit = int(limit_input_str) - - if temp_limit <= 0: - logger.warning(f"Ungültiges Limit '{temp_limit}' (<=0) eingegeben, wird als Unbegrenzt behandelt.") - final_limit_to_use = None - else: - final_limit_to_use = temp_limit - logger.info(f"Limit für Zeilenverarbeitung (interaktiv gesetzt): {final_limit_to_use}") - break # Gültige Eingabe oder Entscheidung für "Unbegrenzt" - except ValueError: - print("Ungültige Eingabe. Bitte eine ganze Zahl eingeben oder Enter für Unbegrenzt.") - except EOFError: - logger.warning("Interaktive Limit-Eingabe abgebrochen. Nutze kein Limit (oder CLI-Vorgabe, falls vorhanden).") - # final_limit_to_use behält den Wert von limit_arg_cli (also None, wenn hierher gekommen) - break - except Exception as e_limit_input: - logger.error(f"Unerwarteter Fehler bei interaktiver Limit-Eingabe: {e_limit_input}") - logger.debug(traceback.format_exc()) - print("Ein Fehler ist bei der Limit-Eingabe aufgetreten. Nutze kein Limit.") - final_limit_to_use = None - break - elif final_limit_to_use is not None: # Wenn ein Limit via CLI gesetzt wurde - logger.info(f"Verwende Limit aus CLI-Argument: {final_limit_to_use}") - elif selected_mode in skippable_limit_modes and final_limit_to_use is None: - logger.info(f"Modus '{selected_mode}' benötigt typischerweise kein Zeilenlimit. Limit-Abfrage übersprungen.") - - - # Die Variable `final_limit_to_use` enthält nun das anzuwendende Limit (entweder von CLI, interaktiv oder None) - # ============================================================================== - # === ENDE NEUER BLOCK === - # ============================================================================== - - - # --- Ausfuehrung des gewaehlten Modus --- + try: - # Holen Sie die CLI-Argumente fuer Start/End/Limit/Steps - limit_arg = args.limit - start_row_arg = args.start_sheet_row - end_row_arg = args.end_sheet_row - - # Sonderbehandlung fuer --steps Argument (relevant fuer reeval und full_run) - steps_to_run_set = set() # Initialisiere ein leeres Set - # Pruefen Sie, ob das --steps Argument gesetzt ist und nicht "all" (case-insensitive) - if args.steps and isinstance(args.steps, str) and args.steps.strip().lower() != 'all': - # Teilen Sie den String in Schritte auf und bereinigen Sie Leerzeichen - steps_list = [step.strip().lower() for step in args.steps.split(',') if step.strip()] - # Filtern Sie nur erlaubte Schritte (die von _process_single_row verstanden werden Block 19) - steps_to_run_set = set(step for step in steps_list if step in valid_single_row_steps) # valid_single_row_steps wurde oben definiert - - # Logge eine Warnung, wenn ungueltige Schritte angegeben wurden - if len(steps_to_run_set) != len(steps_list): - invalid_steps = [step for step in steps_list if step not in valid_single_row_steps] - logger.warning(f"Ignoriere ungueltige Schritte im --steps Argument: {invalid_steps}. Fuehre nur {steps_to_run_set} aus.") - - # Wenn nach der Filterung keine gueltigen Schritte uebrig sind - if not steps_to_run_set: - logger.error("Keine gueltigen Schritte im --steps Argument gefunden. Re-Eval/Full-Run kann nicht gestartet werden.") - print("Fehler: Keine gueltigen Schritte fuer den Modus ausgewaehlt. Bitte ueberpruefen Sie das --steps Argument.") - return # Skript beenden, wenn keine Schritte ausgewaehlt sind - - # Wenn das --steps Argument 'all' ist oder nicht gesetzt - else: - # Fuhren Sie standardmaessig alle gueltigen Single-Row Schritte aus. - steps_to_run_set = set(valid_single_row_steps) # valid_single_row_steps wurde oben definiert - # Logge, welche Schritte ausgewaehlt wurden, wenn es der Standard ist - if default_steps_arg: # Wenn es ueberhaupt gueltige Schritte gibt - logger.debug(f"--steps Argument 'all' oder nicht gesetzt. Standard Schritte: {steps_to_run_set}.") - - - # Dispatching basierend auf dem gewaehlten Modus (selected_mode) - logger.info(f"Starte Ausfuehrung des Modus: {selected_mode}") - - # ---- Kombinierte LÄUFE ---- - if selected_mode == "combined_all": - # Führt die wichtigsten Batch-Modi nacheinander aus - logger.info("--- Start Kombinierter Modus: wiki_verify ---") - # Rufe die Methode der DataProcessor Instanz auf (Block 26) - data_processor.process_verification_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - logger.info("--- Start Kombinierter Modus: website_scraping ---") - # Rufe die Methode der DataProcessor Instanz auf (Block 27) - data_processor.process_website_scraping_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - logger.info("--- Start Kombinierter Modus: summarize_website ---") - # Rufe die Methode der DataProcessor Instanz auf (Block 28) - data_processor.process_summarization_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - logger.info("--- Start Kombinierter Modus: branch_eval ---") - # Rufe die Methode der DataProcessor Instanz auf (Block 29) - data_processor.process_branch_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - # TODO: Fuegen Sie hier weitere Batch-Modi hinzu, falls sie im kombinierten Lauf enthalten sein sollen - logger.info("--- Kombinierter Modus abgeschlossen ---") - - - # ---- Batch-VERARBEITUNG (Schritt-Optimiert) ---- - elif selected_mode == "wiki_verify": # Entspricht dem Batch-Modus Wiki Verifizierung (AX) - # Rufe die Methode der DataProcessor Instanz auf (Block 26) - data_processor.process_verification_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - - elif selected_mode == "website_scraping": # Entspricht dem Batch-Modus Website Scraping (AR, AT, AP) - # Rufe die Methode der DataProcessor Instanz auf (Block 27) - data_processor.process_website_scraping_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - - elif selected_mode == "summarize_website": # Entspricht dem Batch-Modus Website Summarization (AS, AP) - # Rufe die Methode der DataProcessor Instanz auf (Block 28) - data_processor.process_summarization_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - - elif selected_mode == "branch_eval": # Entspricht dem Batch-Modus Branchen-Einstufung (W-Y, AO, AP) - # Rufe die Methode der DataProcessor Instanz auf (Block 29) - data_processor.process_branch_batch(start_sheet_row=start_row_arg, end_sheet_row=end_row_arg, limit=limit_arg) - - - # ---- Sequentielle VERARBEITUNG (Zeilenweise) ---- - elif selected_mode == "full_run": # Nutzt process_rows_sequentially (Block 24) - # Full_run verarbeitet sequentiell einen Bereich. - # Startzeile wird vom CLI Argument oder automatisch ermittelt (erste leere AO). - # Endzeile vom CLI Argument oder bis Ende Sheet. - # Limit begrenzt die Anzahl der *verarbeiteten* Zeilen im Bereich. - - calculated_start_sheet_row = start_row_arg # Beginne mit CLI Argument start_sheet_row - # Wenn start_sheet_row nicht ueber CLI gesetzt wurde - if calculated_start_sheet_row is None: - # Automatische Ermittlung der Startzeile (erste Zeile ohne AO) - logger.info("Automatische Ermittlung der Startzeile fuer sequenzielle Verarbeitung (erste Zeile ohne AO)...") - # get_start_row_index (Block 14) gibt 0-basierten Index in Daten (ohne Header) zurueck. - # Prueft auf leeren AO (Block 1 Column Map). - start_data_index_no_header = sheet_handler.get_start_row_index(check_column_key="Timestamp letzte Pruefung", min_sheet_row=7) - - # Wenn get_start_row_index -1 zurueckgibt (Fehler) - if start_data_index_no_header == -1: - logger.error("FEHLER bei automatischer Ermittlung der Startzeile. Kann Full-Run nicht starten.") - return # Beende das Skript - - # Berechne die 1-basierte Sheet-Startzeile aus dem 0-basierten Daten-Index - calculated_start_sheet_row = start_data_index_no_header + sheet_handler._header_rows + 1 # Block 14 SheetHandler Attribut - - - # Berechnen Sie die tatsaechliche Anzahl der zu verarbeitenden Zeilen im Bereich. - # (basierend auf Endzeile und Limit) - total_sheet_rows = len(sheet_handler.get_all_data_with_headers()) # Block 14 SheetHandler - calculated_end_sheet_row = end_row_arg if end_row_arg is not None else total_sheet_rows - # Stellen Sie sicher, dass die Endzeile nicht vor der Startzeile liegt - calculated_end_sheet_row = max(calculated_start_sheet_row - 1, calculated_end_sheet_row) - - - # Die Anzahl der Zeilen im betrachteten Bereich - rows_in_range = max(0, calculated_end_sheet_row - calculated_start_sheet_row + 1) - - # num_to_process ist das Limit, angewendet auf die Zeilen im Bereich. - num_to_process_calc = rows_in_range # Standard: alle Zeilen im Bereich - # Wenn ein Limit ueber CLI gesetzt wurde und es gueltig ist - if limit_arg is not None and isinstance(limit_arg, int) and limit_arg >= 0: - num_to_process_calc = min(rows_in_range, limit_arg) - - - # Wenn es Zeilen zu verarbeiten gibt - if num_to_process_calc > 0: - logger.info(f"'full_run': Verarbeite {num_to_process_calc} Zeilen im Sheet-Bereich [{calculated_start_sheet_row}, {calculated_end_sheet_row}].") - # Rufe die sequentielle Verarbeitungsmethode auf (Block 24) - # _process_single_row (Block 19) wird intern aufgerufen. - data_processor.process_rows_sequentially( - start_sheet_row = calculated_start_sheet_row, - num_to_process = num_to_process_calc, - # Uebergeben Sie die aus dem --steps Argument ermittelten Flags (steps_to_run_set) - process_wiki_steps='wiki' in steps_to_run_set, - process_chatgpt_steps='chat' in steps_to_run_set, - process_website_steps='web' in steps_to_run_set, - process_ml_steps='ml_predict' in steps_to_run_set - # TODO: Weitere Schritt-Flags hier uebergeben - # force_reeval_in_single_row=False # Normalerweise kein Re-Eval im Full-Run - # clear_x_flag=False # Normalerweise kein X loeschen im Full-Run - ) - else: - # Wenn keine Zeilen zu verarbeiten sind - logger.info(f"Keine Zeilen fuer 'full_run' zu verarbeiten im Bereich [{calculated_start_sheet_row}, {calculated_end_sheet_row}] mit Limit {limit_arg}.") - - - # ---- Re-EVALUATE Markierte Zeilen ---- - elif selected_mode == "reeval": # Nutzt process_reevaluation_rows (Block 25) - # reeval Modus nutzt immer force_reeval=True in _process_single_row. - # Das 'x'-Flag wird von _process_single_row (Block 21) geloescht, wenn clear_flag=True uebergeben wird. - # Das Limit wird direkt an process_reevaluation_rows uebergeben und dort gehandhabt. - if limit_arg is not None and isinstance(limit_arg, int) and limit_arg <= 0: - # Wenn ein Limit von 0 oder weniger angegeben wurde - logger.info(f"Limit {limit_arg} angegeben im Re-Eval Modus. Ueberspringe Verarbeitung.") - else: - # Rufe die Methode der DataProcessor Instanz auf (Block 25) - data_processor.process_reevaluation_rows( - row_limit=limit_arg, # Uebergibt das Limit (kann None sein) - clear_flag=True, # Standardmaessig das 'x'-Flag loeschen - # Uebergeben Sie die aus dem --steps Argument ermittelten Schritte (steps_to_run_set) - process_wiki_steps='wiki' in steps_to_run_set, - process_chatgpt_steps='chat' in steps_to_run_set, - process_website_steps='web' in steps_to_run_set, - process_ml_steps='ml_predict' in steps_to_run_set - # TODO: Weitere Schritt-Flags hier uebergeben - ) - - - # ---- Einzelne DIENSTPROGRAMME / SUCHEN ---- - elif selected_mode == "find_wiki_serp": # Nutzt process_find_wiki_serp (Block 30) - # find_wiki_serp sucht leere AY mit Groessenfilter. Nutzt limit, min_employees, min_umsatz. - # Start/Endzeile koennen manuell gesetzt werden oder werden automatisch ermittelt (erste leere AY). - data_processor.process_find_wiki_serp( - start_sheet_row=start_row_arg, # Kann manuell gesetzt werden - end_sheet_row=end_row_arg, # Kann manuell gesetzt werden - limit=limit_arg, # Kann manuell gesetzt werden - min_employees=args.min_employees, # Aus CLI Argument - min_umsatz=args.min_umsatz # Aus CLI Argument - ) - - elif selected_mode == "website_lookup": # Nutzt process_serp_website_lookup (Block 30) - # website_lookup sucht leere D. Nutzt limit. Start/Endzeile koennen manuell gesetzt werden. - data_processor.process_serp_website_lookup( - start_sheet_row=start_row_arg, # Kann manuell gesetzt werden - end_sheet_row=end_row_arg, # Kann manuell gesetzt werden - limit=limit_arg # Kann manuell gesetzt werden - ) - - elif selected_mode == "check_urls": - data_processor.process_url_check( - start_sheet_row=start_row_arg, - end_sheet_row=end_row_arg, - limit=limit_arg - ) - - elif selected_mode == "contacts": # Nutzt process_contact_search (Block 30) - # contacts sucht leere AM. Nutzt limit. Start/Endzeile koennen manuell gesetzt werden. - data_processor.process_contact_search( - start_sheet_row=start_row_arg, # Kann manuell gesetzt werden - end_sheet_row=end_row_arg, # Kann manuell gesetzt werden - limit=limit_arg # Kann manuell gesetzt werden - ) - - elif selected_mode == "update_wiki_suggestions": # Nutzt process_wiki_updates_from_chatgpt (Block 32) - # update_wiki_suggestions prueft Status S. Nutzt limit. Start/Endzeile koennen manuell gesetzt werden. - data_processor.process_wiki_updates_from_chatgpt( - start_sheet_row=start_row_arg, # Kann manuell gesetzt werden - end_sheet_row=end_row_arg, # Kann manuell gesetzt werden - limit=limit_arg # Kann manuell gesetzt werden - ) - - elif selected_mode == "wiki_reextract_missing_an": # Nutzt process_wiki_reextract_missing_an (Block 32) - # wiki_reextract_missing_an sucht M gefuellt & AN leer. Nutzt limit. Start/Endzeile koennen manuell gesetzt werden. - # Ruft intern _process_single_row mit steps={'wiki'} und force_reeval=True auf. - data_processor.process_wiki_reextract_missing_an( - start_sheet_row=start_row_arg, # Kann manuell gesetzt werden - end_sheet_row=end_row_arg, # Kann manuell gesetzt werden - limit=limit_arg # Kann manuell gesetzt werden - ) - - - elif selected_mode == "website_details": # EXPERIMENTELL - Nutzt process_website_details (Block 32) - # website_details sucht 'x' in A. Nutzt limit. Start/Endzeile koennen manuell gesetzt werden. - data_processor.process_website_details( - start_sheet_row=start_row_arg, # Kann manuell gesetzt werden - end_sheet_row=end_row_arg, # Kann manuell gesetzt werden - limit=limit_arg # Kann manuell gesetzt werden - ) - - - elif selected_mode == "train_technician_model": # Nutzt train_technician_model (Block 31) - # training braucht keine Zeilenlimits im Sinne eines Bereichs oder der Anzahl zu verarbeitender Zeilen im Sheet. - # Es nutzt prepare_data_for_modeling (Block 31), die alle relevanten Zeilen filtert. - # Die output-Pfade werden aus CLI Argumenten genommen (args). - data_processor.train_technician_model( - model_out=args.model_out, # Aus CLI Argument - imputer_out=args.imputer_out, # Aus CLI Argument - patterns_out=args.patterns_out # Aus CLI Argument (JSON Datei) - ) - - elif selected_mode == "alignment": # Nutzt globale alignment_demo (Block 14) - # alignment_demo ist eine globale Funktion, die das sheet Objekt braucht. - # Sie braucht keine Zeilenlimits oder Start/Ende. - if sheet_handler and sheet_handler.sheet: - alignment_demo(sheet_handler.sheet) - else: - logger.error("Sheet-Handler oder Sheet-Objekt nicht verfuegbar fuer Alignment-Demo.") - - elif selected_mode == "reparatur_sitz": # NEUER BLOCK - # Hier können Sie Start, Ende und Limit aus args verwenden, falls Sie dafür CLI-Optionen hinzufügen möchten - # oder feste Werte / interaktive Abfragen für diesen Modus implementieren. - # Für den Anfang ein kompletter Durchlauf (ab Datenstart): - data_processor.process_repair_sitz_data( - start_sheet_row=None, # Beginnt nach den Headern - end_sheet_row=None, # Bis zum Ende des Sheets - limit=final_limit_to_use # Verwendet das global ermittelte Limit - ) + logger.info(f"Betriebsmodus: {selected_mode}") + final_limit_to_use = args.limit + skippable_limit_modes = ['alignment', 'train_technician_model', 'analyze_ml_by_branch'] + if final_limit_to_use is None and selected_mode not in skippable_limit_modes: + try: + limit_input = input(f"Maximale Anzahl zu verarbeitender Zeilen für Modus '{selected_mode}' (Enter für Unbegrenzt): ") + if limit_input.strip(): + final_limit_to_use = int(limit_input) + logger.info(f"Limit für Zeilenverarbeitung (interaktiv gesetzt): {final_limit_to_use}") + except (ValueError, KeyboardInterrupt, EOFError): + logger.warning("Kein gültiges Limit eingegeben, wird als Unbegrenzt behandelt.") + final_limit_to_use = None + + # --- Ausführung des gewählten Modus --- + valid_single_row_steps = ['wiki', 'chat', 'web', 'ml_predict'] + steps_to_run_set = {step.strip().lower() for step in args.steps.split(',') if step.strip() and step.strip().lower() in valid_single_row_steps} + if not steps_to_run_set: + steps_to_run_set = set(valid_single_row_steps) # Default auf alle, wenn nichts Gültiges angegeben wurde + + # Dispatching basierend auf dem gewaehlten Modus (selected_mode) + if selected_mode == "combined_all": + data_processor.process_verification_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + data_processor.process_website_scraping_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + data_processor.process_summarization_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + data_processor.process_branch_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + elif selected_mode == "wiki_verify": + data_processor.process_verification_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + elif selected_mode == "website_scraping": + data_processor.process_website_scraping_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + elif selected_mode == "summarize_website": + data_processor.process_summarization_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + elif selected_mode == "branch_eval": + data_processor.process_branch_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=args.limit) + elif selected_mode == "suggest_parents": + data_processor.process_parent_suggestion_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) + elif selected_mode == "full_run": + data_processor.process_rows_sequentially(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, num_to_process=final_limit_to_use, steps_to_run=steps_to_run_set) + elif selected_mode == "reeval": + data_processor.process_reevaluation_rows(row_limit=final_limit_to_use, steps_to_run=steps_to_run_set) + elif selected_mode == "find_wiki_serp": + data_processor.process_find_wiki_serp(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use, min_employees=args.min_employees, min_umsatz=args.min_umsatz) + elif selected_mode == "website_lookup": + data_processor.process_serp_website_lookup(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) + elif selected_mode == "check_urls": + data_processor.process_url_check(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) + elif selected_mode == "contacts": + data_processor.process_contact_search(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) + elif selected_mode == "update_wiki_suggestions": + data_processor.process_wiki_updates_from_chatgpt(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) + elif selected_mode == "wiki_reextract_missing_an": + data_processor.process_wiki_reextract_missing_an(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) + elif selected_mode == "website_details": + data_processor.process_website_details(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) + elif selected_mode == "train_technician_model": + data_processor.train_technician_model(model_out=args.model_out or Config.MODEL_FILE, imputer_out=args.imputer_out or Config.IMPUTER_FILE, patterns_out=args.patterns_out or Config.PATTERNS_FILE_JSON) + elif selected_mode == "alignment": + alignment_demo(sheet_handler.sheet) + elif selected_mode == "reparatur_sitz": + data_processor.process_repair_sitz_data(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) elif selected_mode == "plausi_check_data": - data_processor.run_plausibility_checks_batch( - start_sheet_row=args.start_sheet_row, # Nimmt CLI-Argumente für Bereich - end_sheet_row=args.end_sheet_row, - limit=final_limit_to_use # VERWENDE das ermittelte Limit - ) - - - elif selected_mode == "suggest_parents": # <<< NEUER ELIF-BLOCK - data_processor.process_parent_suggestion_batch( - start_sheet_row=args.start_sheet_row, - end_sheet_row=args.end_sheet_row, - limit=final_limit_to_use, # Nutzt das ggf. interaktiv abgefragte Limit - re_evaluate_question_mark=True # Beispiel: Standardmäßig Fragezeichen neu bewerten - # Sie können hierfür auch ein CLI Argument hinzufügen - ) - - # ---- Modus nicht gefunden (sollte durch Validierung oben abgefangen werden) ---- + data_processor.run_plausibility_checks_batch(start_sheet_row=args.start_sheet_row, end_sheet_row=args.end_sheet_row, limit=final_limit_to_use) else: - # Dieser Zweig sollte aufgrund der Validierung am Anfang nie erreicht werden. - logger.error(f"Unerwarteter Modus '{selected_mode}' erreichte das Ausfuehrungsende des Dispatchers.") - print(f"Interner Fehler: Unbekannter Modus '{selected_mode}'.") + logger.error(f"Modus '{selected_mode}' ist definiert, hat aber keine Ausführungslogik in main().") - - # --- Ausnahmebehandlung fuer den gesamten Ausfuehrungsblock --- except KeyboardInterrupt: - # Wenn der Benutzer das Skript manuell unterbricht (Ctrl+C) - logger.warning("Skript durch Benutzer unterbrochen (KeyboardInterrupt).") - print("\n! Skript wurde manuell beendet.") + logger.warning("Skript durch Benutzer unterbrochen (KeyboardInterrupt).") + print("\n! Skript wurde manuell beendet.") except Exception as e: - # Dieser Block faengt alle unerwarteten Exceptions ab, die in den aufgerufenen - # Funktionen/Methoden passieren und nicht intern gefangen und behandelt werden. logger.critical(f"FATAL: Unerwarteter Fehler waehrend der Ausfuehrung von Modus '{selected_mode}': {e}") - # exception() loggt den Fehlertyp, die Nachricht und den vollständigen Traceback. - logger.exception("Traceback des kritischen Fehlers:") - # Gebe eine Fehlermeldung an die Konsole aus, die auf das Log verweist. - print(f"\n! Ein kritischer Fehler ist aufgetreten: {type(e).__name__} - {e}") - print(f"Bitte pruefen Sie die Logdatei fuer Details: {LOG_FILE}") - - - # --- Abschluss der Skriptausfuehrung --- - end_process_time = time.time() # Ende der Zeitmessung - duration = end_process_time - start_process_time # Berechne die Gesamtdauer - logger.info(f"Verarbeitung abgeschlossen um {datetime.now().strftime('%H:%M:%S')}.") - logger.info(f"Gesamtdauer: {duration:.2f} Sekunden.") - logger.info(f"===== Skript beendet =====") - - # Schliesse Logging Handler explizit - # Dies stellt sicher, dass alle gepufferten Logmeldungen in die Datei geschrieben werden. - logging.shutdown() - - # Logfile Pfad fuer den Nutzer auf der Konsole ausgeben - if LOG_FILE: - print(f"\nVerarbeitung abgeschlossen. Logfile: {LOG_FILE}") - else: - print("\nVerarbeitung abgeschlossen. Es konnte keine Logdatei erstellt werden.") + logger.error(f"Traceback des kritischen Fehlers:\n{traceback.format_exc()}") + if LOG_FILE: + print(f"\n! Ein kritischer Fehler ist aufgetreten: {type(e).__name__} - {e}. Bitte Logdatei pruefen: {LOG_FILE}") + else: + print(f"\n! Ein kritischer Fehler ist aufgetreten: {type(e).__name__} - {e}.") + finally: + end_time = time.time() + logger.info(f"Verarbeitung abgeschlossen um {datetime.now().strftime('%H:%M:%S')}.") + logger.info(f"Gesamtdauer: {(end_time - start_time):.2f} Sekunden.") + logger.info("===== Skript beendet =====") + logging.shutdown() + if LOG_FILE: + print(f"\nVerarbeitung abgeschlossen. Logfile: {LOG_FILE}") # ==============================================================================