initial commit

app.py

@@ -28,6 +28,7 @@ from fuzzywuzzy import fuzz
 import calendar
 import translation_utils
 import hashlib
+import time
 
 translation_utils.create_translation_table()
 
@@ -166,110 +167,29 @@ 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):
-    if step == 0 or rounds_combination == "0,0":
-        return None
-
-    results = {}
-    length = 0
-
-    selected_language_long = tlang  # From the Gradio dropdown (long form)
-    tlang = LANGUAGES_SUPPORTED.get(selected_language_long) #Get the short code.
-    if tlang is None: # Handle unsupported languages
-        tlang = "en"
-        logger.warning(f"Unsupported language selected: {selected_language_long}. Defaulting to English (en).")
-
-    if include_torah:
-        logger.debug(f"Arguments for Torah: {(1, 39, step, rounds_combination, length, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)}")
-        results["Torah"] = cached_process_json_files(torah.process_json_files, 1, 39, step, rounds_combination, length, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
-    else:
-        results["Torah"] = []
-
-    if include_bible:
-        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, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
-    else:
-        results["Quran"] = []
+def add_24h_projection(results_dict, date_str):  # Add date_str as parameter
+    combined_results = []
+    for book_name, results in results_dict.items():
+        combined_results.extend(results)
 
-    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)
-    else:
-        results["Rig Veda"] = []
+    num_results = len(combined_results)
+    if num_results > 0:
+        time_interval = timedelta(minutes=24 * 60 / num_results)
+        current_datetime = datetime.combine(datetime.today(), datetime.min.time())
+        for i in range(num_results):
+            next_datetime = current_datetime + time_interval
+            time_range_str = f"{current_datetime.strftime('%H:%M')}-{next_datetime.strftime('%H:%M')}"
+            combined_results[i]['24h Projection'] = time_range_str
+            current_datetime = next_datetime
 
-    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)
-    else:
-        results["Tripitaka"] = []
+    # Re-organize results back into their book dictionaries
+    reorganized_results = defaultdict(list)
+    for result in combined_results:
+        book_name = result.get('book', 'Unknown') #Get book name to reorganize
+        reorganized_results[book_name].append(result)
 
-    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
-        num_results = len(results)
-        if num_results > 0:
-            time_interval = timedelta(minutes=24 * 60 / num_results)
-            current_time = datetime.min.time()
-            for i in range(num_results):
-                next_time = (datetime.combine(datetime.min, current_time) + time_interval).time()
-                time_range_str = f"{current_time.strftime('%H:%M')}-{next_time.strftime('%H:%M')}"
-                results[i]['24h Projection'] = time_range_str
-                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
-
-    for book_name, results in results_dict.items():  # Iterate per book
-        num_results = len(results)
-        if num_results > 0:
-            days_in_month = calendar.monthrange(selected_date.year, selected_date.month)[1]
-            total_seconds = (days_in_month - 1) * 24 * 3600
-            seconds_interval = total_seconds / num_results
-            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
-                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
-    return results_dict
-
-
-def add_yearly_projection(results_dict, selected_date): #Correct name, handle dictionary input
-    if selected_date is None:
-        return results_dict  # Return if no date is selected
-
-    for book_name, results in results_dict.items(): # Iterate per book
-        num_results = len(results)
-        if num_results > 0:
-            days_in_year = 366 if calendar.isleap(selected_date.year) else 365
-            total_seconds = (days_in_year - 1) * 24 * 3600
-            seconds_interval = total_seconds / num_results
-            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
-                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
-
-    return results_dict
+    return reorganized_results
 
 
 def sort_results(results):
@@ -290,24 +210,17 @@ 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")
+            start_date_range = Calendar(type="datetime", label="Start Date for ELS")
+            end_date_range = Calendar(type="datetime", label="End Date for ELS")
             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)
@@ -335,48 +248,9 @@ with gr.Blocks() as app:
 
     # --- Event Handlers ---
 
-    def update_date_words(selected_date, date_language_input, use_day, use_month, use_year):
-        if selected_date is None:
-            return ""
-
-        if not use_year and not use_month and not use_day:
-            return translate_date_to_words(selected_date, date_language_input)
-
-        year = selected_date.year if use_year else None
-        month = selected_date.month if use_month else None
-        day = selected_date.day if use_day else None
-
-        if year is not None and month is not None and day is not None:
-            date_obj = selected_date
-        elif year is not None and month is not None:
-            date_obj = str(f"{year}-{month}")
-        elif year is not None:
-            date_obj = str(f"{year}")
-        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)
-
-    def update_journal_sum(gematria_text, date_words_output):
-        sum_value = calculate_gematria_sum(gematria_text, date_words_output)
-        return sum_value, sum_value, sum_value
-
     def update_rounds_combination(round_x, round_y):
         return f"{int(round_x)},{int(round_y)}"
 
