fix tab 4

app.py

@@ -2,7 +2,7 @@ import logging
 import os
 
 logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.DEBUG)
 
 import gradio as gr
 import torah
@@ -721,6 +721,9 @@ with gr.Blocks() as app:
             include_tripitaka_chk_els = gr.Checkbox(label="Include Tripitaka", value=False)
         with gr.Row():
             translate_results_chk_els = gr.Checkbox(label="Translate Results to English", value=False)
+        with gr.Row():
+            sub_oscillation_search_chk_els = gr.Checkbox(label="Search in Sub-Oscillations", value=False) # Neue Checkbox
+            sub_oscillation_level_els = gr.Number(label="Sub-Oscillation Level (0 = off)", precision=0, value=1)
 
         with gr.Row():
             perform_search_btn_els = gr.Button("Perform Search")
@@ -741,7 +744,177 @@ with gr.Blocks() as app:
         )
 
         # Hauptfunktion für den vierten Tab
-        def perform_date_range_els_search(start_date, end_date, names_input, search_type, search_term, gematria_sum_search, search_mode, include_torah, include_bible, include_quran, include_hindu, include_tripitaka, translate_results):
+        def perform_date_range_els_search(start_date, end_date, names_input, search_type, search_term, gematria_sum_search, search_mode, include_torah, include_bible, include_quran, include_hindu, include_tripitaka, translate_results, sub_oscillation_search, sub_oscillation_level):
+            names = [n.strip() for n in names_input.split("\n") if n.strip()]
+            date_gematrias = perform_gematria_calculation_for_date_range(start_date, end_date)
+            search_term = strip_diacritics(search_term)
+            # Zwischenergebnisse mit Datum, Namen und Gematria-Summe speichern
+            intermediate_results = []
+            for date_str, date_data in date_gematrias.items():
+                for name in names:
+                    name_gematria = calculate_gematria_sum(name, "")
+                    combined_gematria_sum = date_data["date_gematria"] + name_gematria
+                    intermediate_results.append(
+                        {"date": date_str, "name": name, "gematria_sum": combined_gematria_sum}
+                    )
+
+            # Ergebnisse nach Datum sortieren
+            intermediate_results.sort(key=lambda x: x["date"])
+
+            all_results = []
+            for intermediate_result in intermediate_results:
+                date_str = intermediate_result["date"]
+                name = intermediate_result["name"]
+                initial_gematria_sum = intermediate_result["gematria_sum"]
+
+                # Basis-Suche durchführen
+                base_results = perform_els_search_for_gematria_sum(
+                    initial_gematria_sum, include_torah, include_bible, include_quran, include_hindu, include_tripitaka
+                )
+
+                # Nur ausgewählte Bücher für die Sub-Oszillationen-Suche berücksichtigen
+                selected_books_results = {}
+                if include_torah:
+                    selected_books_results["Torah"] = base_results.get("Torah", [])
+                if include_bible:
+                    selected_books_results["Bible"] = base_results.get("Bible", [])
+                if include_quran:
+                    selected_books_results["Quran"] = base_results.get("Quran", [])
+                if include_hindu:
+                    selected_books_results["Rig Veda"] = base_results.get("Rig Veda", [])
+                if include_tripitaka:
+                    selected_books_results["Tripitaka"] = base_results.get("Tripitaka", [])
+
+                # Speichere die base_results in einer Liste
+                base_results_list = []
+                for book_name, book_results in selected_books_results.items():
+                    for result in book_results:
+                        base_results_list.append({'book': book_name, 'result': result})
+
+                # Sub-Oszillationen-Suche, falls aktiviert und Level > 0
+                if sub_oscillation_search and sub_oscillation_level > 0:
+                    base_results_list = perform_sub_oscillation_search(
+                        base_results_list, initial_gematria_sum, sub_oscillation_level,
+                        include_torah, include_bible, include_quran, include_hindu, include_tripitaka
+                    )
+
+                # Umwandlung der erweiterten base_results_list in base_results
+                base_results = {}
+                for result_entry in base_results_list:
+                    book_name = result_entry['book']
+                    if book_name not in base_results:
+                        base_results[book_name] = []
+                    base_results[book_name].append(result_entry['result'])
+
+                # Filterung und Hinzufügen der Ergebnisse zu all_results
+                filtered_results = filter_and_format_results(
+                    base_results, search_type, search_term, gematria_sum_search,
+                    search_mode, date_str, name, initial_gematria_sum, sub_oscillation_level, base_results_list
+                )
+                all_results.extend(filtered_results)
+
+            # Übersetzung der Ergebnisse, falls angefordert
+            if translate_results:
+                for result_entry in all_results:
+                    try:
+                        text_to_translate = result_entry["result"]["result_text"]
+                        source_lang = result_entry["result"].get("source_language", "auto")
+                        translated_text = translation_utils.get_translation(text_to_translate, "en", source_lang)[0]
+                        result_entry["result"]["translated_text"] = translated_text
+                    except KeyError as e:
+                        logger.error(f"KeyError translating result_text: {e}")
+
+            return all_results
+
+        # Hilfsfunktion zum Durchführen der ELS-Suche für eine gegebene Gematria-Summe
+        def perform_els_search_for_gematria_sum(gematria_sum, include_torah, include_bible, include_quran, include_hindu, include_tripitaka):
+            return perform_els_search(
+                step=gematria_sum,
+                rounds_combination="1,-1",
+                tlang="english",
+                strip_spaces=True,
+                strip_in_braces=True,
+                strip_diacritics_chk=True,
+                include_torah=include_torah,
+                include_bible=include_bible,
+                include_quran=include_quran,
+                include_hindu=include_hindu,
+                include_tripitaka=include_tripitaka
+            )
+
+        # Hilfsfunktion zum Filtern und Formatieren der Ergebnisse
+        def filter_and_format_results(results, search_type, search_term, gematria_sum_search, search_mode, date_str, name, initial_gematria_sum, sub_oscillation_level, base_results_list):
+            search_term=strip_diacritics(search_term)
+            filtered_results = []
+            for book_name, book_results in results.items():
+                if book_results:
+                    for result in book_results:
+                        try:
+                            result_text = result['result_text']
+                            result_sum = result['result_sum']
+
+                            # Finde die verwendete Sub-Oszillation heraus
+                            sub_oscillation_sums = []
+                            current_gematria_sum = initial_gematria_sum
+
+                            if sub_oscillation_level > 0:
+                                for i in range(1, sub_oscillation_level + 1):
+                                    for base_result_entry_tuple in base_results_list:
+                                        base_result_entry = dict(base_result_entry_tuple)
+                                        if result.get('result_sum') == base_result_entry['result'].get('result_sum') and result.get('result_text') == base_result_entry['result'].get('result_text'):
+                                            sub_gematria_sum = base_result_entry.get('sub_gematria_sum')
+                                            if sub_gematria_sum:
+                                                sub_oscillation_sums.append(sub_gematria_sum)
+                                                current_gematria_sum += sub_gematria_sum
+                                            break  # Innere Schleife beenden, da das passende Ergebnis gefunden wurde
+                                    else:
+                                        continue  # Äußere Schleife fortsetzen, wenn kein passendes Ergebnis gefunden wurde
+                                    break
+
+                            # Sub-Oszillation Summen an den Namen anhängen
+                            sub_oscillation_text = ""
+                            if sub_oscillation_sums:
+                                sub_oscillation_text = " + " + " + ".join(map(str, sub_oscillation_sums))
+
+                            # Filtern der Ergebnisse
+                            if search_type == "Text in result_text":
+                                if search_mode == "Exact Search" and search_term == result_text:
+                                    filtered_results.append(
+                                        {
+                                            "date": date_str,
+                                            "name": f"{name}{sub_oscillation_text}",
+                                            "gematria_sum": current_gematria_sum,
+                                            "book": book_name,
+                                            "result": result
+                                        }
+                                    )
+                                elif search_mode == "Contains Word" and search_term in result_text:
+                                    filtered_results.append(
+                                        {
+                                            "date": date_str,
+                                            "name": f"{name}{sub_oscillation_text}",
+                                            "gematria_sum": current_gematria_sum,
+                                            "book": book_name,
+                                            "result": result
+                                        }
+                                    )
+                            elif search_type == "Gematria Sum in results":
+                                if result_sum == gematria_sum_search:
+                                    filtered_results.append(
+                                        {
+                                            "date": date_str,
+                                            "name": f"{name}{sub_oscillation_text}",
+                                            "gematria_sum": current_gematria_sum,
+                                            "book": book_name,
+                                            "result": result
+                                        }
+                                    )
+                        except KeyError as e:
+                            logger.error(f"KeyError - Key '{e.args[0]}' not found in result. Skipping this result.")
+                            continue
+            return filtered_results
+
+        def perform_date_range_els_search(start_date, end_date, names_input, search_type, search_term, gematria_sum_search, search_mode, include_torah, include_bible, include_quran, include_hindu, include_tripitaka, translate_results, sub_oscillation_search, sub_oscillation_level):
             names = [n.strip() for n in names_input.split("\n") if n.strip()]
             date_gematrias = perform_gematria_calculation_for_date_range(start_date, end_date)
 
