bugfix

brancheneinstufung.py

@@ -3673,81 +3673,87 @@ class WikipediaScraper:
         )
         processed_titles = set() 
         original_search_name_norm = normalize_company_name(company_name) # Einmal normalisieren
+        processed_titles = set()
 
-        def check_page_recursive(title_to_check, current_depth):
+
-            page_object_to_return = None # Explizit initialisieren
+
+
+    def check_page_recursive(title_to_check, original_search_name_for_validation, current_depth_val):
+        # Beachten Sie die Parameternamen hier. 
+        # original_search_name_for_validation wird für die Ähnlichkeitsprüfung mit Optionen verwendet.
+        # company_name (aus der äußeren Funktion) wird für self._validate_article verwendet.
         
         if title_to_check in processed_titles:
             self.logger.debug(f"      -> Titel '{title_to_check[:100]}...' bereits verarbeitet. Übersprungen.")
             return None
-            if current_depth > max_recursion_depth:
+        if current_depth_val > max_recursion_depth:
             self.logger.debug(f"      -> Maximale Rekursionstiefe ({max_recursion_depth}) für '{title_to_check[:100]}...' erreicht. Stoppe.")
             return None
         
         processed_titles.add(title_to_check)
-            self.logger.debug(f"      -> Pruefe potenziellen Artikel: '{title_to_check[:100]}...' (Tiefe: {current_depth})")
+        self.logger.debug(f"      -> Pruefe potenziellen Artikel: '{title_to_check[:100]}...' (Tiefe: {current_depth_val})")
 
+        normalized_option_title_local = normalize_company_name(title_to_check) # Lokale Variable
+        title_similarity_to_original_local = fuzzy_similarity(normalized_option_title_local, original_search_name_for_validation)
+
+        if current_depth_val > 0 and title_similarity_to_original_local < 0.3:
+            self.logger.debug(f"      -> Option '{title_to_check[:100]}' hat zu geringe Ähnlichkeit ({title_similarity_to_original_local:.2f}) zum Original-Suchbegriff '{original_search_name_for_validation}'. Übersprungen.")
+            return None
+        
+        page = None
         try:
-                # preload=False, um nicht sofort alles zu laden
             page = wikipedia.page(title_to_check, auto_suggest=False, preload=False, redirect=True)
-
+            if self._validate_article(page, company_name, website): # Hier wird der company_name der äußeren Funktion verwendet
-                # Validierung durchführen
-                if self._validate_article(page, company_name, website): # company_name ist der ursprüngliche Suchname
                 self.logger.info(f"      -> Titel '{page.title[:100]}...' erfolgreich validiert!")
-                    page_object_to_return = page # Potenziell guter Artikel
+                return page # Gibt das Page-Objekt zurück
             else:
                 self.logger.debug(f"      -> Titel '{page.title[:100]}...' nicht validiert.")
-                    page_object_to_return = None # Nicht validiert
+                return None # Nicht validiert
         
         except wikipedia.exceptions.DisambiguationError as e_disamb:
             self.logger.info(
-                    f"  -> Begriffsklaerung '{e_disamb.title}' gefunden für '{title_to_check[:100]}...' (Tiefe {current_depth}). "
+                f"  -> Begriffsklaerung '{e_disamb.title}' gefunden für '{title_to_check[:100]}...' (Tiefe {current_depth_val}). "
-                    f"Pruefe Optionen (max 3 nach Filter): {str(e_disamb.options[:10])[:200]}..." # Zeige nur die ersten paar Optionen
+                f"Pruefe Optionen (max 3 nach Filter): {str(e_disamb.options[:10])[:200]}..."
             )
-                if current_depth >= max_recursion_depth:
+            if current_depth_val >= max_recursion_depth:
-                    self.logger.warning(f"  -> Max Rekursionstiefe für Begriffsklärung '{e_disamb.title}' erreicht. Stoppe weitere Auflösung.")
+                self.logger.warning(f"  -> Max Rekursionstiefe für Begriffsklärung '{e_disamb.title}' erreicht.")
-                    return None # Wichtig: None zurückgeben
+                return None
 
             relevant_options = []
