Update app.py

app.py

@@ -3,340 +3,71 @@ logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
 
 import gradio as gr
-import torah
-import bible
-import quran
-from utils import number_to_ordinal_word, custom_normalize, date_to_words, translate_date_to_words
+from utils import date_to_words
 from gematria import calculate_gematria, strip_diacritics
-
-import pandas as pd
-from deep_translator import GoogleTranslator
-from gradio_calendar import Calendar
 from datetime import datetime, timedelta
-import math
 import json
-import re
-import sqlite3
-from collections import defaultdict
-from typing import List, Tuple
-
-# --- Constants ---
-DATABASE_FILE = 'gematria.db'
-MAX_PHRASE_LENGTH_LIMIT = 20
-
-# --- Database Initialization ---
-def initialize_database():
-    global conn
-    conn = sqlite3.connect(DATABASE_FILE)
-    cursor = conn.cursor()
-    cursor.execute('''
-    CREATE TABLE IF NOT EXISTS results (
-        gematria_sum INTEGER,
-        words TEXT,
-        translation TEXT,
-        book TEXT,
-        chapter INTEGER,
-        verse INTEGER,
-        phrase_length INTEGER,
-        word_position TEXT,
-        PRIMARY KEY (gematria_sum, words, book, chapter, verse, word_position)
-    )
-    ''')
-    cursor.execute('''
-    CREATE INDEX IF NOT EXISTS idx_results_gematria
-    ON results (gematria_sum)
-    ''')
-    cursor.execute('''
-    CREATE TABLE IF NOT EXISTS processed_books (
-        book TEXT PRIMARY KEY,
-        max_phrase_length INTEGER
-    )
-    ''')
-    conn.commit()
-
-# --- Initialize Database ---
-initialize_database()
-
-# --- Helper Functions (from Network app.py) ---
-def flatten_text(text: List) -> str:
-    if isinstance(text, list):
-        return " ".join(flatten_text(item) if isinstance(item, list) else item for item in text)
-    return text
 
-def search_gematria_in_db(gematria_sum: int, max_words: int) -> List[Tuple[str, str, int, int, int, str]]:
-    global conn
-    with sqlite3.connect(DATABASE_FILE) as conn:
-        cursor = conn.cursor()
-        cursor.execute('''
-        SELECT words, book, chapter, verse, phrase_length, word_position
-        FROM results
-        WHERE gematria_sum = ? AND phrase_length <= ?
-        ''', (gematria_sum, max_words))
-        results = cursor.fetchall()
-    return results
-
-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
-    return most_frequent_phrase
-
-# --- Functions from BOS app.py ---
-def create_language_dropdown(label, default_value='en', show_label=True):
-    languages = GoogleTranslator(source='en', target='en').get_supported_languages(as_dict=True)
-    return gr.Dropdown(
-      choices=list(languages.keys()),
-      label=label,
-      value=default_value,
-      show_label=show_label
-    )
-
-def calculate_gematria_sum(text, date_words):
-    if text or date_words:
-        combined_input = f"{text} {date_words}"
-        numbers = re.findall(r'\d+', combined_input)
-        text_without_numbers = re.sub(r'\d+', '', combined_input)
-        number_sum = sum(int(number) for number in numbers)
-        text_gematria = calculate_gematria(strip_diacritics(text_without_numbers))
-        total_sum = text_gematria + number_sum
-        return total_sum
+# --- Helper Functions ---
+def calculate_gematria_sum(text):
+    if text:
+        text_gematria = calculate_gematria(strip_diacritics(text))
+        return text_gematria
     else:
         return None
 
-def perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, merge_results, include_torah, include_bible, include_quran):
-    if step == 0 or rounds_combination == "0,0":
-        return None
-
-    torah_results = []
-    bible_results = []
-    quran_results = []
+def perform_gematria_calculation_for_date_range(start_date, end_date):
+    results = {}
+    delta = timedelta(days=1)
+    current_date = start_date
 
-    if include_torah:
-        torah_results.extend(torah.process_json_files(1, 39, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces, strip_diacritics))
+    while current_date <= end_date:
+        date_words = date_to_words(current_date, 'english')
+        gematria_sum = calculate_gematria_sum(date_words)
 
