add search interface

app.py

@@ -359,6 +359,82 @@ def update_rounds_dropdown():
     new_choices = extract_rounds_combinations()
     return new_choices
 
+def perform_gematria_calculation_for_date_range(start_date, end_date):
+    logger.debug(f"Calculating date gematria for range: {start_date} - {end_date}")
+    results = {}
+    delta = timedelta(days=1)
+    current_date = start_date
+
+    while current_date <= end_date:
+        date_string = current_date.strftime("%Y-%m-%d")
+        date_words = date_to_words(date_string)
+        date_gematria = calculate_gematria_sum(date_words, "")  # Angepasst, um der Funktion calculate_gematria_sum zu entsprechen
+
+        results[date_string] = {
+            "date_words": date_words,
+            "date_gematria": date_gematria,
+        }
+        current_date += delta
+    logger.debug(f"Finished calculating date gematria.")
+    return results
+
+def find_matching_dates(date_gematrias, names, search_journal_sum):
+    logger.debug(f"Searching for matches with journal sum: {search_journal_sum}")
+    matching_dates = {}
+
+    for name in names:
+        name_gematria = calculate_gematria_sum(name, "") # Angepasst, um der Funktion calculate_gematria_sum zu entsprechen
+        target_date_gematria = search_journal_sum - name_gematria if name_gematria is not None else None
+        logger.debug(f"Name: {name}, Gematria: {name_gematria}, Target Date Gematria: {target_date_gematria}")
+
+        if target_date_gematria is not None:
+            for date_str, date_data in date_gematrias.items():
+                if date_data["date_gematria"] == target_date_gematria:
+                    if name not in matching_dates:
+                        matching_dates[name] = []
+                    matching_dates[name].append(date_str)
+        logger.debug(f"Matches for {name}: {matching_dates.get(name, [])}")
+    return matching_dates
+
+def find_shared_journal_sums(date_gematrias, names):
+    """Finds shared journal sums and formats output with names and dates together."""
+    logger.debug("Calculating shared journal sums...")
+    shared_sums = {}
+    name_gematrias = {name: calculate_gematria_sum(name, "") for name in names}
+
+    for date_str, date_data in date_gematrias.items():
+        date_gematria = date_data["date_gematria"]
+        for name, name_gematria in name_gematrias.items():
+            journal_sum = date_gematria + name_gematria
+            journal_sum_str = str(journal_sum) # Konvertiere den Schlüssel (journal_sum) in einen String
+            if journal_sum_str not in shared_sums:
+                shared_sums[journal_sum_str] = {}
+            if name not in shared_sums[journal_sum_str]:
+                shared_sums[journal_sum_str][name] = []
+            shared_sums[journal_sum_str][name].append(date_str)
+
+    # Filter out sums not shared by at least two names and format output
+    result = {}
+    for journal_sum_str, data in shared_sums.items():
+        if len(data) >= 2:
+            result[journal_sum_str] = {}
+            for name, dates in data.items():
+                result[journal_sum_str][name] = dates
+
+    logger.debug(f"Shared Journal Sums: {result}")
+    return result
+
+def calculate_and_find_dates(start_date, end_date, names_input, search_journal_sum, find_shared=False):
+    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)
+    if find_shared:
+        shared_sums = find_shared_journal_sums(date_gematrias, names)
+        return None, shared_sums
+    else:
+        matching_dates = find_matching_dates(date_gematrias, names, int(search_journal_sum))
+        return matching_dates, None
+
+
 # --- Main Gradio App ---
 with gr.Blocks() as app:
     with gr.Tab("ELS Search"):
@@ -586,6 +662,174 @@ with gr.Blocks() as app:
             else:
                 return {"visible": False, "__type__": "update"}, {"visible": True, "__type__": "update"}
 
+    with gr.Tab("Date Range Journal Sum Search"):
+        with gr.Row():
+            start_date_jr = Calendar(type="datetime", label="Start Date")
+            end_date_jr = Calendar(type="datetime", label="End Date")
+        with gr.Row():
+            names_input_jr = gr.Textbox(label="Names (one per line)", lines=5)
+            search_sum_jr = gr.Number(label="Search Journal Sum", precision=0)
+
+        with gr.Row():
+            calculate_btn_jr = gr.Button("Search Journal Sum")
+            shared_sums_btn_jr = gr.Button("Find Shared Journal Sums")
+
+        matching_dates_output_jr = gr.JSON(label="Matching Dates")
+        shared_sums_output_jr = gr.JSON(label="Shared Journal Sums")
+
+        calculate_btn_jr.click(
+            lambda start_date, end_date, names_input, search_sum: calculate_and_find_dates(
+                start_date, end_date, names_input, search_sum, find_shared=False),
+            inputs=[start_date_jr, end_date_jr, names_input_jr, search_sum_jr],
+            outputs=[matching_dates_output_jr, shared_sums_output_jr]
+        )
+
+        shared_sums_btn_jr.click(
+            lambda start_date, end_date, names_input: calculate_and_find_dates(
+                start_date, end_date, names_input, 0, find_shared=True),
+            inputs=[start_date_jr, end_date_jr, names_input_jr],
+            outputs=[matching_dates_output_jr, shared_sums_output_jr]
+        )
+
+
+    with gr.Tab("Date Range ELS Search"):
+        with gr.Row():
+            start_date_els = Calendar(type="datetime", label="Start Date")
+            end_date_els = Calendar(type="datetime", label="End Date")
+        with gr.Row():
+            names_input_els = gr.Textbox(label="Names (one per line)", lines=5)
+        with gr.Row():
+            search_type_els = gr.Radio(
+                label="Search by",
+                choices=["Text in result_text", "Gematria Sum in results"],
+                value="Text in result_text"
+            )
+        with gr.Row():
+            search_mode_els = gr.Radio(
+                label="Search Mode",
+                choices=["Exact Search", "Contains Word"],
+                value="Contains Word"
+            )
+        with gr.Row():
+            search_term_els = gr.Textbox(label="Search Term", visible=True)
+            gematria_sum_search_els = gr.Number(label="Gematria Sum", visible=False)
+        with gr.Row():
+            include_torah_chk_els = gr.Checkbox(label="Include Torah", value=True)
+            include_bible_chk_els = gr.Checkbox(label="Include Bible", value=True)
+            include_quran_chk_els = gr.Checkbox(label="Include Quran", value=True)
+            include_hindu_chk_els = gr.Checkbox(label="Include Rigveda", value=False)
+            include_tripitaka_chk_els = gr.Checkbox(label="Include Tripitaka", value=False)
+
+        with gr.Row():
+            perform_search_btn_els = gr.Button("Perform Search")
+
+        filtered_results_output_els = gr.JSON(label="Filtered Results")
+
+        # Funktionen zur Aktualisierung der Sichtbarkeit der Sucheingabefelder
+        def update_search_components_els(search_type):
+            if search_type == "Text in result_text":
+                return gr.Textbox(visible=True), gr.Number(visible=False)
+            else:
+                return gr.Textbox(visible=False), gr.Number(visible=True)
+
+        search_type_els.change(
+            fn=update_search_components_els,
+            inputs=[search_type_els],
+            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):
+            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}
+                    )
+
+            # 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"]
+                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
+                )
+
+                # 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
+
+            return all_results
+
+        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],
+            outputs=[filtered_results_output_els]
+        )
+
     # --- Event Handlers ---
 
     search_type.change(