add search interface

app.py

@@ -1,6 +1,6 @@
-#TODO: Quran results have numbers
-
 import logging
+import os
+
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
 
@@ -23,8 +23,8 @@ import re
 import sqlite3
 from collections import defaultdict
 from typing import List, Tuple
-import rich
-from fuzzywuzzy import fuzz
+# import rich  # Removed rich
+# from fuzzywuzzy import fuzz  # Removed fuzzywuzzy
 import calendar
 import translation_utils
 import hashlib
@@ -33,9 +33,9 @@ translation_utils.create_translation_table()
 
 # Create a translator instance *once* globally
 translator = GoogleTranslator(source='auto', target='auto')
-LANGUAGES_SUPPORTED = translator.get_supported_languages(as_dict=True)  # Corrected dictionary name
+LANGUAGES_SUPPORTED = translator.get_supported_languages(as_dict=True)
 
-LANGUAGE_CODE_MAP = LANGUAGES_SUPPORTED # Use deep_translator's mapping directly
+LANGUAGE_CODE_MAP = LANGUAGES_SUPPORTED  # Use deep_translator's mapping directly
 
 # --- Constants ---
 DATABASE_FILE = 'gematria.db'
@@ -49,7 +49,7 @@ def create_els_cache_table():
     if not os.path.exists(ELS_CACHE_DB):
         with sqlite3.connect(ELS_CACHE_DB) as conn:
             conn.execute('''
-                CREATE TABLE els_cache (
+                CREATE TABLE IF NOT EXISTS els_cache (
                     query_hash TEXT PRIMARY KEY,
                     function_name TEXT,
                     args TEXT,
@@ -111,7 +111,6 @@ def get_query_hash(func, args, kwargs):
     key = (func.__name__, args, kwargs)
     return hashlib.sha256(json.dumps(key).encode()).hexdigest()
 
-
 def cached_process_json_files(func, *args, **kwargs):
     # Create a dictionary to store the parameters
     params = {
@@ -154,15 +153,15 @@ def cached_process_json_files(func, *args, **kwargs):
     try:
         with sqlite3.connect(ELS_CACHE_DB, timeout=DATABASE_TIMEOUT) as conn:
             cursor = conn.cursor()
-            cursor.execute("INSERT INTO els_cache (query_hash, function_name, args, kwargs, results) VALUES (?, ?, ?, ?, ?)",
-                           (query_hash, params["function"], params_json, json.dumps({}), json.dumps(results)))
+            cursor.execute(
+                "INSERT INTO els_cache (query_hash, function_name, args, kwargs, results) VALUES (?, ?, ?, ?, ?)",
+                (query_hash, params["function"], params_json, json.dumps({}), json.dumps(results)))
             conn.commit()
     except sqlite3.Error as e:
         logger.error(f"Database error caching results: {e}")
 
     return results
 
-
 # --- Helper Functions (from Network app.py) ---
 def flatten_text(text: List) -> str:
     if isinstance(text, list):
@@ -185,13 +184,13 @@ def get_most_frequent_phrase(results):
     phrase_counts = defaultdict(int)
     for words, book, chapter, verse, phrase_length, word_position in results:
         phrase_counts[words] += 1
-    most_frequent_phrase = max(phrase_counts, key=phrase_counts.get) if phrase_counts else None  # Handle empty results
+    most_frequent_phrase = max(phrase_counts, key=phrase_counts.get) if phrase_counts else None
     return most_frequent_phrase
 
 # --- Functions from BOS app.py ---
-def create_language_dropdown(label, default_value='English', show_label=True): # Default value must be in LANGUAGE_CODE_MAP
+def create_language_dropdown(label, default_value='English', show_label=True):
     return gr.Dropdown(
-        choices=list(LANGUAGE_CODE_MAP.keys()),  # Correct choices
+        choices=list(LANGUAGE_CODE_MAP.keys()),
         label=label,
         value=default_value,
         show_label=show_label
@@ -210,22 +209,21 @@ def calculate_gematria_sum(text, date_words):
     else:
         return None
 
-def perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, include_torah, include_bible, include_quran, include_hindu, include_tripitaka):
+def perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk,
+                       include_torah, include_bible, include_quran, include_hindu, include_tripitaka):
     if step == 0 or rounds_combination == "0,0":
         return None
 
     results = {}
     length = 0
 
-    selected_language_long = tlang  # From the Gradio dropdown (long form)
-    # Get the short code.
+    selected_language_long = tlang
     tlang = LANGUAGES_SUPPORTED.get(selected_language_long)
-    if tlang is None:  # Handle unsupported languages
+    if tlang is None:
         tlang = "en"
         logger.warning(
             f"Unsupported language selected: {selected_language_long}. Defaulting to English (en).")
 
-    # Cache Update: Pass parameters individually
     if include_torah:
         logger.debug(
             f"Arguments for Torah: {(1, 39, step, rounds_combination, length, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)}")
@@ -235,35 +233,37 @@ def perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_b
         results["Torah"] = []
 
     if include_bible:
-        results["Bible"] = cached_process_json_files(bible.process_json_files, 40, 66, step, rounds_combination, length,
+        results["Bible"] = cached_process_json_files(bible.process_json_files, 40, 66, step, rounds_combination,
+                                                     length,
                                                      tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
     else:
         results["Bible"] = []
 
     if include_quran:
-        results["Quran"] = cached_process_json_files(quran.process_json_files, 1, 114, step, rounds_combination, length,
+        results["Quran"] = cached_process_json_files(quran.process_json_files, 1, 114, step, rounds_combination,
+                                                     length,
                                                      tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
     else:
         results["Quran"] = []
 
     if include_hindu:
         results["Rig Veda"] = cached_process_json_files(
-            hindu.process_json_files, 1, 10, step, rounds_combination, length, tlang, False, strip_in_braces, strip_diacritics_chk)
+            hindu.process_json_files, 1, 10, step, rounds_combination, length, tlang, False, strip_in_braces,
+            strip_diacritics_chk)
     else:
         results["Rig Veda"] = []
 
     if include_tripitaka:
         results["Tripitaka"] = cached_process_json_files(
-            tripitaka.process_json_files, 1, 52, step, rounds_combination, length, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
+            tripitaka.process_json_files, 1, 52, step, rounds_combination, length, tlang, strip_spaces,
+            strip_in_braces, strip_diacritics_chk)
     else:
         results["Tripitaka"] = []
 
     return results
 
-
-
-def add_24h_projection(results_dict): #Now takes a dictionary of results
-    for book_name, results in results_dict.items():  # Iterate per book
+def add_24h_projection(results_dict):
+    for book_name, results in results_dict.items():
         num_results = len(results)
         if num_results > 0:
             time_interval = timedelta(minutes=24 * 60 / num_results)
@@ -275,12 +275,11 @@ def add_24h_projection(results_dict): #Now takes a dictionary of results
                 current_time = next_time
     return results_dict
 
-
 def add_monthly_projection(results_dict, selected_date):
     if selected_date is None:
-        return results_dict  # Return if no date is selected
+        return results_dict
 
-    for book_name, results in results_dict.items():  # Iterate per book
+    for book_name, results in results_dict.items():
         num_results = len(results)
         if num_results > 0:
             days_in_month = calendar.monthrange(selected_date.year, selected_date.month)[1]
@@ -289,23 +288,21 @@ def add_monthly_projection(results_dict, selected_date):
             start_datetime = datetime(selected_date.year, selected_date.month, 1)
             current_datetime = start_datetime
 
-
             for i in range(num_results):
                 next_datetime = current_datetime + timedelta(seconds=seconds_interval)
-                current_date = current_datetime.date() # Moved assignment inside loop
+                current_date = current_datetime.date()
                 next_date = next_datetime.date()
                 date_range_str = f"{current_date.strftime('%h %d')} - {next_date.strftime('%h %d')}"
                 results[i]['Monthly Projection'] = date_range_str
-                current_datetime = next_datetime # Add this
-                current_date = next_datetime.date() # Add this too
+                current_datetime = next_datetime
+                current_date = next_datetime.date()
     return results_dict
 
-
-def add_yearly_projection(results_dict, selected_date): #Correct name, handle dictionary input
+def add_yearly_projection(results_dict, selected_date):
     if selected_date is None:
-        return results_dict  # Return if no date is selected
+        return results_dict
 
-    for book_name, results in results_dict.items(): # Iterate per book
+    for book_name, results in results_dict.items():
         num_results = len(results)
         if num_results > 0:
             days_in_year = 366 if calendar.isleap(selected_date.year) else 365
@@ -314,80 +311,293 @@ def add_yearly_projection(results_dict, selected_date): #Correct name, handle di
             start_datetime = datetime(selected_date.year, 1, 1)
             current_datetime = start_datetime
 
-
             for i in range(num_results):
                 next_datetime = current_datetime + timedelta(seconds=seconds_interval)
-                current_date = current_datetime.date() # Move assignment inside loop
+                current_date = current_datetime.date()
                 next_date = next_datetime.date()
                 date_range_str = f"{current_date.strftime('%b %d')} - {next_date.strftime('%b %d')}"
                 results[i]['Yearly Projection'] = date_range_str
-                current_datetime = next_datetime # Update current datetime for next iteration
+                current_datetime = next_datetime
 
     return results_dict
 
-
 def sort_results(results):
     def parse_time(time_str):
         try:
             hours, minutes = map(int, time_str.split(':'))
-            return hours * 60 + minutes  # Convert to total minutes
+            return hours * 60 + minutes
         except ValueError:
-            return 24 * 60  # Sort invalid times to the end
+            return 24 * 60
 
     return sorted(results, key=lambda x: (
-        parse_time(x.get('24h Projection', '23:59').split('-')[0]),  # Sort by start time first
-        parse_time(x.get('24h Projection', '23:59').split('-')[1])   # Then by end time
+        parse_time(x.get('24h Projection', '23:59').split('-')[0]),
+        parse_time(x.get('24h Projection', '23:59').split('-')[1])
     ))
 
+def extract_rounds_combinations():
+    """Extracts unique rounds combinations from the database."""
+    combinations = set()
+    try:
+        with sqlite3.connect(ELS_CACHE_DB) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT args FROM els_cache")
+            all_args = cursor.fetchall()
+            for args_tuple in all_args:
+                args_str = args_tuple[0]
+                try:
+                    args_json = json.loads(args_str)
+                    if 'rounds' in args_json:
+                        combinations.add(args_json['rounds'])
+                except json.JSONDecodeError:
+                    logger.error(f"Could not decode JSON for args: {args_str}")
+    except sqlite3.Error as e:
+        logger.error(f"Database error: {e}")
+    logger.info(f"Found unique rounds combinations: {combinations}")
+    return ["All"] + sorted(list(combinations))
+
+def update_rounds_dropdown():
+    new_choices = extract_rounds_combinations()
+    return new_choices
+
 # --- Main Gradio App ---
 with gr.Blocks() as app:
-    with gr.Column():
-        with gr.Row():
-            tlang = create_language_dropdown("Target Language for Result Translation", default_value='english')
-            selected_date = Calendar(type="datetime", label="Date to investigate (optional)", info="Pick a date from the calendar")
-            use_day = gr.Checkbox(label="Use Day", info="Check to include day in search", value=True)
-            use_month = gr.Checkbox(label="Use Month", info="Check to include month in search", value=True)
-            use_year = gr.Checkbox(label="Use Year", info="Check to include year in search", value=True)
-            date_language_input = create_language_dropdown("Language of the person/topic (optional) (Date Word Language)", default_value='english')
-        with gr.Row():
-            gematria_text = gr.Textbox(label="Name and/or Topic (required)", value="Hans Albert Einstein Mileva Marity-Einstein")
-            date_words_output = gr.Textbox(label="Date in Words Translated (optional)")
-            gematria_result = gr.Number(label="Journal Sum")
-        #with gr.Row():
-
-
-        with gr.Row():
-            step = gr.Number(label="Jump Width (Steps) for ELS")
-            float_step = gr.Number(visible=False, value=1)
-            half_step_btn = gr.Button("Steps / 2")
-            double_step_btn = gr.Button("Steps * 2")
-
-            with gr.Column():
-                round_x = gr.Number(label="Round (1)", value=1)
-                round_y = gr.Number(label="Round (2)", value=-1)
-
-            rounds_combination = gr.Textbox(label="Combined Rounds", value="1,-1")
-
-        with gr.Row():
-            include_torah_chk = gr.Checkbox(label="Include Torah", value=True)
-            include_bible_chk = gr.Checkbox(label="Include Bible", value=True)
-            include_quran_chk = gr.Checkbox(label="Include Quran", value=True)
-            include_hindu_chk = gr.Checkbox(label="Include Rigveda", value=False)
-            include_tripitaka_chk = gr.Checkbox(label="Include Tripitaka", value=False)
-
-            strip_spaces = gr.Checkbox(label="Strip Spaces from Books", value=True)
-            strip_in_braces = gr.Checkbox(label="Strip Text in Braces from Books", value=True)
-            strip_diacritics_chk = gr.Checkbox(label="Strip Diacritics from Books", value=True)
-
-        translate_btn = gr.Button("Search with ELS")
-
-        # --- Output Components ---
-        markdown_output = gr.Dataframe(label="ELS Results")
-        most_frequent_phrase_output = gr.Textbox(label="Most Frequent Phrase in Network Search")
-        json_output = gr.JSON(label="JSON Output")
+    with gr.Tab("ELS Search"):
+        with gr.Column():
+            with gr.Row():
+                tlang = create_language_dropdown("Target Language for Result Translation", default_value='english')
+                selected_date = Calendar(type="datetime", label="Date to investigate (optional)",
+                                         info="Pick a date from the calendar")
+                use_day = gr.Checkbox(label="Use Day", info="Check to include day in search", value=True)
+                use_month = gr.Checkbox(label="Use Month", info="Check to include month in search", value=True)
+                use_year = gr.Checkbox(label="Use Year", info="Check to include year in search", value=True)
+                date_language_input = create_language_dropdown(
+                    "Language of the person/topic (optional) (Date Word Language)", default_value='english')
+            with gr.Row():
+                gematria_text = gr.Textbox(label="Name and/or Topic (required)",
+                                            value="Hans Albert Einstein Mileva Marity-Einstein")
+                date_words_output = gr.Textbox(label="Date in Words Translated (optional)")
+                gematria_result = gr.Number(label="Journal Sum")
+            # with gr.Row():
+
+            with gr.Row():
+                step = gr.Number(label="Jump Width (Steps) for ELS")
+                float_step = gr.Number(visible=False, value=1)
+                half_step_btn = gr.Button("Steps / 2")
+                double_step_btn = gr.Button("Steps * 2")
+
+                with gr.Column():
+                    round_x = gr.Number(label="Round (1)", value=1)
+                    round_y = gr.Number(label="Round (2)", value=-1)
+
+                rounds_combination = gr.Textbox(label="Combined Rounds", value="1,-1")
+
+            with gr.Row():
+                include_torah_chk = gr.Checkbox(label="Include Torah", value=True)
+                include_bible_chk = gr.Checkbox(label="Include Bible", value=True)
+                include_quran_chk = gr.Checkbox(label="Include Quran", value=True)
+                include_hindu_chk = gr.Checkbox(label="Include Rigveda", value=False)
+                include_tripitaka_chk = gr.Checkbox(label="Include Tripitaka", value=False)
+
+                strip_spaces = gr.Checkbox(label="Strip Spaces from Books", value=True)
+                strip_in_braces = gr.Checkbox(label="Strip Text in Braces from Books", value=True)
+                strip_diacritics_chk = gr.Checkbox(label="Strip Diacritics from Books", value=True)
+
+            translate_btn = gr.Button("Search with ELS")
+
+            # --- Output Components ---
+            markdown_output = gr.Dataframe(label="ELS Results")
+            most_frequent_phrase_output = gr.Textbox(label="Most Frequent Phrase in Network Search")
+            json_output = gr.JSON(label="JSON Output")
+
+    with gr.Tab("Cache Database Search"):
+        with gr.Column():
+            with gr.Row():
+                main_book_filter = gr.Dropdown(label="Filter by Main Book",
+                                            choices=["All", "Torah", "Bible", "Quran", "Rig Veda", "Tripitaka"],
+                                            value="All")
+                # Keine choices hier, nur das Label und den Initialwert
+                rounds_filter = gr.Dropdown(label="Filter by Rounds", value="All")
+
+            with gr.Row():
+                search_type = gr.Radio(label="Search by",
+                                    choices=["Text in result_text", "Gematria Sum in results"],
+                                    value="Text in result_text")
+            with gr.Row():
+                search_term = gr.Textbox(label="Search Term", visible=True)
+                gematria_sum_search = gr.Number(label="Gematria Sum", visible=False)
+
+            with gr.Row():
+                search_db_btn = gr.Button("Search Cache Database")
+            with gr.Row():
+                cache_search_results = gr.JSON(label="Cache Search Results")
+
+        def update_search_components(search_type):
+             if search_type == "Text in result_text":
+                return gr.Textbox.update(visible=True), gr.Number.update(visible=False)
+             else:
+                return gr.Textbox.update(visible=False), gr.Number.update(visible=True)
+
+
+        def search_cache_database(search_type, search_term, gematria_sum_search, main_book_filter, rounds_filter):
+            """Searches the cache database based on the selected filters and search term."""
+            results = []
+            if main_book_filter == "All" and rounds_filter == "All" and not search_term and not gematria_sum_search:
+                return results
+
+            try:
+                with sqlite3.connect(ELS_CACHE_DB) as conn:
+                    cursor = conn.cursor()
+
+                    if search_type == "Text in result_text":
+                        # Optimization: If only main_book_filter is selected, don't perform a full search
+                        if main_book_filter != "All" and rounds_filter == "All" and not search_term:
+                            return results
+
+                        cursor.execute("SELECT * FROM els_cache")
+                        all_results = cursor.fetchall()
+                        columns = [desc[0] for desc in cursor.description]
+
+                        for row in all_results:
+                            row_dict = dict(zip(columns, row))
+                            args_dict = json.loads(row_dict['args'])
+                            function_name = row_dict['function_name']
+
+                            # Function name filtering
+                            include_result = False
+                            if main_book_filter == "All":
+                                include_result = True
+                            elif main_book_filter == "Torah" and function_name == "torah.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Bible" and function_name == "bible.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Quran" and function_name == "quran.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Rig Veda" and function_name == "hindu.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Tripitaka" and function_name == "tripitaka.process_json_files":
+                                include_result = True
+
+                            if not include_result:
+                                continue
+
+                            # Rounds filtering
+                            if rounds_filter != "All" and args_dict.get('rounds') != rounds_filter:
+                                continue
+
+                            try:
+                                results_json = json.loads(row_dict['results'])
+                                for result_entry in results_json:
+                                    if 'result_text' in result_entry and search_term in result_entry['result_text']:
+                                        entry = {
+                                            'function_name': function_name,
+                                            'step': args_dict.get('step'),
+                                            'rounds': args_dict.get('rounds'),
+                                            'result': result_entry
+                                        }
+                                        results.append(entry)
+                            except (json.JSONDecodeError, TypeError) as e:
+                                logger.error(f"Error processing row: {e}")
+                                continue
+
+                    elif search_type == "Gematria Sum in results":
+
+                        # Optimization: If only main_book_filter is selected, don't perform a full search
+                        if main_book_filter != "All" and rounds_filter == "All" and not gematria_sum_search:
+                            return results
+
+                        if not isinstance(gematria_sum_search, (int, float)):
+                            return results
+
+                        cursor.execute("SELECT * FROM els_cache")
+                        all_results = cursor.fetchall()
+                        columns = [desc[0] for desc in cursor.description]
+
+                        for row in all_results:
+                            row_dict = dict(zip(columns, row))
+                            args_dict = json.loads(row_dict['args'])
+                            function_name = row_dict['function_name']
+
+                            # Function name filtering
+                            include_result = False
+                            if main_book_filter == "All":
+                                include_result = True
+                            elif main_book_filter == "Torah" and function_name == "torah.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Bible" and function_name == "bible.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Quran" and function_name == "quran.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Rig Veda" and function_name == "hindu.process_json_files":
+                                include_result = True
+                            elif main_book_filter == "Tripitaka" and function_name == "tripitaka.process_json_files":
+                                include_result = True
+
+                            if not include_result:
+                                continue
+
+                            # Rounds filtering
+                            if rounds_filter != "All" and args_dict.get('rounds') != rounds_filter:
+                                continue
+
+                            try:
+                                results_json = json.loads(row_dict['results'])
+                                for result_entry in results_json:
+                                    if 'result_sum' in result_entry and result_entry[
+                                        'result_sum'] == gematria_sum_search:
+                                        entry = {
+                                            'function_name': function_name,
+                                            'step': args_dict.get('step'),
+                                            'rounds': args_dict.get('rounds'),
+                                            'result': result_entry
+                                        }
+                                        results.append(entry)
+                            except (json.JSONDecodeError, TypeError) as e:
+                                logger.error(f"Error processing row: {e}")
+                                continue
+
+                # Sort results by gematria sum
+                results.sort(
+                    key=lambda x: x['result']['result_sum'] if 'result' in x and 'result_sum' in x['result'] else 0)
+                return results
+
+            except sqlite3.Error as e:
+                logger.error(f"Database error: {e}")
+                return []
+
+        def update_search_components(search_type):
+            """Updates the visibility of the search term and gematria sum input fields."""
+            if search_type == "Text in result_text":
+                return {"visible": True, "__type__": "update"}, {"visible": False, "__type__": "update"}
+            else:
+                return {"visible": False, "__type__": "update"}, {"visible": True, "__type__": "update"}
 
     # --- Event Handlers ---
 
+    search_type.change(
+        fn=update_search_components,
+        inputs=[search_type],
+        outputs=[search_term, gematria_sum_search]
+    )
+
+    search_db_btn.click(
+        fn=search_cache_database,
+        inputs=[search_type, search_term, gematria_sum_search, main_book_filter, rounds_filter],
+        outputs=cache_search_results
+    )
+
+
+    def update_rounds_choices():
+        return gr.update(choices=extract_rounds_combinations()) # gr.update, nicht gr.Dropdown.update
+
+    app.load(fn=update_rounds_choices, inputs=None, outputs=rounds_filter)
+
+    main_book_filter.change(
+        fn=update_rounds_choices,
+        inputs=None, # No input needed here
+        outputs=rounds_filter
+    )
+
+    # rest of the handlers
     def update_date_words(selected_date, date_language_input, use_day, use_month, use_year):
         if selected_date is None:
             return ""
@@ -408,10 +618,8 @@ with gr.Blocks() as app:
         else:  # Return empty string if no date components are selected
             return ""
 
-
         date_in_words = date_to_words(date_obj)
 
-
         translator = GoogleTranslator(source='auto', target=date_language_input)
         translated_date_words = translator.translate(date_in_words)
         return custom_normalize(translated_date_words)
@@ -431,51 +639,50 @@ with gr.Blocks() as app:
         new_step = math.ceil(float_step * 2)
         return new_step, float_step * 2
 
-
     def find_closest_phrase(target_phrase, phrases):
         best_match = None
         best_score = 0
 
-        logging.debug(f"Target phrase for similarity search: {target_phrase}")  # Log target phrase
+        logging.debug(f"Target phrase for similarity search: {target_phrase}")
 
         for phrase, _, _, _, _, _ in phrases:
             word_length_diff = abs(len(target_phrase.split()) - len(phrase.split()))
             similarity_score = fuzz.ratio(target_phrase, phrase)
             combined_score = similarity_score - word_length_diff
 
-            logging.debug(f"Comparing with phrase: {phrase}")  # Log each phrase being compared
+            logging.debug(f"Comparing with phrase: {phrase}")
             logging.debug(
-                f"Word Length Difference: {word_length_diff}, Similarity Score: {similarity_score}, Combined Score: {combined_score}")  # Log scores
+                f"Word Length Difference: {word_length_diff}, Similarity Score: {similarity_score}, Combined Score: {combined_score}")
 
             if combined_score > best_score:
                 best_score = combined_score
                 best_match = phrase
 
-        logging.debug(f"Closest phrase found: {best_match} with score: {best_score}")  # Log the best match
+        logging.debug(f"Closest phrase found: {best_match} with score: {best_score}")
         return best_match
 
-    def perform_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, include_torah, include_bible, include_quran, include_hindu, include_tripitaka, gematria_text, date_words_output, selected_date):
-        # Inside perform_search
+    def perform_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk,
+                       include_torah, include_bible, include_quran, include_hindu, include_tripitaka, gematria_text,
+                       date_words_output, selected_date):
         els_results = perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces,
-                                        strip_diacritics_chk, include_torah, include_bible, include_quran,
-                                        include_hindu,
-                                        include_tripitaka)
+                                         strip_diacritics_chk, include_torah, include_bible, include_quran,
+                                         include_hindu,
+                                         include_tripitaka)
 
-        # --- Network Search Integration ---
         most_frequent_phrases = {}
-        combined_and_sorted_results = []  # Combined list to hold all results
+        combined_and_sorted_results = []
 
         for book_name, book_results in els_results.items():
-            if book_results:  # Add this check to ensure book_results is not empty
-                most_frequent_phrases[book_name] = ""  # Default value
+            if book_results:
+                most_frequent_phrases[book_name] = ""
 
                 for result in book_results:
                     try:
-                        gematria_sum = calculate_gematria(result['result_text'])  # Calculate gematria
+                        gematria_sum = calculate_gematria(result['result_text'])
                         max_words = len(result['result_text'].split())
                         matching_phrases = search_gematria_in_db(gematria_sum, max_words)
                         max_words_limit = 20
-                        while not matching_phrases and max_words < max_words_limit:  # Increase max_words for more results
+                        while not matching_phrases and max_words < max_words_limit:
                             max_words += 1
                             matching_phrases = search_gematria_in_db(gematria_sum, max_words)
 
@@ -484,13 +691,13 @@ with gr.Blocks() as app:
                             most_frequent_phrases[book_name] = most_frequent_phrase
                         else:
                             closest_phrase = find_closest_phrase(result['result_text'],
-                                                                search_gematria_in_db(gematria_sum, max_words_limit))
+                                                                 search_gematria_in_db(gematria_sum, max_words_limit))
                             most_frequent_phrases[
-                                book_name] = closest_phrase or ""  # Update most frequent phrases even if no phrase found
+                                book_name] = closest_phrase or ""
 
                         result['Most Frequent Phrase'] = most_frequent_phrases[book_name]
                         if 'book' in result:
-                            if isinstance(result['book'], int):  # Torah, Bible, Quran case
+                            if isinstance(result['book'], int):
                                 result['book'] = f"{book_name} {result['book']}."
                         combined_and_sorted_results.append(result)
 
@@ -498,49 +705,46 @@ with gr.Blocks() as app:
                         print(f"DEBUG: KeyError - Key '{e.args[0]}' not found in result. Skipping this result.")
                         continue
 
-        # --- Batch Translation ---
         selected_language_long = tlang
         tlang_short = LANGUAGES_SUPPORTED.get(selected_language_long)
         if tlang_short is None:
             tlang_short = "en"
             logger.warning(f"Unsupported language selected: {selected_language_long}. Defaulting to English (en).")
 
-        # Prepare lists for batch translation, including source language
         phrases_to_translate = []
-        phrases_source_langs = []  # Source languages for phrases
+        phrases_source_langs = []
         results_to_translate = []
-        results_source_langs = []  # Source languages for results
+        results_source_langs = []
         for result in combined_and_sorted_results:
             phrases_to_translate.append(result.get('Most Frequent Phrase', ''))
-            # Always use 'iw' as the source language for "Most Frequent Phrase"
             phrases_source_langs.append("he")
             results_to_translate.append(result.get('result_text', ''))
             results_source_langs.append(result.get("source_language", "auto"))
 
-        translated_phrases = translation_utils.batch_translate(phrases_to_translate, tlang_short, phrases_source_langs)
-        translated_result_texts = translation_utils.batch_translate(results_to_translate, tlang_short, results_source_langs)
-
+        translated_phrases = translation_utils.batch_translate(phrases_to_translate, tlang_short,
+                                                               phrases_source_langs)
+        translated_result_texts = translation_utils.batch_translate(results_to_translate, tlang_short,
+                                                                    results_source_langs)
 
         for i, result in enumerate(combined_and_sorted_results):
             result['translated_text'] = translated_result_texts.get(results_to_translate[i], None)
             result['Translated Most Frequent Phrase'] = translated_phrases.get(phrases_to_translate[i], None)
 
-        # Time Projections (using els_results dictionary)
-        updated_els_results = add_24h_projection(els_results)  # Use original els_results dictionary
-        updated_els_results = add_monthly_projection(updated_els_results, selected_date)  # Call correct functions with correct params
+        updated_els_results = add_24h_projection(els_results)
+        updated_els_results = add_monthly_projection(updated_els_results, selected_date)
         updated_els_results = add_yearly_projection(updated_els_results, selected_date)
 
         combined_and_sorted_results = []
-        for book_results in updated_els_results.values():  # Combine results for dataframe and json
+        for book_results in updated_els_results.values():
             combined_and_sorted_results.extend(book_results)
-        combined_and_sorted_results = sort_results(combined_and_sorted_results)  # sort combined results
+        combined_and_sorted_results = sort_results(combined_and_sorted_results)
 
         df = pd.DataFrame(combined_and_sorted_results)
         df.index = range(1, len(df) + 1)
         df.reset_index(inplace=True)
         df.rename(columns={'index': 'Result Number'}, inplace=True)
 
-        for i, result in enumerate(combined_and_sorted_results):  # Iterate through the combined list
+        for i, result in enumerate(combined_and_sorted_results):
             result['Result Number'] = i + 1
 
         search_config = {
@@ -561,40 +765,44 @@ with gr.Blocks() as app:
 
         output_data = {
             "search_configuration": search_config,
-            "results": combined_and_sorted_results  # Use the combined list here
+            "results": combined_and_sorted_results
         }
 
         json_data = output_data
 
-        # --- Return results ---
         combined_most_frequent = "\n".join(
-            f"{book}: {phrase}" for book, phrase in most_frequent_phrases.items())  # Combine phrases
+            f"{book}: {phrase}" for book, phrase in most_frequent_phrases.items())
         return df, combined_most_frequent, json_data
 
-
-
     # --- Event Triggers ---
     round_x.change(update_rounds_combination, inputs=[round_x, round_y], outputs=rounds_combination)
     round_y.change(update_rounds_combination, inputs=[round_x, round_y], outputs=rounds_combination)
 
-    selected_date.change(update_date_words, inputs=[selected_date, date_language_input, use_day, use_month, use_year], outputs=[date_words_output])
-    date_language_input.change(update_date_words, inputs=[selected_date, date_language_input, use_day, use_month, use_year], outputs=[date_words_output])
+    selected_date.change(update_date_words, inputs=[selected_date, date_language_input, use_day, use_month, use_year],
+                         outputs=[date_words_output])
+    date_language_input.change(update_date_words,
+                               inputs=[selected_date, date_language_input, use_day, use_month, use_year],
+                               outputs=[date_words_output])
 
-    gematria_text.change(update_journal_sum, inputs=[gematria_text, date_words_output], outputs=[gematria_result, step, float_step])
-    date_words_output.change(update_journal_sum, inputs=[gematria_text, date_words_output], outputs=[gematria_result, step, float_step])
+    gematria_text.change(update_journal_sum, inputs=[gematria_text, date_words_output],
+                         outputs=[gematria_result, step, float_step])
+    date_words_output.change(update_journal_sum, inputs=[gematria_text, date_words_output],
+                             outputs=[gematria_result, step, float_step])
 
     half_step_btn.click(update_step_half, inputs=[float_step], outputs=[step, float_step])
     double_step_btn.click(update_step_double, inputs=[float_step], outputs=[step, float_step])
 
     translate_btn.click(
         perform_search,
-        inputs=[step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, include_torah_chk, include_bible_chk, include_quran_chk, include_hindu_chk, include_tripitaka_chk, gematria_text, date_words_output, selected_date],
+        inputs=[step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, include_torah_chk,
+                include_bible_chk, include_quran_chk, include_hindu_chk, include_tripitaka_chk, gematria_text,
+                date_words_output, selected_date],
         outputs=[markdown_output, most_frequent_phrase_output, json_output]
     )
 
     app.load(
         update_date_words,
-        inputs=[selected_date, date_language_input, use_day, use_month, use_year],  # Include all 5 inputs
+        inputs=[selected_date, date_language_input, use_day, use_month, use_year],
         outputs=[date_words_output]
     )
 
@@ -615,14 +823,13 @@ with gr.Blocks() as app:
     )
 
     def checkbox_behavior(use_day_value, use_month_value):
-        if use_day_value: # Tick month and year automatically when day is ticked.
+        if use_day_value:
             return True, True
 
-        return use_month_value, True # return  month value unchanged and automatically tick year if month is checked
+        return use_month_value, True
 
     use_day.change(checkbox_behavior, inputs=[use_day, use_month], outputs=[use_month, use_year])
-    use_month.change(checkbox_behavior, inputs=[use_day, use_month], outputs=[use_month, use_year]) #No need for use_day here, day won't be changed by month
-
+    use_month.change(checkbox_behavior, inputs=[use_day, use_month], outputs=[use_month, use_year])
 
 if __name__ == "__main__":
     app.launch(share=False)