-    if include_bible:
-        bible_results.extend(bible.process_json_files(40, 66, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces, strip_diacritics))
+        if gematria_sum not in results:
+            results[gematria_sum] = []
 
-    if include_quran:
-        quran_results.extend(quran.process_json_files(1, 114, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces, strip_diacritics))
+        results[gematria_sum].append({
+            "date": current_date.strftime('%Y-%m-%d'),
+            "date_words": date_words
+        })
 
-    if merge_results:
-        results = []
-        max_length = max(len(torah_results), len(bible_results), len(quran_results))
-        for i in range(max_length):
-            if i < len(torah_results):
-                results.append(torah_results[i])
-            if i < len(bible_results):
-                results.append(bible_results[i])
-            if i < len(quran_results):
-                results.append(quran_results[i])
-    else:
-        results = torah_results + bible_results + quran_results
+        current_date += delta
 
     return results
 
-def generate_json_dump(start, end, initial_step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, search_phrase, results_df, start_date, end_date):
-    """Generates the JSON dump with configuration, date range, and results, including the initial step."""
-    config = {
-        "Start Book": start,
-        "End Book": end,
-        "Step": initial_step, # Use initial_step here
-        "Rounds": rounds_combination,
-        "Target Language": tlang,
-        "Strip Spaces": strip_spaces,
-        "Strip Text in Braces": strip_in_braces,
-        "Strip Diacritics": strip_diacritics_chk,
-        "Search Phrase": search_phrase
-    }
+def generate_json_output(results, start_date, end_date):
     result = {
-        "Configuration": config,
         "DateRange": {
             "StartDate": start_date.strftime("%Y-%m-%d"),
             "EndDate": end_date.strftime("%Y-%m-%d")
         },
-        "Results": json.loads(results_df.to_json(orient='records', force_ascii=False))
+        "Results": results
     }
-    logger.info(f"Generated JSON dump: {result}")
     return json.dumps(result, indent=4, ensure_ascii=False)
 
-def download_json_file(config_json, step, rounds_combination, strip_spaces, strip_in_braces, strip_diacritics_chk):
-    """Downloads the JSON config file with a descriptive name."""
-    filename_suffix = ""
-    if strip_spaces:
-        filename_suffix += "-stSp"
-    if strip_in_braces:
-        filename_suffix += "-stBr"
-    if strip_diacritics_chk:
-        filename_suffix += "-stDc"
-    file_path = f"step-{step}-rounds-{rounds_combination}{filename_suffix}.json"  # Include rounds in filename
-    with open(file_path, "w", encoding='utf-8') as file:
-        file.write(config_json)
-    logger.info(f"Downloaded JSON file to: {file_path}")
-    return file_path
-
-
 # --- Main Gradio App ---
 with gr.Blocks() as app:
     with gr.Row():
-        start_date = Calendar(type="datetime", label="Start Date")
-        end_date = Calendar(type="datetime", label="End Date")
-
-    with gr.Row():
-        tlang = create_language_dropdown("Target Language for Translation", default_value='english')
-        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")
-        gematria_result = gr.Number(label="Journal Sum")
-
-    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)
-        merge_results_chk = gr.Checkbox(label="Merge Results (Torah-Bible-Quran)", value=True)
+        start_date = gr.Calendar(type="datetime", label="Start Date")
+        end_date = gr.Calendar(type="datetime", label="End Date")
 
-        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.Textbox(label="JSON Configuration Output")
-    json_download_btn = gr.Button("Prepare .json for Download")
-    json_file = gr.File(label="Download Config JSON", file_count="single")
+    calculate_btn = gr.Button("Calculate Gematria for Date Range")
+    json_output = gr.Textbox(label="JSON Output")
 
     # --- Event Handlers ---