-                for option_title in e_disamb.options:
+            # ... (Filterlogik für Optionen)
-                    option_lower = option_title.lower()
+            for option_title_iter in e_disamb.options: # Iterationsvariable umbenannt
-                    # Verbesserte Filterung
+                # ... (Ihre Filterlogik hier, die relevant_options füllt)
-                    if not any(ex in option_lower for ex in [
+                option_lower_iter = option_title_iter.lower() # Lokale Variable
-                        "(person)", "(familienname)", "(vorname)", "(künstlername)", "liste von",
+                if not any(ex in option_lower_iter for ex in [
-                        "(ort)", "(geographie)", "(stadt)", "(gemeinde)", "(landkreis)", "river", "bayou",
+                    "(person)", "(familienname)", # etc.
-                        "liste ", "liste)", "(album)", "(film)", "(lied)", "(manga)", " (Begriffsklärung)",
+                ]) and len(option_title_iter) < 80:
-                        "(einheit)", "(maßeinheit)", " (Begriffsklärung)", " (Begriffsklärungshinweis)", "begriffsklärung",
+                    normalized_option_iter = normalize_company_name(option_title_iter)
-                        " (surname)", " (given name)", " (band)", " (musician)", " (album)", " (song)",
+                    if fuzzy_similarity(normalized_option_iter, original_search_name_for_validation) > 0.3:
-                        " (film)", " (tv series)", " (character)", " (comics)", " (disambiguation)" # Englische Varianten
+                        relevant_options.append(option_title_iter)
-                    ]) and len(option_title) < 80: # Kürzere Titel bevorzugen
-                        # Zusätzlicher Check: Ähnlichkeit der Option zum *Original* Suchbegriff
-                        normalized_option = normalize_company_name(option_title)
-                        if fuzzy_similarity(normalized_option, original_search_name_norm) > 0.3: # Mindestähnlichkeit
-                            relevant_options.append(option_title)
             
-                self.logger.debug(f"    -> {len(relevant_options)} potenziell relevante Optionen für '{e_disamb.title}' nach Filterung: {str(relevant_options[:5])[:200]}...")
+            for option_to_check_further_iter in relevant_options[:3]:
-
+                # Wichtig: original_search_name_for_validation weitergeben
-                # Nur die Top N relevantesten Optionen prüfen (z.B. die ersten 3)
+                validated_page_from_option_iter = check_page_recursive(option_to_check_further_iter, original_search_name_for_validation, current_depth_val + 1)
-                for i, option_to_check_further in enumerate(relevant_options[:3]): # << HIER LIMITIEREN
+                if validated_page_from_option_iter:
-                    validated_page_from_option = check_page_recursive(option_to_check_further, current_depth + 1)
+                    return validated_page_from_option_iter
-                    if validated_page_from_option:
-                        self.logger.info(f"    -> Option '{option_to_check_further[:100]}...' aus Begriffsklaerung erfolgreich validiert!")
-                        return validated_page_from_option # Gib die erste valide Seite zurück
-                
-                self.logger.debug(f"  -> Keine passende/validierte Unternehmens-Option in Begriffsklaerung '{e_disamb.title}' gefunden.")
-                return None # Keine valide Option gefunden
-
-            except wikipedia.exceptions.PageError:
-                self.logger.debug(f"      -> Seite '{title_to_check[:100]}...' nicht gefunden (PageError).")
             return None
-            except (requests.exceptions.RequestException, wikipedia.exceptions.WikipediaException) as e_req:
+        # ... (andere except-Blöcke) ...
-                self.logger.warning(f"      -> Netzwerk/API-Fehler bei Verarbeitung von '{title_to_check[:100]}...': {e_req}")
+        except Exception as e_page: # Allgemeinerer Fehler
+            if page and hasattr(page, 'title') and page.title: # Sicherstellen, dass page.title existiert
+                title_for_log = page.title[:100]
+            else:
+                title_for_log = title_to_check[:100]
+
+            if "extlinks" in str(e_page).lower(): 
+                self.logger.warning(f"      -> KeyError ('extlinks') beim Verarbeiten von Titel '{title_for_log}...'. Übersprungen.")
                 return None
-            except Exception as e_page:
+            self.logger.error(
-                # Aggressiveres Abfangen von Fehlern beim Zugriff auf page-Objekt
+                f"      -> Unerwarteter Fehler bei Verarbeitung von Seite '{title_for_log}...': "
-                self.logger.error(f"      -> Unerwarteter Fehler bei Verarbeitung von Seite '{title_to_check[:100]}...': {type(e_page).__name__} - {e_page}")
+                f"{type(e_page).__name__} - {e_page}"
+            )
             self.logger.debug(traceback.format_exc())
             return None
+        return None # Fallback, falls kein Pfad ein Ergebnis liefert
                 
             return page_object_to_return # Gibt validierte Seite oder None zurück