add Tab 5

app.py

@@ -29,6 +29,7 @@ import calendar
 import translation_utils
 import hashlib
 import copy
+from collections import Counter
 
 translation_utils.create_translation_table()
 
@@ -1099,6 +1100,210 @@ with gr.Blocks() as app:
             outputs=[filtered_results_output_els]
         )
 
+
+    with gr.Tab("Comprehensive ELS Search"):
+        with gr.Row():
+            start_date_comp = Calendar(type="datetime", label="Start Date")
+            end_date_comp = Calendar(type="datetime", label="End Date")
+        with gr.Row():
+            names_input_comp = gr.Textbox(label="Names (one per line)", lines=5)
+        with gr.Row():
+            sub_oscillation_level_comp = gr.Number(label="Sub-Oscillation Level", precision=0, value=1)
+        with gr.Row():
+            include_torah_chk_comp = gr.Checkbox(label="Include Torah", value=True)
+            include_bible_chk_comp = gr.Checkbox(label="Include Bible", value=True)
+            include_quran_chk_comp = gr.Checkbox(label="Include Quran", value=True)
+            include_hindu_chk_comp = gr.Checkbox(label="Include Rigveda", value=False)
+            include_tripitaka_chk_comp = gr.Checkbox(label="Include Tripitaka", value=False)
+        with gr.Row():
+            translate_results_chk_comp = gr.Checkbox(label="Translate Results to English", value=False)
+        with gr.Row():
+            common_gematria_results = gr.JSON(label="Common Gematria Results")
+        with gr.Row():
+            perform_search_btn_comp = gr.Button("Perform Search")
+
+
+
+        def perform_comprehensive_els_search(
+            start_date,
+            end_date,
+            names_input,
+            sub_oscillation_level,
+            include_torah,
+            include_bible,
+            include_quran,
+            include_hindu,
+            include_tripitaka,
+            translate_results
+        ):
+            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)
+
+            all_results_by_date = {}
+
+            for date_str, date_data in date_gematrias.items():
+                all_results_by_date[date_str] = {}
+                for name in names:
+                    name_gem = calculate_gematria_sum(name, "")
+                    initial_gem = date_data["date_gematria"] + name_gem
+
+                    base_results_list = []
+                    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
+                    )
+                    for book_name, res_list in base_results.items():
+                        for one_res in res_list:
+                            if not isinstance(one_res, dict) or "result_sum" not in one_res:
+                                print(f"Warning: Invalid result format for {name} on {date_str}: {one_res}")
+                                continue
+
+                            base_results_list.append({
+                                        "book": book_name,
+                                        "result": one_res,
+                                        "subresults": []
+                                    })
+
+
+                    if 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
+                        )
+
+                    all_results_by_date[date_str][name] = base_results_list
+
+
+            common_results = {}
+            for date_str, name_results in all_results_by_date.items():
+                common_results[date_str] = {}
+                sums_by_name = {}
+                all_sums_count = Counter()
+                for name, results in name_results.items():
+                    sums_by_name[name] = set()
+                    count_sums_recursive(results, all_sums_count)
+                    extract_sums_recursive(results, sums_by_name[name])
+
+                ordered_common_sums = [item for item, count in all_sums_count.most_common() if all(item in sums_by_name[n] for n in sums_by_name)]
+
+                for common_sum in ordered_common_sums:
+                    common_results[date_str][str(common_sum)] = {}
+                    for name, results in name_results.items():
+                        matching_items = []
+                        for item in results:
+                            if find_results_by_sum([item], common_sum):
+                                item_copy = copy.deepcopy(item)
+
+                                if translate_results:
+                                    translate_recursive(item_copy)
+
+
+                                item_copy["subresults"] = find_results_by_sum(item.get("subresults", []), common_sum)
+
+                                if translate_results:
+                                    for sub_item in item_copy["subresults"]:
+                                        translate_recursive(sub_item)
+
+                                matching_items.append(item_copy)
+
+                        if matching_items:
+                            common_results[date_str][str(common_sum)][name] = matching_items
+
+            return common_results
+
+        def find_results_by_sum(results, target_sum):
+            matches = []
+            if isinstance(results, list):
+                for item in results:
+                    matches.extend(find_results_by_sum(item, target_sum))
+            elif isinstance(results, dict):
+                if "result" in results and isinstance(results["result"], dict) and "result_sum" in results["result"]:
+                    try:
+                        result_sum = int(results["result"]["result_sum"])
+                        if result_sum == target_sum:
+                            matches.append(results)
+                    except (TypeError, ValueError) as e:
+                        print(f"Error comparing result_sum: {e}, Data: {results}")
+                if "subresults" in results:
+                    matches.extend(find_results_by_sum(results["subresults"], target_sum))
+
+            return matches
+
+
+        def extract_sums_recursive(data, sums_set):
+            if isinstance(data, list):
+                for item in data:
+                    extract_sums_recursive(item, sums_set)
+            elif isinstance(data, dict):
+                if "result" in data and isinstance(data["result"], dict) and "result_sum" in data["result"]:
+                    try:
+                        result_sum = int(data["result"]["result_sum"])
+                        sums_set.add(result_sum)
+                    except (TypeError, ValueError) as e:
+                        print(f"Error extracting result_sum: {e}, Data: {data}")
+
+                if "subresults" in data:
+                    extract_sums_recursive(data["subresults"], sums_set)
+
+
+        def count_sums_recursive(data, sums_counter):
+            if isinstance(data, list):
+                for item in data:
+                    count_sums_recursive(item, sums_counter)
+            elif isinstance(data, dict):
+                if "result" in data and isinstance(data["result"], dict) and "result_sum" in data["result"]:
+                    try:
+                        result_sum = int(data["result"]["result_sum"])
+                        sums_counter[result_sum] += 1
+                    except (TypeError, ValueError) as e:
+                        print(f"Error counting result_sum: {e}, Data: {data}")
+                if "subresults" in data:
+                    count_sums_recursive(data["subresults"], sums_counter)
+
+
+
+        def translate_recursive(item):
+            if "result" in item and isinstance(item["result"], dict) and "result_text" in item["result"]:
+                text = item["result"].get("result_text", "")
+                source_lang = item["result"].get("source_language", "auto")
+                if text:
+                    translated_text = translation_utils.get_translation(text, "en", source_lang)[0]
+                    item["result"]["translated_text"] = translated_text
+
+            if "subresults" in item and isinstance(item["subresults"], list):
+                for sub in item["subresults"]:
+                    translate_recursive(sub)
+
+
+
+
+        perform_search_btn_comp.click(
+            perform_comprehensive_els_search,
+            inputs=[
+                start_date_comp,
+                end_date_comp,
+                names_input_comp,
+                sub_oscillation_level_comp,
+                include_torah_chk_comp,
+                include_bible_chk_comp,
+                include_quran_chk_comp,
+                include_hindu_chk_comp,
+                include_tripitaka_chk_comp,
+                translate_results_chk_comp
+            ],
+            outputs=[common_gematria_results]
+        )
+
     # --- Event Handlers ---
 
     search_type.change(