@@ -762,67 +935,54 @@ with gr.Blocks() as app:
             for intermediate_result in intermediate_results:
                 date_str = intermediate_result["date"]
                 name = intermediate_result["name"]
-                gematria_sum = intermediate_result["gematria_sum"]
-
-                # Hier die ELS-Suche für jede Gematria-Summe durchführen
-                els_results = perform_els_search(
-                    step=gematria_sum,
-                    rounds_combination="1,-1",
-                    tlang="english",
-                    strip_spaces=True,
-                    strip_in_braces=True,
-                    strip_diacritics_chk=True,
-                    include_torah=include_torah,
-                    include_bible=include_bible,
-                    include_quran=include_quran,
-                    include_hindu=include_hindu,
-                    include_tripitaka=include_tripitaka
+                initial_gematria_sum = intermediate_result["gematria_sum"]
+
+                # Basis-Suche durchführen
+                base_results = perform_els_search_for_gematria_sum(
+                    initial_gematria_sum, include_torah, include_bible, include_quran, include_hindu, include_tripitaka
                 )
 
-                # Die Ergebnisse für jedes Buch und jede Gematria-Summe verarbeiten
-                for book_name, book_results in els_results.items():
-                    if book_results:
-                        for result in book_results:
-                            try:
-                                result_text = result['result_text']
-                                result_sum = result['result_sum']
-
-                                # Filtern der Ergebnisse
-                                if search_type == "Text in result_text":
-                                    if search_mode == "Exact Search" and search_term == result_text:
-                                        all_results.append(
-                                            {
-                                                "date": date_str,
-                                                "name": name,
-                                                "gematria_sum": gematria_sum,
-                                                "book": book_name,
-                                                "result": result
-                                            }
-                                        )
-                                    elif search_mode == "Contains Word" and search_term in result_text:
-                                        all_results.append(
-                                            {
-                                                "date": date_str,
-                                                "name": name,
-                                                "gematria_sum": gematria_sum,
-                                                "book": book_name,
-                                                "result": result
-                                            }
-                                        )
-                                elif search_type == "Gematria Sum in results":
-                                    if result_sum == gematria_sum_search:
-                                        all_results.append(
-                                            {
-                                                "date": date_str,
-                                                "name": name,
-                                                "gematria_sum": gematria_sum,
-                                                "book": book_name,
-                                                "result": result
-                                            }
-                                        )
-                            except KeyError as e:
-                                logger.error(f"KeyError - Key '{e.args[0]}' not found in result. Skipping this result.")
-                                continue
+                # Nur ausgewählte Bücher für die Sub-Oszillationen-Suche berücksichtigen
+                selected_books_results = {}
+                if include_torah:
+                    selected_books_results["Torah"] = base_results.get("Torah", [])
+                if include_bible:
+                    selected_books_results["Bible"] = base_results.get("Bible", [])
+                if include_quran:
+                    selected_books_results["Quran"] = base_results.get("Quran", [])
+                if include_hindu:
+                    selected_books_results["Rig Veda"] = base_results.get("Rig Veda", [])
+                if include_tripitaka:
+                    selected_books_results["Tripitaka"] = base_results.get("Tripitaka", [])
+
+                # Speichere die base_results in einer Liste von Tupeln
+                base_results_list = []
+                for book_name, book_results in selected_books_results.items():
+                    for result in book_results:
+                        base_results_list.append(tuple(sorted({'book': book_name, 'result': result}.items())))
+
+                # Sub-Oszillationen-Suche, falls aktiviert und Level > 0
+                if sub_oscillation_search and sub_oscillation_level > 0:
+                    base_results_list = perform_sub_oscillation_search(
+                        base_results_list, initial_gematria_sum, sub_oscillation_level,
+                        include_torah, include_bible, include_quran, include_hindu, include_tripitaka
+                    )
+
+                # Umwandlung der erweiterten base_results_list in base_results
+                base_results = {}
+                for result_entry_tuple in base_results_list:
+                    result_entry = dict(result_entry_tuple)  # Konvertiere zurück zu Dictionary
+                    book_name = result_entry['book']
+                    if book_name not in base_results:
+                        base_results[book_name] = []
+                    base_results[book_name].append(result_entry['result'])
+
+                # Filterung und Hinzufügen der Ergebnisse zu all_results
+                filtered_results = filter_and_format_results(
+                    base_results, search_type, search_term, gematria_sum_search,
+                    search_mode, date_str, name, initial_gematria_sum, sub_oscillation_level, base_results_list
+                )
+                all_results.extend(filtered_results)
 
             # Übersetzung der Ergebnisse, falls angefordert
             if translate_results:
@@ -830,19 +990,113 @@ with gr.Blocks() as app:
                     try:
                         text_to_translate = result_entry["result"]["result_text"]
                         source_lang = result_entry["result"].get("source_language", "auto")
-                        translated_text = translation_utils.get_translation(text_to_translate, "en", source_lang)
-                        result_entry["result"]["translated_text"] = translated_text[0]
+                        translated_text = translation_utils.get_translation(text_to_translate, "en", source_lang)[0]
+                        result_entry["result"]["translated_text"] = translated_text
                     except KeyError as e:
                         logger.error(f"KeyError translating result_text: {e}")
 
             return all_results
 
+        def remove_duplicates(dict_list):
+            """
+            Entfernt Duplikate aus dict_list, basierend auf einer ID (repr).
+            dict_list: Liste aus Dictionaries (oder Tupeln),
+                    in denen wir Duplikate filtern wollen.
+            """
+            seen = set()
+            unique_list = []
+            for item in dict_list:
+                # Hier legen wir fest, was item sein kann:
+                #    - typischerweise ein dict: {'book':..., 'result':...}
+                #    - oder ein tuple, das wir ggf. in dict umwandeln
+
+                # Mache item zu einem Dictionary, falls es ein tuple ist
+                if isinstance(item, tuple):
+                    item = dict(item)
+                # => Jetzt haben wir item als Dictionary
+
+                # Erstelle eine ID; repr(item) enthält Keys und Values
+                # Wenn du es feingranular willst, kannst du stattdessen
+                # nur bestimmte Felder rausziehen, z.B. (book, result_sum, result_text)
+                item_id = repr(item)
+
+                if item_id not in seen:
+                    seen.add(item_id)
+                    unique_list.append(item)
+
+            return unique_list
+
+
+        def perform_sub_oscillation_search(base_results_list, initial_gematria_sum, level,
+                                        include_torah, include_bible, include_quran,
+                                        include_hindu, include_tripitaka):
+            """
+            Führt 'level' Sub-Oszillationsrunden durch und
+            hängt neu entstehende Ergebnisse an base_results_list an.
+            Verwendet remove_duplicates, um Dopplungen zu vermeiden.
+            """
+            if level == 0:
+                return base_results_list
+
+            # Mache base_results_list komplett zu Dicts
+            # (falls es Tupel gibt, wandeln wir die hier in Dicts):
+            dict_list = []
+            for entry in base_results_list:
+                if isinstance(entry, tuple):
+                    dict_list.append(dict(entry))
+                elif isinstance(entry, dict):
+                    dict_list.append(entry)
+                else:
+                    dict_list.append({"unknown": entry})
+
+            new_results = []
+            # Erzeuge in diesem Durchgang neue Einträge
+            for base_entry in dict_list:
+                sub_gematria_sum = base_entry['result']['result_sum']
+                combined_sub_gematria_sum = initial_gematria_sum + sub_gematria_sum
+
+                sub_results = perform_els_search_for_gematria_sum(
+                    combined_sub_gematria_sum,
+                    include_torah, include_bible, include_quran, include_hindu, include_tripitaka
+                )
+
+                # Für jedes gefundene sub_result => new_entry
+                for book_name, book_list in sub_results.items():
+                    for res in book_list:
+                        new_entry = {
+                            'book': book_name,
+                            'result': res,
+                            # speichere optional sub_gematria_sum
+                            'sub_gematria_sum': sub_gematria_sum
+                        }
+                        new_results.append(new_entry)
+
+            # Kombiniere Originaldaten + neue Daten
+            combined = dict_list + new_results
+
+            # Entferne Duplikate
+            combined_no_dupes = remove_duplicates(combined)
+
+            # Rekursion: ein Level tiefer
+            return perform_sub_oscillation_search(
+                combined_no_dupes,
+                initial_gematria_sum,
+                level - 1,
+                include_torah,
+                include_bible,
+                include_quran,
+                include_hindu,
+                include_tripitaka
+            )
+
         perform_search_btn_els.click(
             perform_date_range_els_search,
-            inputs=[start_date_els, end_date_els, names_input_els, search_type_els, search_term_els, gematria_sum_search_els, search_mode_els, include_torah_chk_els, include_bible_chk_els, include_quran_chk_els, include_hindu_chk_els, include_tripitaka_chk_els, translate_results_chk_els],
+            inputs=[start_date_els, end_date_els, names_input_els, search_type_els, search_term_els, gematria_sum_search_els, search_mode_els, include_torah_chk_els, include_bible_chk_els, include_quran_chk_els, include_hindu_chk_els, include_tripitaka_chk_els, translate_results_chk_els, sub_oscillation_search_chk_els, sub_oscillation_level_els],
             outputs=[filtered_results_output_els]
         )
 
+
+
     # --- Event Handlers ---
 
     search_type.change(

gematria.py

@@ -12,8 +12,8 @@ def strip_diacritics(text):
     for char in unicodedata.normalize('NFD', text):
         if unicodedata.category(char) not in ['Mn', 'Cf']:
             stripped_text += char
-        else:
-            logger.debug(f"Info: Diakritisches Zeichen '{char}' wird ignoriert.")
+        #else:
+            #logger.debug(f"Info: Diakritisches Zeichen '{char}' wird ignoriert.")
     return stripped_text
 
 def letter_to_value(letter):
@@ -150,7 +150,7 @@ def letter_to_value(letter):
         return 0
     else:
         # Gib eine spezifische Warnung aus, wenn das Zeichen unbekannt ist
-        logger.debug(f"Warnung: Unbekanntes Zeichen '{letter}' ignoriert.")
+        #logger.debug(f"Warnung: Unbekanntes Zeichen '{letter}' ignoriert.")
         return 0