-    def update_step_half(float_step):
-        new_step = math.ceil(float_step / 2)
-        return new_step, float_step / 2
-
-    def update_step_double(float_step):
-        new_step = math.ceil(float_step * 2)
-        return new_step, float_step * 2
 
 
     def find_closest_phrase(target_phrase, phrases):
@@ -401,98 +275,146 @@ with gr.Blocks() as app:
         logging.debug(f"Closest phrase found: {best_match} with score: {best_score}")  # Log the best match
         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
-        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)
 
-        # --- Network Search Integration ---
+    def perform_search(rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, include_torah, include_bible, include_quran, include_hindu, include_tripitaka, gematria_text, start_date, end_date, date_language_input):
+        overall_start_time = time.time()
+
+        combined_and_sorted_results = []
         most_frequent_phrases = {}
-        combined_and_sorted_results = []  # Combined list to hold all 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
-
-                for result in book_results:
-                    try:
-                        gematria_sum = calculate_gematria(result['result_text'])  # Calculate gematria
-                        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
-                            max_words += 1
-                            matching_phrases = search_gematria_in_db(gematria_sum, max_words)
-
-                        if matching_phrases:
-                            most_frequent_phrase = get_most_frequent_phrase(matching_phrases)
-                            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))
-                            most_frequent_phrases[
-                                book_name] = closest_phrase or ""  # Update most frequent phrases even if no phrase found
-
-                        result['Most Frequent Phrase'] = most_frequent_phrases[book_name]
-                        if 'book' in result:
-                            if isinstance(result['book'], int):  # Torah, Bible, Quran case
-                                result['book'] = f"{book_name} {result['book']}."
-                        combined_and_sorted_results.append(result)
-
-                    except KeyError as e:
-                        print(f"DEBUG: KeyError - Key '{e.args[0]}' not found in result. Skipping this result.")
-                        continue
+
+        current_date = start_date
+        while current_date <= end_date:
+            date_str = current_date.strftime("%Y-%m-%d")
+            date_words = translate_date_to_words(current_date, date_language_input)
+
+            step = calculate_gematria_sum(gematria_text, date_words)
+            logger.debug(f"Calculated step for {date_str}: {step}")
+
+            if step != 0 and rounds_combination != "0,0":
+                # Process for the current date
+                els_results_single_date = {}
+                if include_torah:
+                    els_results_single_date["Torah"] = cached_process_json_files(torah.process_json_files, 1, 39, step,
+                                                                            rounds_combination, 0, tlang, strip_spaces,
+                                                                            strip_in_braces, strip_diacritics_chk)
+                if include_bible:
+                    els_results_single_date["Bible"] = cached_process_json_files(bible.process_json_files, 40, 66, step,
+                                                                            rounds_combination, 0, tlang, strip_spaces,
+                                                                            strip_in_braces, strip_diacritics_chk)
+                if include_quran:
+                    els_results_single_date["Quran"] = cached_process_json_files(quran.process_json_files, 1, 114, step,
+                                                                            rounds_combination, 0, tlang, strip_spaces,
+                                                                            strip_in_braces, strip_diacritics_chk)
+                if include_hindu:
+                    els_results_single_date["Rig Veda"] = cached_process_json_files(hindu.process_json_files, 1, 10, step,
+                                                                                rounds_combination, 0, tlang, False,
+                                                                                strip_in_braces, strip_diacritics_chk)
+                if include_tripitaka:
+                    els_results_single_date["Tripitaka"] = cached_process_json_files(tripitaka.process_json_files, 1, 52,
+                                                                                    step, rounds_combination, 0, tlang,
+                                                                                    strip_spaces, strip_in_braces,
+                                                                                    strip_diacritics_chk)
+
+                # Add 24h projection *before* iterating through books
+                els_results_single_date = add_24h_projection(els_results_single_date, date_str)
+
+                for book_name, book_results in els_results_single_date.items():
+                    logger.debug(f"Processing results for book: {book_name}")
+                    if book_results:
+                        most_frequent_phrases[book_name] = ""
+                        for result in book_results:
+                            try:
+                                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:
+                                    max_words += 1
+                                    matching_phrases = search_gematria_in_db(gematria_sum, max_words)
+
+                                if matching_phrases:
+                                    most_frequent_phrase = get_most_frequent_phrase(matching_phrases)
+                                    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))
+                                    most_frequent_phrases[book_name] = closest_phrase or ""
+
+                                result['Most Frequent Phrase'] = most_frequent_phrases[book_name]
+                                result['date'] = date_str
+                                if 'book' in result:
+                                    if isinstance(result['book'], int):
+                                        result['book'] = f"{book_name} {result['book']}."
+
+                            except KeyError as e:
+                                print(f"DEBUG: KeyError - Key '{e.args[0]}' not found in result. Skipping this result.")
+                                continue
+
+
+                    combined_and_sorted_results.extend(book_results)
+
+
+
+            current_date += timedelta(days=1)
 
         # --- Batch Translation ---
