Brancheneinstufung2/knowledge_base_builder.py

# knowledge_base_builder.py

__version__ = "v1.1.0"

import logging
import json
import re
from collections import Counter
import pandas as pd

from google_sheet_handler import GoogleSheetHandler
from config import Config

# --- Konfiguration ---
SOURCE_SHEET_NAME = "CRM_Jobtitles"
EXACT_MATCH_OUTPUT_FILE = "exact_match_map.json"
KEYWORD_RULES_OUTPUT_FILE = "keyword_rules.json"

DEPARTMENT_PRIORITIES = {
    # --- Tier 1: Ultra-spezifische Nischen (höchste Priorität) ---
    "Fuhrparkmanagement": 1,
    "Legal": 1,
    "Baustofflogistik": 1,
    "Baustoffherstellung": 1,
    
    # --- Tier 2: Kern-Fachbereiche (sortiert nach Kontakthäufigkeit) ---
    "Field Service Management / Kundenservice": 2,
    "IT": 3,
    "Production Maintenance / Wartung Produktion": 4,
    "Utility Maintenance": 5,
    "Procurement / Einkauf": 6,
    "Supply Chain Management": 7,
    "Finanzen": 8,
    "Technik": 8,
    
    # --- Tier 3: Übergreifende & Allgemeine Funktionen ---
    "Management / GF / C-Level": 10,
    "Logistik": 11,
    "Vertrieb": 12,
    "Transportwesen": 13,
    
    # --- Tier 4: Auffang-Kategorien (niedrigste Priorität) ---
    "Berater": 20,
    "Undefined": 99
}

# NEU: Definition von Branchen-Gruppen für die kontextsensitive Regelerstellung
# Key: Ein einfaches, normalisiertes Schlüsselwort für die Gruppe
# Value: Eine Liste von d365_branch_detail Werten aus Ihrer config.py
BRANCH_GROUP_RULES = {
    "bau": [
        "Baustoffhandel", "Baustoffindustrie", 
        "Logistiker Baustoffe", "Bauunternehmen"
    ],
    "versorger": [
        "Stadtwerke", "Verteilnetzbetreiber", 
        "Telekommunikation", "Gase & Mineralöl"
    ],
    "produktion": [
        "Maschinenbau", "Automobil", "Anlagenbau", "Medizintechnik",
        "Chemie & Pharma", "Elektrotechnik", "Lebensmittelproduktion",
        "Bürotechnik", "Automaten (Vending, Slot)", "Gebäudetechnik Allgemein",
        "Braune & Weiße Ware", "Fenster / Glas", "Getränke", "Möbel", "Agrar, Pellets"
    ]
}
# Schwellenwert: Wenn >X% der Jobtitel eines Departments in einer Branchengruppe liegen, wird es spezifisch
BRANCH_SPECIFICITY_THRESHOLD = 0.8 

STOP_WORDS = {
    'manager', 'leiter', 'head', 'lead', 'senior', 'junior', 'direktor', 'director',
    'verantwortlicher', 'beauftragter', 'referent', 'sachbearbeiter', 'mitarbeiter',
    'spezialist', 'specialist', 'expert', 'experte', 'consultant', 'berater',
    'assistant', 'assistenz', 'teamleiter', 'teamlead', 'abteilungsleiter',
    'bereichsleiter', 'gruppenleiter', 'geschäftsführer', 'vorstand', 'ceo', 'cio',
    'cfo', 'cto', 'coo', 'von', 'of', 'und', 'für', 'der', 'die', 'das', '&'
}


