From 36fbbc073e78b65fdd2733b5621edbb608d258c8 Mon Sep 17 00:00:00 2001 From: Floke Date: Tue, 15 Apr 2025 13:55:16 +0000 Subject: [PATCH] bugfix --- brancheneinstufung.py | 229 ++++++++++++++++++++++++++++++++---------- 1 file changed, 176 insertions(+), 53 deletions(-) diff --git a/brancheneinstufung.py b/brancheneinstufung.py index 1f6586e5..5b899a4d 100644 --- a/brancheneinstufung.py +++ b/brancheneinstufung.py @@ -440,63 +440,186 @@ def fuzzy_similarity(str1, str2): # ==================== BRANCH MAPPING & SCHEMA ==================== -def load_branch_mapping(file_path=BRANCH_MAPPING_FILE): - """Lädt Mapping extern -> Ziel-Branche aus CSV.""" - mapping = {} - debug_print(f"Versuche, Mapping aus '{file_path}' zu laden...") # NEU - line_count = 0 # NEU - try: - with open(file_path, mode='r', encoding="utf-8") as f: - reader = csv.reader(f) - # Optional: Header überspringen, falls vorhanden - # try: # NEU - Sicher Header überspringen - # header = next(reader) - # debug_print(f"CSV Header übersprungen: {header}") - # except StopIteration: - # debug_print("CSV ist leer oder hat keinen Header.") - # return mapping - # except Exception as e_header: - # debug_print(f"Fehler beim Lesen des Headers: {e_header}") - # return mapping +import re # Sicherstellen, dass re importiert ist - for row in reader: - line_count += 1 # NEU - if line_count <= 10 or line_count % 100 == 0: # Logge die ersten 10 und dann jede 100. Zeile - debug_print(f"Lese Zeile {line_count}: {row}") # NEU +# Annahmen: +# - Die globalen Variablen ALLOWED_TARGET_BRANCHES und TARGET_SCHEMA_STRING werden +# durch load_target_schema() korrekt befüllt (enthalten nur Kurzformen). +# - Die Funktion call_openai_chat(prompt, temperature) existiert und funktioniert. +# - Die Funktion debug_print(message) existiert. +# - Die globale Variable Config.API_KEYS['openai'] ist verfügbar. - if len(row) >= 2: - # Spalte A: Externer Begriff (normalisiert) - anpassen, falls nur eine Spalte relevant ist - # Spalte B: Ziel-Branchenschema - dies sollte die Kurzform sein - # WICHTIG: Annehmen, dass die Kurzform jetzt in Spalte A steht, da kein externes Mapping mehr? - # ODER steht die Kurzform in Spalte B und Spalte A ist jetzt leer/irrelevant? - # --> ANNAHME: Die Kurzform steht jetzt in Spalte A (Index 0) und ist der Zielwert. - - # key = normalize_string(row[0].strip()).lower() # Alter Ansatz - # value = row[1].strip() # Alter Ansatz +def evaluate_branche_chatgpt(crm_branche, beschreibung, wiki_branche, wiki_kategorien, website_summary): + """ + Ordnet das Unternehmen basierend auf den angegebenen Informationen exakt einer Branche + aus dem Ziel-Branchenschema (nur Kurzformen) zu. Validiert den ChatGPT-Vorschlag + strikt gegen die erlaubten Kurzformen und führt einen Fallback auf die (extrahierte) + CRM-Kurzform durch, falls der Vorschlag ungültig ist. - # --> NEUER ANSATZ (Annahme: Kurzform in Spalte A): - target_branch = row[0].strip() - if target_branch: # Nur wenn nicht leer - # Wir brauchen kein Mapping mehr, nur die Liste der Ziele - # Also bauen wir das Set direkt auf - pass # Wird jetzt in load_target_schema erledigt - # --------- ENDE NEUER ANSATZ --------- + Args: + crm_branche (str): Branche laut CRM (kann noch Präfix enthalten). + beschreibung (str): Unternehmensbeschreibung (CRM). + wiki_branche (str): Branche aus Wikipedia (falls vorhanden). + wiki_kategorien (str): Wikipedia-Kategorien. + website_summary (str): Zusammenfassung des Website-Inhalts. + + Returns: + dict: Enthält "branch" (die finale, gültige Kurzform oder Fehler), + "consistency" ('ok', 'X', 'fallback_crm_valid', 'fallback_invalid') und + "justification" (Begründung von ChatGPT oder Fallback-Info). + """ + # Globale Variablen für Schema und erlaubte Branches verwenden + global ALLOWED_TARGET_BRANCHES, TARGET_SCHEMA_STRING + + # Grundlegende Prüfung: Ist das Schema überhaupt geladen? + if not ALLOWED_TARGET_BRANCHES: + debug_print("FEHLER in evaluate_branche_chatgpt: Ziel-Branchenschema (ALLOWED_TARGET_BRANCHES) ist leer. Abbruch.") + # Gib den CRM-Wert zurück, aber markiere als Fehler + return {"branch": crm_branche, "consistency": "error_schema_missing", "justification": "Fehler: Ziel-Schema nicht geladen"} + + # Erstelle ein Set/Dict der erlaubten Branches in Kleinbuchstaben für effizientes Nachschlagen + # Speichert die Originalschreibweise als Wert. + allowed_branches_lookup = {b.lower(): b for b in ALLOWED_TARGET_BRANCHES} + + # --- Prompt für ChatGPT erstellen --- + # Beginne mit den Regeln und der Liste der gültigen Kurzformen + prompt_parts = [TARGET_SCHEMA_STRING] # TARGET_SCHEMA_STRING sollte bereits die klare Anweisung enthalten + prompt_parts.append("\nOrdne das Unternehmen anhand folgender Angaben exakt einer Branche des Ziel-Branchenschemas (Kurzformen) zu:") + + # Füge nur vorhandene Informationen hinzu und kürze sie ggf. + if crm_branche and crm_branche != "k.A.": prompt_parts.append(f"- CRM-Branche (Referenz): {crm_branche}") + if beschreibung and beschreibung != "k.A.": prompt_parts.append(f"- Beschreibung: {beschreibung[:500]}") # Kürzen + if wiki_branche and wiki_branche != "k.A.": prompt_parts.append(f"- Wikipedia-Branche: {wiki_branche}") + if wiki_kategorien and wiki_kategorien != "k.A.": prompt_parts.append(f"- Wikipedia-Kategorien: {wiki_kategorien[:500]}") # Kürzen + if website_summary and website_summary != "k.A.": prompt_parts.append(f"- Website-Zusammenfassung: {website_summary[:500]}") # Kürzen + + # Fallback, wenn gar keine spezifischen Infos da sind + if len(prompt_parts) <= 2: + debug_print("Warnung in evaluate_branche_chatgpt: Zu wenige Informationen für Branchenevaluierung.") + return {"branch": crm_branche, "consistency": "error_no_info", "justification": "Fehler: Zu wenige Informationen für eine Einschätzung"} + + # Füge die strengen Anweisungen für das Antwortformat hinzu + prompt_parts.append("\nWICHTIG: Antworte NUR mit dem exakten Kurznamen einer Branche aus der obigen Liste. Verwende KEINE Präfixe wie 'Hersteller / Produzenten >' oder 'Service provider (Dienstleister) >'.") + prompt_parts.append("\nAntworte ausschließlich im folgenden Format (keine Einleitung, kein Schlusssatz):") + prompt_parts.append("Branche: ") + prompt_parts.append("Übereinstimmung: ") + prompt_parts.append("Begründung: ") + + prompt = "\n".join(prompt_parts) + + # --- ChatGPT aufrufen --- + chat_response = call_openai_chat(prompt, temperature=0.0) # Niedrige Temperatur für konsistente Zuordnung + + if not chat_response: + debug_print("Fehler in evaluate_branche_chatgpt: Keine Antwort von OpenAI erhalten.") + return {"branch": crm_branche, "consistency": "error_api_no_response", "justification": "Fehler: Keine Antwort von API"} + + # --- Antwort parsen --- + lines = chat_response.strip().split("\n") + result = {"branch": None, "consistency": None, "justification": ""} # Initialisiere mit None + suggested_branch = "" + for line in lines: + line_lower = line.lower() + if line_lower.startswith("branche:"): + suggested_branch = line.split(":", 1)[1].strip() + # Entferne mögliche Anführungszeichen + suggested_branch = suggested_branch.strip('"\'') + elif line_lower.startswith("übereinstimmung:"): + # Wir überschreiben die Konsistenz später basierend auf unserer Logik + pass + elif line_lower.startswith("begründung:"): + result["justification"] = line.split(":", 1)[1].strip() + + if not suggested_branch: + debug_print(f"Fehler in evaluate_branche_chatgpt: Konnte 'Branche:' nicht aus Antwort parsen: {chat_response}") + return {"branch": crm_branche, "consistency": "error_parsing", "justification": f"Fehler: Parsing der API Antwort fehlgeschlagen. Antwort: {chat_response}"} + + # --- Validierung des ChatGPT-Vorschlags --- + final_branch = None + suggested_branch_lower = suggested_branch.lower() + + if suggested_branch_lower in allowed_branches_lookup: + final_branch = allowed_branches_lookup[suggested_branch_lower] # Nimm korrekte Schreibweise + debug_print(f"ChatGPT-Branchenvorschlag '{suggested_branch}' ist gültig ('{final_branch}').") + # Konsistenz wird später gesetzt + result["consistency"] = "pending_comparison" # Temporärer Status + else: + # --- Fallback-Logik --- + debug_print(f"ChatGPT-Branchenvorschlag '{suggested_branch}' ist NICHT im Ziel-Schema ({len(ALLOWED_TARGET_BRANCHES)} Einträge) enthalten. Starte Fallback...") + + # Versuche Kurzform aus CRM-Branche zu extrahieren + crm_short_branch = "k.A." + if crm_branche and ">" in crm_branche: + crm_short_branch = crm_branche.split(">", 1)[1].strip() + elif crm_branche and crm_branche != "k.A.": # Wenn CRM schon Kurzform sein könnte + crm_short_branch = crm_branche.strip() + + # --- HIER DIE NEUEN DEBUG-AUSGABEN --- + debug_print(f"Fallback Debug: Prüfe CRM-Kurzform.") + debug_print(f" -> Extrahierte CRM-Kurzform: '{crm_short_branch}' (Typ: {type(crm_short_branch)})") + crm_short_branch_lower = crm_short_branch.lower() + debug_print(f" -> CRM-Kurzform (lower): '{crm_short_branch_lower}'") + # Zeige einige Lookup-Keys (nur wenn nicht zu viele) + lookup_keys_sample = list(allowed_branches_lookup.keys()) + if len(lookup_keys_sample) < 20: + debug_print(f" -> Prüfe gegen Lookup-Keys: {lookup_keys_sample}") + else: + debug_print(f" -> Prüfe gegen Lookup-Keys (erste 10): {lookup_keys_sample[:10]}") + # ------------------------------------- + + # Der eigentliche Check + if crm_short_branch != "k.A." and crm_short_branch_lower in allowed_branches_lookup: + debug_print(f" -> ERFOLG: '{crm_short_branch_lower}' in allowed_branches_lookup gefunden!") # NEU + final_branch = allowed_branches_lookup[crm_short_branch_lower] # Nimm korrekte Schreibweise + result["consistency"] = "fallback_crm_valid" # Setze Fallback-Status + # Kombiniere ChatGPT Begründung (falls vorhanden) mit Fallback-Info + fallback_reason = f"Fallback: Ungültiger ChatGPT-Vorschlag ('{suggested_branch}'). Gültige CRM-Kurzform '{final_branch}' verwendet." + result["justification"] = f"{fallback_reason} (ChatGPT Begründung war: {result.get('justification', 'Keine')})" + debug_print(f"Fallback auf gültige CRM-Kurzform erfolgreich: '{final_branch}'") + else: + debug_print(f" -> FEHLER: '{crm_short_branch_lower}' NICHT in allowed_branches_lookup gefunden!") # NEU + # Wenn auch CRM-Kurzform ungültig oder nicht extrahierbar + final_branch = suggested_branch # Behalte ungültigen Vorschlag + result["consistency"] = "fallback_invalid" # Setze Fehler-Fallback-Status + error_reason = f"Fehler: Ungültiger ChatGPT-Vorschlag ('{suggested_branch}') und keine gültige CRM-Kurzform ('{crm_short_branch}') als Fallback verfügbar." + result["justification"] = f"{error_reason} (ChatGPT Begründung war: {result.get('justification', 'Keine')})" + debug_print(f"Fallback fehlgeschlagen. Ungültiger Vorschlag: '{final_branch}', Ungültige CRM-Kurzform: '{crm_short_branch}'") + # Alternativ: Gib einen speziellen Fehlerwert zurück + # final_branch = "FEHLER - UNGÜLTIGE ZUWEISUNG" + + # Setze den finalen Branch im Ergebnis-Dictionary + result["branch"] = final_branch if final_branch else "FEHLER" + + # --- Konsistenzprüfung (Finale Bewertung) --- + # Extrahiere CRM-Kurzform für den Vergleich (erneut oder Variable von oben) + crm_short_to_compare = "k.A." + if crm_branche and ">" in crm_branche: + crm_short_to_compare = crm_branche.split(">", 1)[1].strip() + elif crm_branche and crm_branche != "k.A.": + crm_short_to_compare = crm_branche.strip() + + # Vergleiche finalen Branch (falls nicht FEHLER) mit CRM-Kurzform (case-insensitive) + if result["branch"] != "FEHLER" and result["branch"].lower() == crm_short_to_compare.lower(): + # Wenn sie übereinstimmen UND *kein* Fallback stattgefunden hat, ist es 'ok'. + if result["consistency"] == "pending_comparison": + result["consistency"] = "ok" + # Wenn Fallback auf gültige CRM stattfand (Status 'fallback_crm_valid'), bleibt dieser Status. + elif result["consistency"] == "pending_comparison": + # Wenn sie nicht übereinstimmen und kein Fallback stattfand, ist es 'X'. + result["consistency"] = "X" + # Wenn der Status bereits 'fallback_crm_valid' oder 'fallback_invalid' ist, bleibt er unverändert. + elif result["consistency"] is None: # Sollte nicht passieren, aber zur Sicherheit + result["consistency"] = "error_unknown_state" - # if key and value: # Alter Ansatz - # if key in mapping: - # debug_print(f"Warnung: Doppelter Mapping-Key '{key}' in {file_path}. Wert '{mapping[key]}' wird mit '{value}' überschrieben.") - # mapping[key] = value - except FileNotFoundError: - debug_print(f"Fehler: Branchen-Mapping-Datei '{file_path}' nicht gefunden.") - return {} # Leeres Mapping zurückgeben - except Exception as e: - debug_print(f"Fehler beim Laden des Branchen-Mappings aus '{file_path}' (Zeile {line_count}): {e}") - return {} # Leeres Mapping zurückgeben - # debug_print(f"Mapping erfolgreich geladen. {len(mapping)} Einträge gefunden nach {line_count} gelesenen Zeilen.") # Alt - # return mapping # Alt - # Die Funktion lädt jetzt nichts mehr, load_target_schema erledigt das - return {} + # Entferne den temporären Status, falls er noch da ist + if result["consistency"] == "pending_comparison": + result["consistency"] = "error_comparison_failed" + + # Debug-Ausgabe des finalen Ergebnisses vor Rückgabe + debug_print(f"Finale Branch-Evaluation: {result}") + + return result def load_target_schema(csv_filepath=BRANCH_MAPPING_FILE): """Lädt Liste erlaubter Ziele (Kurzformen) aus Spalte A der CSV.""" @@ -508,7 +631,7 @@ def load_target_schema(csv_filepath=BRANCH_MAPPING_FILE): debug_print(f"Versuche, Ziel-Schema (Kurzformen) aus '{csv_filepath}' Spalte A zu laden...") # NEU line_count = 0 try: - with open(csv_filepath, encoding="utf-8") as f: + with open(csv_filepath, encoding="utf-8-sig") as f: reader = csv.reader(f) # Optional: Header überspringen # next(reader, None)