+        translation_start_time = time.time()
         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).")
+            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', ''))
             phrases_source_langs.append(result.get("source_language", "auto"))
             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)
 
-
         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)
+            result['translated_text'] = translated_result_texts.get(results_to_translate[i], result.get('result_text', ''))
+            result['Translated Most Frequent Phrase'] = translated_phrases.get(phrases_to_translate[i],
+                                                                            result.get('Most Frequent Phrase', ''))
 
-        # 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_yearly_projection(updated_els_results, selected_date)
+        translation_end_time = time.time()
+        logger.debug(f"Batch translation took: {translation_end_time - translation_start_time} seconds")
 
-        combined_and_sorted_results = []
-        for book_results in updated_els_results.values():  # Combine results for dataframe and json
-            combined_and_sorted_results.extend(book_results)
-        combined_and_sorted_results = sort_results(combined_and_sorted_results)  # sort combined results
+        # --- Time projections ---
+        time_projections_start_time = time.time()
+        for result in combined_and_sorted_results:
+            selected_date = datetime.strptime(result['date'], '%Y-%m-%d')
+            book_name = result.get('book', 'Unknown')
+            projection_input = {book_name: [result]}
+
+            updated_date_results = add_24h_projection(projection_input, result['date'])
+
+            result.update(updated_date_results[book_name][0])
+
+        combined_and_sorted_results = sort_results(combined_and_sorted_results)
+        time_projections_end_time = time.time()
+        logger.debug(
+            f"Time projections took: {time_projections_end_time - time_projections_start_time} seconds")
+
+        # --- Dataframe and JSON creation ---
+        dataframe_json_start_time = time.time()
 
         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
-            result['Result Number'] = i + 1
-
         search_config = {
-            "step": step,
-            "rounds_combination": rounds_combination,
+            "rounds_combination": rounds_combination,  # No more 'step'
             "target_language": tlang,
             "strip_spaces": strip_spaces,
             "strip_in_braces": strip_in_braces,
@@ -503,72 +425,47 @@ with gr.Blocks() as app:
             "include_hindu": include_hindu,
             "include_tripitaka": include_tripitaka,
             "gematria_text": gematria_text,
-            "date_words": date_words_output
+            "start_date": start_date.strftime("%Y-%m-%d"),
+            "end_date": end_date.strftime("%Y-%m-%d")
         }
 
         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
-        return df, combined_most_frequent, json_data
+            f"{book}: {phrase}" for book, phrase in most_frequent_phrases.items() if phrase)
 
+        dataframe_json_end_time = time.time()
+        logger.debug(
+            f"Dataframe and JSON creation took: {dataframe_json_end_time - dataframe_json_start_time} seconds")
 
+        overall_end_time = time.time()
+        logger.debug(f"Overall process took: {overall_end_time - overall_start_time} seconds")
+
+        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])
 
-    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])
+    def update_rounds_combination(round_x, round_y):
+        return f"{int(round_x)},{int(round_y)}"
+
+
+    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)
 
-    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=[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, start_date_range, end_date_range, date_language_input],
         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
-        outputs=[date_words_output]
-    )
-
-    use_day.change(
-        update_date_words,
-        inputs=[selected_date, date_language_input, use_day, use_month, use_year],
-        outputs=[date_words_output]
-    )
-    use_month.change(
-        update_date_words,
-        inputs=[selected_date, date_language_input, use_day, use_month, use_year],
-        outputs=[date_words_output]
-    )
-    use_year.change(
-        update_date_words,
-        inputs=[selected_date, date_language_input, use_day, use_month, use_year],
-        outputs=[date_words_output]
-    )
-
-    def checkbox_behavior(use_day_value, use_month_value):
-        if use_day_value: # Tick month and year automatically when day is ticked.
-            return True, True
-
-        return use_month_value, True # return  month value unchanged and automatically tick year if month is checked
-
-    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
 
 
 if __name__ == "__main__":