-    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 perform_search(start_date, end_date, date_language_input, step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, merge_results, include_torah, include_bible, include_quran, gematria_text):
-        all_results = []
-        delta = timedelta(days=1)
-        current_date = start_date
-
-        initial_step = step # Store the initial step value
-
-        while current_date <= end_date:
-            date_words_output = translate_date_to_words(current_date, date_language_input)
-            journal_sum, _, _ = update_journal_sum(gematria_text, date_words_output)
-            step = journal_sum # Update step for each date
-
-            els_results = perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, merge_results, include_torah, include_bible, include_quran)
-
-            # --- Network Search Integration ---
-            updated_els_results = []
-            texts_to_translate = []  # Collect texts for batch translation
-
-            for result in els_results:
-                logger.debug(f"Processing result: {result}") # Add debugging log
-                try:
-                    gematria_sum = calculate_gematria(result['result_text'])
-                    texts_to_translate.append(result['result_text']) # Add text for translation
-                except KeyError as e:
-                    print(f"DEBUG: KeyError - Key '{e.args[0]}' not found in result. Skipping this result.")
-                    continue
-
-                max_words = len(result['result_text'].split())
-                matching_phrases = search_gematria_in_db(gematria_sum, max_words)
-
-                # Iteratively increase max_words if no results are found
-                max_words_limit = 20  # Set a limit for max_words
-                while not matching_phrases and max_words < max_words_limit:
-                    max_words += 1
-                    matching_phrases = search_gematria_in_db(gematria_sum, max_words)
-
-                # Find most frequent phrase or first phrase with lowest word count
-                if matching_phrases:
-                    most_frequent_phrase = get_most_frequent_phrase(matching_phrases)
-                else:
-                    # Sort initial results by word count and take the first phrase
-                    sorted_results = sorted(search_gematria_in_db(gematria_sum, max_words_limit), key=lambda x: len(x[0].split()))
-                    most_frequent_phrase = sorted_results[0][0] if sorted_results else ""
-
-                # Add most frequent phrase, date, and date_words to the result dictionary
-                result['Most Frequent Phrase'] = most_frequent_phrase
-                result['Date'] = current_date.strftime('%Y-%m-%d')
-                result['Date Words'] = date_words_output
-                updated_els_results.append(result)
-
-            # --- Batch Translation ---
-            translator = GoogleTranslator(source='auto', target=tlang)
-            translated_texts = translator.translate_batch(texts_to_translate)
-
-            # --- Add Translated Texts to Results ---
-            for i, result in enumerate(updated_els_results):
-                result['Translated Text'] = translated_texts[i]
-
-            all_results.extend(updated_els_results)
-            current_date += delta
-
-        # --- Prepare Dataframe ---
-        df = pd.DataFrame(all_results)
-        df.index = range(1, len(df) + 1)
-        df.reset_index(inplace=True)
-        df.rename(columns={'index': 'Result Number'}, inplace=True)
-
-        # Find the most frequent phrase across all dates
-        all_phrases = [result['Most Frequent Phrase'] for result in all_results]
-        most_frequent_phrase = max(set(all_phrases), key=all_phrases.count) if all_phrases else ""
-
-        # Generate JSON output
-        search_phrase = f"{gematria_text}" # Removed date_words_output as it's now included in each result
-        config_json = generate_json_dump(1, 180, initial_step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, search_phrase, df, start_date, end_date)
-
-        return df, most_frequent_phrase, config_json
-
-    def handle_json_download(config_json, step, rounds_combination, strip_spaces, strip_in_braces, strip_diacritics_chk):
-        """Handles the download of the JSON config file."""
-        return download_json_file(config_json, step, rounds_combination, strip_spaces, strip_in_braces, strip_diacritics_chk)
-
+    def perform_calculation(start_date, end_date):
+        results = perform_gematria_calculation_for_date_range(start_date, end_date)
+        json_result = generate_json_output(results, start_date, end_date)
+        return json_result
 
     # --- 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)
-
-    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=[start_date, end_date, date_language_input, step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, merge_results_chk, include_torah_chk, include_bible_chk, include_quran_chk, gematria_text],
-        outputs=[markdown_output, most_frequent_phrase_output, json_output]
-    )
-
-    json_download_btn.click(
-        handle_json_download,
-        inputs=[json_output, step, rounds_combination, strip_spaces, strip_in_braces, strip_diacritics_chk],
-        outputs=[json_file]
+    calculate_btn.click(
+        perform_calculation,
+        inputs=[start_date, end_date],
+        outputs=[json_output]
     )
 
 if __name__ == "__main__":
-    app.launch(share=False)
+    app.launch(share=False)