results structure

app.py

@@ -28,6 +28,7 @@ from typing import List, Tuple
 import calendar
 import translation_utils
 import hashlib
+import copy
 
 translation_utils.create_translation_table()
 
@@ -743,91 +744,22 @@ with gr.Blocks() as app:
             outputs=[search_term_els, gematria_sum_search_els]
         )
 
-        # 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, 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):
+        def perform_els_search_for_gematria_sum(
+            gematria_sum,
+            include_torah,
+            include_bible,
+            include_quran,
+            include_hindu,
+            include_tripitaka
+        ):
+            """
+            Calls your actual ELS search function, returning a dict like:
+            {
+            "Torah": [ { "result_sum": ..., "result_text": ..., "source_language": ...}, ...],
+            "Bible": [...],
+            ...
+            }
+            """
             return perform_els_search(
                 step=gematria_sum,
                 rounds_combination="1,-1",
@@ -842,261 +774,331 @@ with gr.Blocks() as app:
                 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)
 
-            # 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}
-                    )
+        def perform_sub_oscillation_search(
+            base_results_list,
+            initial_gematria_sum,
+            level,
+            include_torah,
+            include_bible,
+            include_quran,
+            include_hindu,
+            include_tripitaka
+        ):
+            """
+            Recursively populates 'subresults' for each base entry, up to the specified level.
+            base_results_list: A list of dicts, each shaped like:
+            {
+                "book": "Torah",
+                "result": {
+                    "result_sum": ...,
+                    "result_text": ...
+                },
+                "subresults": []
+            }
+            initial_gematria_sum: The base sum from day+name (or from prior recursion).
+            level: how many sub-levels we still want to descend.
+            include_XXX: booleans for controlling which texts to include.
+            """
 
-            # Ergebnisse nach Datum sortieren
-            intermediate_results.sort(key=lambda x: x["date"])
+            if level <= 0:
+                return base_results_list
 
-            all_results = []
-            for intermediate_result in intermediate_results:
-                date_str = intermediate_result["date"]
-                name = intermediate_result["name"]
-                initial_gematria_sum = intermediate_result["gematria_sum"]
+            for base_entry in base_results_list:
+                parent_sum = base_entry["result"]["result_sum"]
+                combined_sum = initial_gematria_sum + parent_sum
+
+                # Next-level search
+                sub_search_results = perform_els_search_for_gematria_sum(
+                    gematria_sum=combined_sum,
+                    include_torah=include_torah,
+                    include_bible=include_bible,
+                    include_quran=include_quran,
+                    include_hindu=include_hindu,
+                    include_tripitaka=include_tripitaka
+                )
 
-                # 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
+                # Build child entries
+                child_entries = []
+                for book_name, res_list in sub_search_results.items():
+                    for one_res in res_list:
+                        child_entries.append({
+                            "book": book_name,
+                            "result": one_res,
+                            "subresults": []
+                        })
+
+                # Attach to subresults
+                base_entry["subresults"].extend(child_entries)
+
+                # Recurse deeper
+                perform_sub_oscillation_search(
+                    base_entry["subresults"],
+                    initial_gematria_sum,
+                    level - 1,
+                    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 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
-                    )
+            return base_results_list
+
+
+        def matches_criteria(item, search_type, search_term, gematria_sum_search, search_mode):
+            """
+            Checks if a single item (a dict with 'result_text', 'result_sum', etc.)
+            matches the user’s chosen filter criteria.
+
+            item shape example:
+            {
+                "book": "Torah",
+                "result": {
+                "result_text": "foo bar",
+                "result_sum": 1234,
+                ...
+                },
+                "subresults": [ ... ]
+            }
+            """
+            result_text = item["result"].get("result_text", "")
+            result_sum  = item["result"].get("result_sum", None)
+
+            if search_type == "Text in result_text":
+                if search_mode == "Exact Search":
+                    return (result_text == search_term)
+                else:  # "Contains Word"
+                    return (search_term in result_text)
+            else:
+                # search_type == "Gematria Sum in results"
+                return (result_sum == gematria_sum_search)
+
 
-                # 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
+        def prune_tree_by_search_criteria(results_list, search_type, search_term, gematria_sum_search, search_mode):
+            """
+            Recursively filters a list of items so that:
+            - An item is included if it directly matches the search criteria,
+                OR if any of its child subresults match (in which case we keep
+                the item *and* the matching children).
+            - This preserves parent chain for matching subresults.
+
+            returns a new, pruned list of items with the same nested structure,
+            but only containing the branches that match or lead to a match.
+            """
+            pruned_list = []
+            for item in results_list:
+                # Recurse into subresults first
+                pruned_sub = prune_tree_by_search_criteria(
+                    item["subresults"],
+                    search_type,
+                    search_term,
+                    gematria_sum_search,
+                    search_mode
                 )
-                all_results.extend(filtered_results)
+                does_item_match = matches_criteria(item, search_type, search_term, gematria_sum_search, search_mode)
 