def build_knowledge_base():
    """
    Hauptfunktion zur Erstellung der Wissensbasis.
    Liest Rohdaten, analysiert sie und erstellt JSON-Dateien für exakte und Keyword-basierte Übereinstimmungen.
    Erstellt automatisch Regeln für branchenspezifische Departments.
    """
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
    logger = logging.getLogger(__name__)
    logger.info(f"Starte Erstellung der Wissensbasis (Version {__version__})...")

    gsh = GoogleSheetHandler()
    df = gsh.get_sheet_as_dataframe(SOURCE_SHEET_NAME)

    if df is None or df.empty:
        logger.critical(f"Konnte keine Daten aus '{SOURCE_SHEET_NAME}' laden oder das Tabellenblatt ist leer. Abbruch.")
        return
        
    df.columns = [col.strip() for col in df.columns]
    
    required_cols = ["Job Title", "Department", "Branche"]
    if not all(col in df.columns for col in required_cols):
        logger.critical(f"Benötigte Spalten {required_cols} nicht in '{SOURCE_SHEET_NAME}' gefunden. Abbruch.")
        return

    logger.info(f"{len(df)} Zeilen aus '{SOURCE_SHEET_NAME}' geladen.")
    
    df.dropna(subset=required_cols, inplace=True)
    df = df[df["Job Title"].str.strip() != '']
    df['normalized_title'] = df['Job Title'].str.lower().str.strip()
    logger.info(f"{len(df)} Zeilen nach Bereinigung.")

    logger.info("Erstelle 'Primary Mapping' für exakte Treffer (Stufe 1)...")
    exact_match_map = df.groupby('normalized_title')['Department'].apply(lambda x: x.mode()[0]).to_dict()
    try:
        with open(EXACT_MATCH_OUTPUT_FILE, 'w', encoding='utf-8') as f:
            json.dump(exact_match_map, f, indent=4, ensure_ascii=False)
        logger.info(f"-> '{EXACT_MATCH_OUTPUT_FILE}' mit {len(exact_match_map)} einzigartigen Jobtiteln erfolgreich erstellt.")
    except IOError as e:
        logger.error(f"Fehler beim Schreiben der Datei '{EXACT_MATCH_OUTPUT_FILE}': {e}")
        return

    logger.info("Erstelle 'Keyword-Datenbank' mit automatischer Branchen-Logik (Stufe 2)...")
    
    titles_by_department = df.groupby('Department')['normalized_title'].apply(list).to_dict()
    branches_by_department = df.groupby('Department')['Branche'].apply(list).to_dict()
    
    keyword_rules = {}
    for department, titles in titles_by_department.items():
        all_words = []
        for title in titles:
            words = re.split(r'[\s/(),-]+', title)
            all_words.extend([word for word in words if word])

        word_counts = Counter(all_words)
        top_keywords = [word for word, count in word_counts.most_common(50) if word not in STOP_WORDS and (len(word) > 2 or word in {'it', 'edv'})]

        if top_keywords:
            rule = {
                "priority": DEPARTMENT_PRIORITIES.get(department, 99),
                "keywords": sorted(top_keywords)
            }
            
            department_branches = branches_by_department.get(department, [])
            total_titles_in_dept = len(department_branches)
            
            if total_titles_in_dept > 10: # Mindestanzahl an Datenpunkten, um eine Regel zu erstellen
                branch_group_counts = Counter()
                for branch_name in department_branches:
                    for group_keyword, d365_names in BRANCH_GROUP_RULES.items():
                        if branch_name in d365_names:
                            branch_group_counts[group_keyword] += 1
                
                if branch_group_counts:
                    most_common_group, count = branch_group_counts.most_common(1)[0]
                    if (count / total_titles_in_dept) > BRANCH_SPECIFICITY_THRESHOLD:
                        logger.info(f"  -> Department '{department}' ist spezifisch für Branche '{most_common_group}' ({count/total_titles_in_dept:.0%}). Regel wird hinzugefügt.")
                        rule["required_branch_keywords"] = [most_common_group]

            keyword_rules[department] = rule

    try:
        with open(KEYWORD_RULES_OUTPUT_FILE, 'w', encoding='utf-8') as f:
            json.dump(keyword_rules, f, indent=4, ensure_ascii=False)
        logger.info(f"-> '{KEYWORD_RULES_OUTPUT_FILE}' mit Regeln für {len(keyword_rules)} Departments erfolgreich erstellt.")
    except IOError as e:
        logger.error(f"Fehler beim Schreiben der Datei '{KEYWORD_RULES_OUTPUT_FILE}': {e}")
        return
        
    logger.info("Wissensbasis erfolgreich erstellt.")


if __name__ == "__main__":
    build_knowledge_base()