From 55b00a1425241be9d9b735795ea625136a3d0f9c Mon Sep 17 00:00:00 2001 From: Floke Date: Mon, 26 May 2025 16:05:47 +0000 Subject: [PATCH] bugfix --- brancheneinstufung.py | 323 ++++++++++++++++++++++++++---------------- 1 file changed, 200 insertions(+), 123 deletions(-) diff --git a/brancheneinstufung.py b/brancheneinstufung.py index 502ea3e0..1f3cbfdc 100644 --- a/brancheneinstufung.py +++ b/brancheneinstufung.py @@ -4563,114 +4563,174 @@ class DataProcessor: # _needs_wiki_processing prueft V (alt AN) und Y="X (URL Copied)" (alt S). run_wiki_step = 'wiki' in steps_to_run - # _needs_wiki_processing (Block 18) nutzt die NEUEN Spaltennamen für Timestamps/Status + # _needs_wiki_processing prüft den Wikipedia Timestamp (Z) und AC="X (URL COPIED)" wiki_processing_needed_based_on_status = self._needs_wiki_processing(row_data, force_reeval) if run_wiki_step and wiki_processing_needed_based_on_status: - any_processing_done = True - - grund_message_parts = [] - if force_reeval: grund_message_parts.append('Re-Eval') - if not self._get_cell_value_safe(row_data, "Wikipedia Timestamp").strip(): grund_message_parts.append('V (Wikipedia Timestamp) leer') # Neuer Schlüssel - if self._get_cell_value_safe(row_data, "Chat Wiki Konsistenzpruefung").strip().upper() == "X (URL COPIED)": grund_message_parts.append("Y (Chat Wiki Konsistenzpruefung)='X (URL Copied)'") # Neuer Schlüssel - grund_message = ", ".join(filter(None, grund_message_parts)) or "Unbekannter Grund" - + any_processing_done = True + # ... (Grund Message für Log erstellen) ... self.logger.info(f"Zeile {row_num_in_sheet}: Fuehre WIKI Suche/Extraktion aus (Grund: {grund_message})...") - # Aktuelle Wiki URL aus Spalte N (alt M) - url_in_n_sheet = self._get_cell_value_safe(row_data, "Wiki URL").strip() # Neuer Schlüssel "Wiki URL" - url_to_extract_from = None - search_was_needed_flag = False + system_suggested_parent_name = self._get_cell_value_safe(row_data, "System Vorschlag Parent Account").strip() # Spalte O + current_wiki_url_in_sheet_for_daughter = self._get_cell_value_safe(row_data, "Wiki URL").strip() # Spalte R - status_y_indicates_reparse = self._get_cell_value_safe(row_data, "Chat Wiki Konsistenzpruefung").strip().upper() == "X (URL COPIED)" # Neuer Schlüssel - timestamp_v_is_empty = not self._get_cell_value_safe(row_data, "Wikipedia Timestamp").strip() # Neuer Schlüssel - - n_url_looks_valid_in_sheet = url_in_n_sheet and isinstance(url_in_n_sheet, str) and "wikipedia.org/wiki/" in url_in_n_sheet.lower() and url_in_n_sheet.lower() not in ["k.a.", "kein artikel gefunden", "fehler bei suche", "http:"] + url_to_extract_from = None # Die URL, von der WIRKLICH extrahiert wird + # Name, der für die Validierung des Artikels durch _validate_article verwendet wird + name_for_wiki_article_validation = company_name + source_of_wiki_data_origin = "Tochter" # Woher stammen die Wiki-Daten letztendlich? + additional_info_for_af = "" # Für Spalte AF "Begründung bei Abweichung" - # --- Logik zur Bestimmung der URL und Priorisierung von SerpAPI --- - if status_y_indicates_reparse: - self.logger.info(f" -> Status Y ist 'X (URL Copied)', ignoriere URL '{url_in_n_sheet[:100]}...' in N. Starte neue Suche (primär SerpAPI)...") - search_was_needed_flag = True - elif force_reeval: - self.logger.debug(" -> Re-Eval Modus aktiv fuer Wiki-Schritt.") - if n_url_looks_valid_in_sheet: - self.logger.info(f" -> Re-Eval: Nutze vorhandene URL aus Spalte N direkt: {url_in_n_sheet[:100]}...") - url_to_extract_from = url_in_n_sheet - else: - self.logger.debug(f" -> Re-Eval: Spalte N leer/ungueltig ('{url_in_n_sheet[:100]}...'). Starte neue Suche (primär SerpAPI)...") - search_was_needed_flag = True - elif timestamp_v_is_empty: # Wikipedia Timestamp (V, alt AN) ist leer - if n_url_looks_valid_in_sheet: - self.logger.debug(f" -> Wikipedia Timestamp (V) fehlt, pruefe Validitaet der URL aus N: {url_in_n_sheet[:100]}...") - try: - # Validierung mit der wiki_scraper Instanz - # _validate_article erwartet ein Page-Objekt. Wir müssen es zuerst holen. - title_from_url_part = url_in_n_sheet.split('/wiki/', 1)[1].split('#')[0] - title_from_url = unquote(title_from_url_part).replace('_', ' ') - page_object_from_n = wikipedia.page(title_from_url, auto_suggest=False, preload=True) # Kann Exceptions werfen - - if self.wiki_scraper._validate_article(page_object_from_n, company_name, website_url): - url_to_extract_from = page_object_from_n.url - self.logger.info(f" -> Vorhandene URL aus N '{url_to_extract_from[:100]}...' ist valide und wird verwendet.") - else: - self.logger.warning(f" -> Vorhandene URL aus N '{page_object_from_n.title[:100]}...' ist NICHT valide. Starte neue Suche (primär SerpAPI)...") - search_was_needed_flag = True - except (wikipedia.exceptions.PageError, wikipedia.exceptions.DisambiguationError) as e_wiki_val: - self.logger.warning(f" -> Vorhandene URL aus N '{url_in_n_sheet[:100]}...' fuehrt zu Fehler ({type(e_wiki_val).__name__}). Starte neue Suche (primär SerpAPI)...") - if isinstance(e_wiki_val, wikipedia.exceptions.DisambiguationError): - self.logger.debug(f" -> Disambiguation Optionen: {str(e_wiki_val.options)[:100]}...") - search_was_needed_flag = True - except Exception as e_val_m_general: - self.logger.exception(f" -> Unerwarteter Fehler beim Pruefen/Laden der URL aus N '{url_in_n_sheet[:100]}...': {e_val_m_general}. Starte neue Suche (primär SerpAPI)...") - search_was_needed_flag = True - else: - self.logger.debug(f" -> Wikipedia Timestamp (V) fehlt und N leer/ungueltig ('{url_in_n_sheet[:100]}...'). Starte Wikipedia-Suche (primär SerpAPI) fuer '{company_name[:50]}...'...") - search_was_needed_flag = True - - if search_was_needed_flag: - self.logger.info(f" -> Suche nach Wikipedia-Artikel für '{company_name[:50]}...' via SerpAPI...") - search_name_for_serp = crm_kurzform if crm_kurzform and len(crm_kurzform) > 2 else company_name - self.logger.debug(f" Verwende Suchnamen für SerpAPI: '{search_name_for_serp}'") - try: - # serp_wikipedia_lookup ist global und nutzt retry - new_url_from_serp = serp_wikipedia_lookup(search_name_for_serp, website=website_url) - if new_url_from_serp: - url_to_extract_from = new_url_from_serp - self.logger.info(f" -> SerpAPI Suche erfolgreich, gefundene URL: {url_to_extract_from[:100]}...") - else: - self.logger.warning(f" -> SerpAPI Suche fand keinen passenden Wikipedia-Artikel für '{search_name_for_serp}'.") - url_to_extract_from = 'Kein Artikel gefunden' # Expliziter Wert - except Exception as e_serp_wiki_search: - self.logger.error(f"FEHLER bei SerpAPI Wikipedia Suche für '{search_name_for_serp}': {e_serp_wiki_search}") - url_to_extract_from = f"FEHLER bei Suche (SerpAPI): {str(e_serp_wiki_search)[:50]}..." - - # --- Datenextraktion, wenn eine URL bestimmt wurde --- - if url_to_extract_from and isinstance(url_to_extract_from, str) and url_to_extract_from.lower() not in ['kein artikel gefunden'] and not url_to_extract_from.startswith("FEHLER"): - self.logger.debug(f" -> Extrahiere Daten von URL: {url_to_extract_from[:100]}...") + # --- NEUE LOGIK: Parent-Account (O) prüfen --- + if system_suggested_parent_name and system_suggested_parent_name.lower() != "k.a.": + if not current_wiki_url_in_sheet_for_daughter or current_wiki_url_in_sheet_for_daughter.lower() == "k.a.": + # Szenario 1: Parent O gefüllt, Wiki R der Tochter leer/k.A. + self.logger.info(f" Zeile {row_num_in_sheet}: Parent '{system_suggested_parent_name}' (O) vorhanden, Wiki-URL der Tochter (R) leer. Versuche Wiki-Suche für Parent.") + try: + parent_page_object = self.wiki_scraper.search_company_article( + company_name=system_suggested_parent_name, + website=None # Keine spezifische Parent-Website bekannt, suche nur mit Namen + ) + if parent_page_object: + url_to_extract_from = parent_page_object.url + name_for_wiki_article_validation = system_suggested_parent_name # Artikel wird gegen Parent-Namen validiert + source_of_wiki_data_origin = "Parent (O)" + additional_info_for_af = f"INFO: Wiki-Daten von Parent '{system_suggested_parent_name}' übernommen. " + self.logger.info(f" -> Wiki-Artikel für Parent '{system_suggested_parent_name}' gefunden: {url_to_extract_from}") + else: + self.logger.warning(f" -> Kein Wiki-Artikel für Parent '{system_suggested_parent_name}' gefunden. Standard-Tochter-Suche folgt.") + # url_to_extract_from bleibt None, die Standard-Logik unten greift. + except Exception as e_parent_wiki_search: + self.logger.error(f" -> Fehler bei Suche nach Wiki für Parent '{system_suggested_parent_name}': {e_parent_wiki_search}") + # Standard-Tochter-Suche folgt. + else: + # Szenario 2: Parent O gefüllt, UND Wiki R der Tochter auch gefüllt. + self.logger.info(f" Zeile {row_num_in_sheet}: Parent '{system_suggested_parent_name}' (O) vorhanden, aber auch Wiki-URL der Tochter (R) '{current_wiki_url_in_sheet_for_daughter}'. Tochter-Wiki hat Vorrang für Extraktion, falls notwendig.") + # Die Standard-Logik unten wird current_wiki_url_in_sheet_for_daughter verwenden. + # url_to_extract_from wird in der Standard-Logik ggf. mit current_wiki_url_in_sheet_for_daughter initialisiert. + pass # Keine Aktion hier, Standardlogik für Tochter greift. + + # --- Standard-Logik für Wiki-URL der Tochter, wenn nicht schon eine Parent-URL gefunden wurde --- + if url_to_extract_from is None: # Nur wenn noch keine URL vom Parent kam + search_for_daughter_wiki_needed = False + + status_ac_indicates_reparse = self._get_cell_value_safe(row_data, "Chat Wiki Konsistenzpruefung").strip().upper() == "X (URL COPIED)" # Spalte AC + timestamp_z_is_empty = not self._get_cell_value_safe(row_data, "Wikipedia Timestamp").strip() # Spalte Z + + # Hat die Tochter bereits eine valide aussehende URL in Spalte R? + r_url_is_valid_looking = current_wiki_url_in_sheet_for_daughter and \ + "wikipedia.org/wiki/" in current_wiki_url_in_sheet_for_daughter.lower() and \ + current_wiki_url_in_sheet_for_daughter.lower() not in ["k.a.", "kein artikel gefunden", "fehler bei suche"] + + if status_ac_indicates_reparse: + self.logger.info(f" Zeile {row_num_in_sheet}: Status AC ('Chat Wiki Konsistenzpruefung') ist 'X (URL COPIED)'. Starte neue Suche für Tochter '{company_name}'.") + search_for_daughter_wiki_needed = True + elif force_reeval: + if r_url_is_valid_looking: + self.logger.info(f" Zeile {row_num_in_sheet}: Re-Eval Modus. Nutze vorhandene Tochter-URL (R): {current_wiki_url_in_sheet_for_daughter}") + url_to_extract_from = current_wiki_url_in_sheet_for_daughter + else: + self.logger.info(f" Zeile {row_num_in_sheet}: Re-Eval Modus. Tochter-URL (R) leer/ungültig. Starte neue Suche für Tochter '{company_name}'.") + search_for_daughter_wiki_needed = True + elif timestamp_z_is_empty: # Wikipedia Timestamp (Z) fehlt + if r_url_is_valid_looking: + self.logger.info(f" Zeile {row_num_in_sheet}: Wikipedia Timestamp (Z) fehlt. Validiere vorhandene Tochter-URL (R): {current_wiki_url_in_sheet_for_daughter}") + # Hier könnte eine explizite Validierung der Tochter-URL stehen (mit _validate_article), + # aber search_company_article macht das implizit, wenn eine URL direkt übergeben wird. + # Fürs Erste nehmen wir an, die URL wird verwendet und extract_company_data validiert. + url_to_extract_from = current_wiki_url_in_sheet_for_daughter + else: + self.logger.info(f" Zeile {row_num_in_sheet}: Wikipedia Timestamp (Z) fehlt und Tochter-URL (R) leer/ungültig. Starte neue Suche für Tochter '{company_name}'.") + search_for_daughter_wiki_needed = True + elif not r_url_is_valid_looking: # Fallback, wenn Z nicht leer, aber R schlecht ist (z.B. "k.A.") + self.logger.info(f" Zeile {row_num_in_sheet}: Tochter-URL (R) ist ungültig ('{current_wiki_url_in_sheet_for_daughter}'). Starte neue Suche für Tochter '{company_name}'.") + search_for_daughter_wiki_needed = True + else: # R ist vorhanden und Timestamp Z ist gesetzt, kein Re-Eval -> keine Wiki-Aktion für Tochter nötig + self.logger.debug(f" Zeile {row_num_in_sheet}: Wiki-Verarbeitung für Tochter nicht nötig (Timestamp Z gesetzt, R vorhanden, kein Re-Eval/Reparse).") + + + if search_for_daughter_wiki_needed: + self.logger.info(f" -> Suche nach Wikipedia-Artikel für Tochter '{company_name}'...") + daughter_page_object = self.wiki_scraper.search_company_article( + company_name=company_name, # Name der Tochter + website=website_url # Website der Tochter + ) + if daughter_page_object: + url_to_extract_from = daughter_page_object.url + name_for_wiki_article_validation = company_name # Artikel wird gegen Tochter-Namen validiert + source_of_wiki_data_origin = "Tochter (Suche)" + self.logger.info(f" -> Suche für Tochter '{company_name}' erfolgreich, gefundene URL: {url_to_extract_from}") + else: + self.logger.warning(f" -> Kein Wiki-Artikel für Tochter '{company_name}' gefunden.") + url_to_extract_from = "Kein Artikel gefunden" + + # Wenn nach all dem url_to_extract_from immer noch None ist, aber eine URL in R stand, diese nehmen. + if url_to_extract_from is None and r_url_is_valid_looking: + url_to_extract_from = current_wiki_url_in_sheet_for_daughter + name_for_wiki_article_validation = company_name + source_of_wiki_data_origin = "Tochter (aus R)" + + + # --- DATENEXTRAKTION (von der ermittelten URL) --- + # Diese Logik wird nur ausgeführt, wenn eine gültige URL zum Extrahieren gefunden wurde + if url_to_extract_from and isinstance(url_to_extract_from, str) and \ + url_to_extract_from.lower() not in ["k.a.", "kein artikel gefunden"] and \ + not url_to_extract_from.startswith("FEHLER"): + + self.logger.debug(f" -> Extrahiere Wiki-Daten von URL ({source_of_wiki_data_origin}): {url_to_extract_from[:100]}...") try: - extracted_data = self.wiki_scraper.extract_company_data(url_to_extract_from) - if extracted_data and isinstance(extracted_data, dict) and extracted_data.get('url') != 'k.A.': - final_wiki_data = extracted_data - wiki_data_updated_in_this_run = True - self.logger.info(f" -> Datenextraktion von {url_to_extract_from[:100]}... erfolgreich.") - else: - self.logger.error(f" -> Fehler bei Datenextraktion von {url_to_extract_from[:100]}... oder Extraktion war leer. Setze Daten auf 'k.A.'") - final_wiki_data = {'url': url_to_extract_from, 'sitz_stadt': 'k.A.', 'sitz_land': 'k.A.', 'first_paragraph': 'k.A. (Extraktion fehlgeschlagen)', 'branche': 'k.A.', 'umsatz': 'k.A.', 'mitarbeiter': 'k.A.', 'categories': 'k.A.'} - wiki_data_updated_in_this_run = True - except Exception as e_wiki_extract: - self.logger.error(f"FEHLER bei Wikipedia Datenextraktion von {url_to_extract_from[:100]}...: {e_wiki_extract}") - final_wiki_data = {'url': url_to_extract_from, 'sitz_stadt': 'k.A.', 'sitz_land': 'k.A.', 'first_paragraph': f'k.A. (FEHLER Extraktion: {str(e_wiki_extract)[:50]}...)', 'branche': 'k.A.', 'umsatz': 'k.A.', 'mitarbeiter': 'k.A.', 'categories': 'k.A.'} - wiki_data_updated_in_this_run = True - else: # Wenn keine gueltige URL zum Extrahieren bestimmt wurde - self.logger.debug(f" -> Keine gueltige URL zum Extrahieren bestimmt ('{url_to_extract_from}'). Wiki-Daten nicht extrahiert oder bleiben auf Fehlerstatus.") - if url_to_extract_from in ['Kein Artikel gefunden'] or (isinstance(url_to_extract_from, str) and url_to_extract_from.startswith("FEHLER")): - final_wiki_data['url'] = url_to_extract_from - for key_to_clear in ['sitz_stadt', 'sitz_land', 'first_paragraph', 'branche', 'umsatz', 'mitarbeiter', 'categories']: - final_wiki_data[key_to_clear] = 'k.A.' - wiki_data_updated_in_this_run = True + # WICHTIG: Die Validierung innerhalb von extract_company_data muss wissen, ob es sich um einen Parent-Artikel handelt, + # um den korrekten Namen (Parent-Name vs. Tochter-Name) für die Ähnlichkeitsprüfung zu verwenden. + # `extract_company_data` ruft `_validate_article` auf, das `company_name` als Argument bekommt. + # Wir übergeben hier `name_for_wiki_article_validation`. + extracted_data = self.wiki_scraper.extract_company_data( + page_url=url_to_extract_from, + # company_name_for_validation=name_for_wiki_article_validation # Diese Anpassung wäre in extract_company_data nötig + ) + + if extracted_data and isinstance(extracted_data, dict) and extracted_data.get('url') != 'k.A.': + final_wiki_data = extracted_data + wiki_data_updated_in_this_run = True + self.logger.info(f" -> Datenextraktion von {url_to_extract_from[:100]}... ({source_of_wiki_data_origin}) erfolgreich.") + + # Wenn Daten vom Parent stammen, setze den AC-Vermerk + if source_of_wiki_data_origin == "Parent (O)": + ac_wert_fuer_parent_wiki = "INFO_PARENT_WIKI" + self.logger.info(f" -> Setze AC ('Chat Wiki Konsistenzpruefung') auf '{ac_wert_fuer_parent_wiki}', da Wiki-Daten von Parent.") + updates.append({ + 'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Chat Wiki Konsistenzpruefung"] + 1)}{row_num_in_sheet}', + 'values': [[ac_wert_fuer_parent_wiki]] + }) + # Leere auch die abhängigen Chat-Wiki-Spalten AD, AE + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Chat Begründung Wiki Inkonsistenz"] + 1)}{row_num_in_sheet}', 'values': [['']]}) + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Chat Vorschlag Wiki Artikel"] + 1)}{row_num_in_sheet}', 'values': [['']]}) + # Und den Wiki Verif. Timestamp (AA) leeren + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wiki Verif. Timestamp"] + 1)}{row_num_in_sheet}', 'values': [['']]}) - # --- Sheet Updates für N-AB (Wiki-Daten) und Timestamps V, W, X --- - # Verwende die NEUEN Spaltenschlüssel aus der aktuellen COLUMN_MAP + + else: # Fehler bei Extraktion oder leeres Ergebnis + self.logger.error(f" -> Fehler bei Datenextraktion von {url_to_extract_from[:100]}... oder Extraktion war leer. Setze Daten auf 'k.A.'") + final_wiki_data['url'] = url_to_extract_from + for key_to_clear in ['sitz_stadt', 'sitz_land', 'first_paragraph', 'branche', 'umsatz', 'mitarbeiter', 'categories']: + final_wiki_data[key_to_clear] = 'k.A. (Extraktion fehlgeschlagen)' if key_to_clear == 'first_paragraph' else 'k.A.' + wiki_data_updated_in_this_run = True + + except Exception as e_wiki_extract: + self.logger.error(f"FEHLER bei Wikipedia Datenextraktion von {url_to_extract_from[:100]}...: {e_wiki_extract}") + final_wiki_data['url'] = url_to_extract_from + for key_to_clear in ['sitz_stadt', 'sitz_land', 'first_paragraph', 'branche', 'umsatz', 'mitarbeiter', 'categories']: + final_wiki_data[key_to_clear] = f'k.A. (FEHLER Extraktion)' if key_to_clear == 'first_paragraph' else 'k.A.' + wiki_data_updated_in_this_run = True + + else: # Wenn keine gültige URL zum Extrahieren bestimmt wurde + self.logger.debug(f" -> Keine Wiki-URL zum Extrahieren bestimmt ('{url_to_extract_from}'). Wiki-Daten nicht geändert oder bleiben auf Fehlerstatus.") + if isinstance(url_to_extract_from, str) and (url_to_extract_from.lower() == 'kein artikel gefunden' or url_to_extract_from.startswith("FEHLER")): + # Nur die URL-Spalte (R) mit dem Fehler/Hinweis aktualisieren, Rest auf k.A. + final_wiki_data['url'] = url_to_extract_from + for key_to_clear in ['sitz_stadt', 'sitz_land', 'first_paragraph', 'branche', 'umsatz', 'mitarbeiter', 'categories']: + final_wiki_data[key_to_clear] = 'k.A.' + wiki_data_updated_in_this_run = True # Markiere als Update, damit Timestamps gesetzt werden + + # --- Sheet Updates für Wiki-Daten (R-Y) und Timestamps (Z, AA, AB) --- updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wiki URL"] + 1)}{row_num_in_sheet}', 'values': [[final_wiki_data.get('url', 'k.A.')]]}) updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wiki Sitz Stadt"] + 1)}{row_num_in_sheet}', 'values': [[final_wiki_data.get('sitz_stadt', 'k.A.')]]}) updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wiki Sitz Land"] + 1)}{row_num_in_sheet}', 'values': [[final_wiki_data.get('sitz_land', 'k.A.')]]}) @@ -4680,32 +4740,49 @@ class DataProcessor: updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wiki Mitarbeiter"] + 1)}{row_num_in_sheet}', 'values': [[final_wiki_data.get('mitarbeiter', 'k.A.')]]}) updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wiki Kategorien"] + 1)}{row_num_in_sheet}', 'values': [[final_wiki_data.get('categories', 'k.A.')]]}) - updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wikipedia Timestamp"] + 1)}{row_num_in_sheet}', 'values': [[now_timestamp]]}) # Spalte V + # Timestamp für Wikipedia-Extraktion (Z) immer setzen, wenn der Wiki-Schritt lief + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wikipedia Timestamp"] + 1)}{row_num_in_sheet}', 'values': [[now_timestamp]]}) - # Setze Y (Chat Wiki Konsistenzpruefung) und W (Wiki Verif. Timestamp) zurück, wenn Neubewertung nötig - status_y_from_sheet = self._get_cell_value_safe(row_data, "Chat Wiki Konsistenzpruefung").strip().upper() # Neuer Schlüssel Y - url_changed_and_is_valid_wiki_link = (url_in_n_sheet != final_wiki_data.get('url')) and \ - isinstance(final_wiki_data.get('url'), str) and \ - "wikipedia.org/wiki/" in final_wiki_data.get('url', '').lower() and \ - final_wiki_data.get('url', '').lower() not in ["k.a.", "kein artikel gefunden"] and \ - not final_wiki_data.get('url', '').startswith("FEHLER") + # Wenn eine SerpAPI-Suche für die Tochter durchgeführt wurde, setze den SerpAPI Wiki Search Timestamp (AB) + # Das Flag `search_for_daughter_wiki_needed` muss aus der Tochter-Logik kommen. + # if search_for_daughter_wiki_needed: + # updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["SerpAPI Wiki Search Timestamp"] + 1)}{row_num_in_sheet}', 'values': [[now_timestamp]]}) + + # Status AC (Chat Wiki Konsistenzpruefung) und AA (Wiki Verif. Timestamp) zurücksetzen, wenn Neubewertung nötig + # Dies ist insbesondere dann der Fall, wenn eine neue URL (egal ob von Parent oder Tochter) in R geschrieben wurde, + # oder wenn Re-Eval forciert wurde. + # Die Logik hierfür muss die `source_of_wiki_data_origin` und `url_to_extract_from` vs. `current_wiki_url_in_sheet_for_daughter` vergleichen. + + # Vereinfachte Reset-Logik: Wenn wiki_data_updated_in_this_run True ist UND der neue Status nicht "INFO_PARENT_WIKI" ist, + # dann setze AC auf "?" und leere AA. + ac_current_value = self._get_cell_value_safe(row_data, "Chat Wiki Konsistenzpruefung").strip() + + # Wenn eine neue URL gefunden und extrahiert wurde (egal ob Parent oder Tochter-Suche) + # ODER wenn Re-Eval war und eine URL vorhanden ist, von der extrahiert wurde. + reset_ac_aa = False + if wiki_data_updated_in_this_run and \ + final_wiki_data.get('url', 'k.A.').lower() not in ["k.a.", "kein artikel gefunden", "kein artikel gefunden (parent)"] and \ + not final_wiki_data.get('url', '').startswith("FEHLER"): + + if source_of_wiki_data_origin == "Parent (O)": + # AC wurde bereits auf "INFO_PARENT_WIKI" gesetzt, AA geleert. Hier nichts weiter tun. + pass + elif current_wiki_url_in_sheet_for_daughter != final_wiki_data.get('url'): # URL der Tochter hat sich geändert + reset_ac_aa = True + elif force_reeval: # Re-Eval und eine URL wurde verarbeitet + reset_ac_aa = True + elif status_ac_indicates_reparse: # AC war "X (URL COPIED)" + reset_ac_aa = True + + + if reset_ac_aa and ac_current_value != "INFO_PARENT_WIKI": # Nicht zurücksetzen, wenn es gerade erst auf Parent-Info gesetzt wurde + self.logger.info(f" Zeile {row_num_in_sheet}: Setze AC ('Chat Wiki Konsistenzpruefung') auf '?' und leere AA ('Wiki Verif. Timestamp') aufgrund neuer/re-evaluierter Wiki-Daten.") + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Chat Wiki Konsistenzpruefung"] + 1)}{row_num_in_sheet}', 'values': [['?']]}) + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Wiki Verif. Timestamp"] + 1)}{row_num_in_sheet}', 'values': [['']]}) + # Auch die abhängigen Spalten AD, AE leeren + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Chat Begründung Wiki Inkonsistenz"] + 1)}{row_num_in_sheet}', 'values': [['']]}) + updates.append({'range': f'{self.sheet_handler._get_col_letter(COLUMN_MAP["Chat Vorschlag Wiki Artikel"] + 1)}{row_num_in_sheet}', 'values': [['']]}) - if force_reeval or status_y_from_sheet == "X (URL COPIED)" or url_changed_and_is_valid_wiki_link: - y_idx = COLUMN_MAP.get("Chat Wiki Konsistenzpruefung") - w_idx = COLUMN_MAP.get("Wiki Verif. Timestamp") - if y_idx is not None and w_idx is not None: - y_let = self.sheet_handler._get_col_letter(y_idx + 1) - w_let = self.sheet_handler._get_col_letter(w_idx + 1) - updates.append({'range': f'{y_let}{row_num_in_sheet}', 'values': [["?"]]}) - updates.append({'range': f'{w_let}{row_num_in_sheet}', 'values': [[""]]}) # W (alt AX) leeren - # Grund für Reset loggen - reset_reason_parts = [] - if force_reeval: reset_reason_parts.append('Re-Eval') - if status_y_from_sheet == "X (URL COPIED)": reset_reason_parts.append("Y='X (URL Copied)'") - if url_changed_and_is_valid_wiki_link: reset_reason_parts.append('URL geändert und valide') - self.logger.info(f" -> Status Y ('Chat Wiki Konsistenzpruefung') zurueckgesetzt auf '?' und Timestamp W ('Wiki Verif. Timestamp') geleert (Grund: {', '.join(reset_reason_parts) or 'Unbekannt'}).") - else: - self.logger.error("FEHLER: Konnte Spaltenbuchstaben fuer Y oder W nicht ermitteln. Zuruecksetzen uebersprungen.") # else if run_wiki_step (aber nicht processing_needed_based_on_status): # self.logger.debug(f"Zeile {row_num_in_sheet}: Ueberspringe WIKI Suche/Extraktion (Timestamp V vorhanden, Y nicht 'X (URL Copied)' und kein Re-Eval).")