-            # Ü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}")
+                # If the item itself matches OR any child matches
+                if does_item_match or len(pruned_sub) > 0:
+                    # Make a copy of the item so we don't destroy the original
+                    new_item = copy.deepcopy(item)
+                    # Overwrite subresults with the pruned version
+                    new_item["subresults"] = pruned_sub
+                    pruned_list.append(new_item)
+
+            return pruned_list
+
+
+
+        def translate_subresults_recursive(subresults_list):
+            """
+            Recursively translates the 'result_text' of each item in subresults_list.
+            We only visit items that remain in the filtered results.
+            """
+            for sub_item in subresults_list:
+                text = sub_item["result"].get("result_text", "")
+                source_lang = sub_item["result"].get("source_language", "auto")
+                if text:
+                    translated_text = translation_utils.get_translation(text, "en", source_lang)[0]
+                    sub_item["result"]["translated_text"] = translated_text
+
+                # Recurse into deeper subresults
+                if sub_item["subresults"]:
+                    translate_subresults_recursive(sub_item["subresults"])
+
+        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
+        ):
+            """
+            - Builds a fully nested sub-oscillation structure if requested.
+            - Then prunes it so only matching items remain (plus parents).
+            - Finally, optionally translates the pruned items if requested.
+            - Returns the filtered (and optionally translated) structure.
+            """
+            # 1) Compute gematria sums for all dates in the chosen range
+            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)
 
-            return all_results
+            all_filtered_results = []
+
+            # 2) Loop over each date
+            for date_str, date_data in date_gematrias.items():
+                for name in names:
+                    # base sum: day gematria + name gematria
+                    name_gem = calculate_gematria_sum(name, "")
+                    initial_gem = date_data["date_gematria"] + name_gem
+                    date_words = date_data["date_words"]
+                    search_path_basic = f"{name} {date_words}"
+
+                    # 3) Do the base ELS search (this is the top-level results)
+                    base_results = perform_els_search_for_gematria_sum(
+                        gematria_sum=initial_gem,
+                        include_torah=include_torah,
+                        include_bible=include_bible,
+                        include_quran=include_quran,
+                        include_hindu=include_hindu,
+                        include_tripitaka=include_tripitaka
+                    )
+
+                    # 4) Convert "base_results" into a uniform nested format
+                    #    shaped like { "0": {"book":..., "results": [ {...}, ... ]}, ... }
+                    formatted_base_results = {}
+                    idx_counter = 0
+                    for book_name, book_res_list in base_results.items():
+                        if book_res_list:
+                            formatted_base_results[str(idx_counter)] = {
+                                "book": book_name,
+                                "results": []
+                            }
+                            for res in book_res_list:
+                                formatted_base_results[str(idx_counter)]["results"].append({
+                                    "book": book_name,
+                                    "result": res,
+                                    "subresults": []
+                                })
+                            idx_counter += 1
+
+                    # 5) Flatten out for sub-osc recursion
+                    base_results_list = []
+                    for val in formatted_base_results.values():
+                        base_results_list.extend(val["results"])
+
+                    # 6) If sub-oscillation is requested, build deeper levels
+                    if sub_oscillation_search and sub_oscillation_level > 0 and base_results_list:
+                        perform_sub_oscillation_search(
+                            base_results_list,
+                            initial_gem,
+                            sub_oscillation_level,
+                            include_torah,
+                            include_bible,
+                            include_quran,
+                            include_hindu,
+                            include_tripitaka
+                        )
+
+                    # 7) Now we prune (filter) the results according to the user’s search criteria
+                    #    For each "book" block, we filter the "results" array
+                    pruned_base_results = {}
+                    for key, block in formatted_base_results.items():
+                        original_list = block["results"]  # each is {book, result, subresults}
+                        filtered_list = prune_tree_by_search_criteria(
+                            original_list,
+                            search_type,
+                            search_term,
+                            gematria_sum_search,
+                            search_mode
+                        )
+                        # Keep only if we got something back
+                        if filtered_list:
+                            pruned_base_results[key] = {
+                                "book": block["book"],
+                                "results": filtered_list
+                            }
+
+                    # If there’s nothing left after filtering, skip adding
+                    if not pruned_base_results:
+                        continue
+
+                    # 8) Build the final item for this date+name, with pruned results
+                    final_item = {
+                        "date": date_str,
+                        "name": name,
+                        "search_path_basic": search_path_basic,
+                        "basic_gematria": initial_gem,
+                        "basic_results": pruned_base_results
+                    }
+
+                    # 9) If translation is requested, only translate the pruned results
+                    if translate_results:
+                        # Recursively translate only the items in pruned_base_results
+                        for block_key, block_val in final_item["basic_results"].items():
+                            for entry in block_val["results"]:
+                                txt = entry["result"].get("result_text", "")
+                                src_lang = entry["result"].get("source_language", "auto")
+                                if txt:
+                                    trans = translation_utils.get_translation(txt, "en", src_lang)[0]
+                                    entry["result"]["translated_text"] = trans
+                                # And go deeper into subresults
+                                if entry["subresults"]:
+                                    translate_subresults_recursive(entry["subresults"])
+
+                    # 10) Add this final, fully filtered (and possibly translated) item
+                    all_filtered_results.append(final_item)
+
+            # Return the fully processed set of results
+            return all_filtered_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.
+            If you need to remove duplicates at any stage, you can call this,
+            but it's optional if your data doesn't require deduping.
             """
             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, sub_oscillation_search_chk_els, sub_oscillation_level_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(