diff --git a/brancheneinstufung.py b/brancheneinstufung.py index 4a457678..a61437a3 100644 --- a/brancheneinstufung.py +++ b/brancheneinstufung.py @@ -1004,11 +1004,19 @@ class GoogleSheetHandler: return self.sheet_values # Angepasste Methode, um den Startindex basierend auf einer spezifischen Spalte zu finden - def get_start_row_index(self, check_column_index=COLUMN_MAP["Website Scrape Timestamp"], min_sheet_row=7): + def get_start_row_index(self, check_column_index, min_sheet_row=7): # Entferne Standardwert hier """ Findet den Index der ersten Zeile (0-basiert für Daten nach Header), ab einer Mindestzeilennummer im Sheet, in der der Timestamp in der angegebenen Spalte fehlt. + + Args: + check_column_index (int): Der 0-basierte Index der zu prüfenden Spalte. + min_sheet_row (int): Die 1-basierte Zeilennummer im Sheet, ab der gesucht werden soll. + + Returns: + int: Der 0-basierte Index in der Datenliste (ohne Header), + oder der Index nach der letzten Zeile, wenn alle gefüllt sind. """ header_rows = 5 data_rows = self.get_data() @@ -1019,25 +1027,36 @@ class GoogleSheetHandler: search_start_index_in_data = max(0, min_sheet_row - header_rows - 1) - # Stelle sicher, dass der Startindex nicht außerhalb der Liste liegt + # DEBUG: Logge, welche Spalte tatsächlich geprüft wird + actual_col_letter = self._get_col_letter(check_column_index + 1) + debug_print(f"get_start_row_index: Suche ab Daten-Index {search_start_index_in_data} nach leerem Timestamp in Spalte {actual_col_letter} (Index {check_column_index}).") + if search_start_index_in_data >= len(data_rows): - col_letter = self._get_col_letter(check_column_index + 1) - debug_print(f"Start-Suchindex ({search_start_index_in_data}) liegt nach der letzten Datenzeile ({len(data_rows)-1}). Suche ab letzter Zeile für Spalte {col_letter}.") - search_start_index_in_data = len(data_rows) -1 # Beginne bei der letzten Zeile falls Start zu weit - if search_start_index_in_data < 0: return 0 # Falls gar keine Datenzeilen + debug_print(f"Start-Suchindex ({search_start_index_in_data}) liegt nach oder auf letzter Datenzeile ({len(data_rows)-1}).") + # Prüfe die *letzte* Zeile, falls der Index genau darauf zeigt + if search_start_index_in_data == len(data_rows) -1: + last_row = data_rows[search_start_index_in_data] + if len(last_row) <= check_column_index or not last_row[check_column_index].strip(): + debug_print(f"Letzte Zeile (Daten-Index {search_start_index_in_data}) hat keinen Timestamp in Spalte {actual_col_letter}. Starte hier.") + return search_start_index_in_data + # Ansonsten sind alle vorherigen gefüllt + debug_print(f"Alle Zeilen ab Zeile {min_sheet_row} scheinen einen Zeitstempel in Spalte {actual_col_letter} zu haben. Nächster Daten-Index wäre {len(data_rows)}.") + return len(data_rows) for i, row in enumerate(data_rows[search_start_index_in_data:], start=search_start_index_in_data): - # Sicherheitscheck für Zeilenlänge + # DEBUG: Logge den geprüften Wert für die ersten paar Iterationen + # if i < search_start_index_in_data + 5: + # checked_value = row[check_column_index].strip() if len(row) > check_column_index else "INDEX_FEHLER" + # debug_print(f" -> Prüfe Zeile {i + header_rows + 1}: Wert in Spalte {actual_col_letter} = '{checked_value}'") + if len(row) <= check_column_index or not row[check_column_index].strip(): actual_sheet_row = i + header_rows + 1 - col_letter = self._get_col_letter(check_column_index + 1) - debug_print(f"Erste Zeile ab Zeile {min_sheet_row} ohne Zeitstempel in Spalte {col_letter} (Index {check_column_index}) gefunden: Zeile {actual_sheet_row} (Daten-Index {i})") + debug_print(f"Erste Zeile ab Zeile {min_sheet_row} ohne Zeitstempel in Spalte {actual_col_letter} (Index {check_column_index}) gefunden: Zeile {actual_sheet_row} (Daten-Index {i})") return i last_index = len(data_rows) - col_letter = self._get_col_letter(check_column_index + 1) - debug_print(f"Alle Zeilen ab Zeile {min_sheet_row} haben einen Zeitstempel in Spalte {col_letter}. Nächster Daten-Index wäre {last_index}.") + debug_print(f"Alle Zeilen ab Zeile {min_sheet_row} haben einen Zeitstempel in Spalte {actual_col_letter}. Nächster Daten-Index wäre {last_index}.") return last_index def _get_col_letter(self, col_idx): @@ -2104,7 +2123,18 @@ def process_website_batch(sheet_handler, start_row_index_in_sheet, end_row_index all_data = sheet_handler.get_all_data_with_headers() sheet = sheet_handler.sheet - timestamp_col_index = COLUMN_MAP["Website Scrape Timestamp"] # Prüfe Spalte AT + # HIER KORRIGIERT: Sicherstellen, dass der Index für AT verwendet wird + timestamp_col_index = COLUMN_MAP.get("Website Scrape Timestamp") + website_col_index = COLUMN_MAP.get("CRM Website") + rohtext_col_index = COLUMN_MAP.get("Website Rohtext") + summary_col_index = COLUMN_MAP.get("Website Zusammenfassung") + version_col_index = COLUMN_MAP.get("Version") + + # Fehlerprüfung für Indizes + if None in [timestamp_col_index, website_col_index, rohtext_col_index, summary_col_index, version_col_index]: + debug_print("FEHLER: Mindestens ein benötigter Spaltenindex für process_website_batch fehlt in COLUMN_MAP.") + return + processed_count = 0 skipped_count = 0 @@ -2113,46 +2143,55 @@ def process_website_batch(sheet_handler, start_row_index_in_sheet, end_row_index if row_index_in_list >= len(all_data): continue row = all_data[row_index_in_list] - # --- NEU: Timestamp-Prüfung für jede Zeile --- + # --- KORRIGIERTE Timestamp-Prüfung für jede Zeile --- if len(row) > timestamp_col_index and row[timestamp_col_index].strip(): - debug_print(f"Zeile {i}: Überspringe Website-Scraping (Timestamp AT bereits vorhanden: '{row[timestamp_col_index]}').") + # Optional: Weniger Lärm im Log, nur alle X Zeilen loggen + # if skipped_count % 100 == 0: + # debug_print(f"Zeile {i}: Überspringe Website-Scraping (Timestamp AT vorhanden: '{row[timestamp_col_index]}')...") skipped_count += 1 continue # --- Ende Timestamp-Prüfung --- - website_url = row[COLUMN_MAP["CRM Website"]] if len(row) > COLUMN_MAP["CRM Website"] else "" + website_url = row[website_col_index] if len(row) > website_col_index else "" if not website_url or website_url.strip().lower() == "k.a.": - debug_print(f"Zeile {i}: Kein gültiger Website-Eintrag, überspringe Website-Scraping.") - # Optional: Zeitstempel trotzdem setzen als "geprüft, keine URL"? Eher nicht. - skipped_count += 1 # Zähle als übersprungen + # debug_print(f"Zeile {i}: Kein gültiger Website-Eintrag, überspringe Website-Scraping.") + skipped_count += 1 continue - debug_print(f"Zeile {i}: Verarbeite Website {website_url}...") + # debug_print(f"Zeile {i}: Verarbeite Website {website_url}...") # Weniger Lärm raw_text = get_website_raw(website_url) - summary = summarize_website_content(raw_text) # Braucht OpenAI Key + summary = summarize_website_content(raw_text) processed_count += 1 updates = [] current_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") current_version = Config.VERSION - updates.append({'range': f'AR{i}', 'values': [[raw_text]]}) # Spalte AR - updates.append({'range': f'AS{i}', 'values': [[summary]]}) # Spalte AS - updates.append({'range': f'AT{i}', 'values': [[current_timestamp]]}) # Spalte AT (NEU) - updates.append({'range': f'AP{i}', 'values': [[current_version]]}) # Spalte AP (Version) - # AO (Letzte Prüfung) wird hier *nicht* gesetzt, das macht der Branch- oder Full-Run + # Spaltenbuchstaben für die Ranges ermitteln + rohtext_col_letter = sheet_handler._get_col_letter(rohtext_col_index + 1) + summary_col_letter = sheet_handler._get_col_letter(summary_col_index + 1) + ts_col_letter = sheet_handler._get_col_letter(timestamp_col_index + 1) + version_col_letter = sheet_handler._get_col_letter(version_col_index + 1) + + updates.append({'range': f'{rohtext_col_letter}{i}', 'values': [[raw_text]]}) + updates.append({'range': f'{summary_col_letter}{i}', 'values': [[summary]]}) + updates.append({'range': f'{ts_col_letter}{i}', 'values': [[current_timestamp]]}) # AT Timestamp + updates.append({'range': f'{version_col_letter}{i}', 'values': [[current_version]]}) # AP Version # Führe Batch-Update für diese eine Zeile durch if updates: - sheet_handler.batch_update_cells(updates) - # Weniger Lärm im Log: debug_print(f"Zeile {i}: Website-Daten aktualisiert | Zeitstempel AT: {current_timestamp}, Version: {current_version}") + success = sheet_handler.batch_update_cells(updates) + if not success: + debug_print(f"FEHLER beim Schreiben der Updates für Zeile {i}.") + # Weniger Lärm im Log bei Erfolg: + # else: debug_print(f"Zeile {i}: Website-Daten aktualisiert...") + # Pause zwischen den Zeilen/Websites time.sleep(Config.RETRY_DELAY) debug_print(f"Website-Scraping (Batch) abgeschlossen. {processed_count} Websites gescraped, {skipped_count} Zeilen übersprungen.") - # Komplette Funktion process_branch_batch (prüft jetzt Timestamp AO) def process_branch_batch(sheet_handler, start_row_index_in_sheet, end_row_index_in_sheet): """Batch-Prozess für Brancheneinschätzung."""