greek gematria fix, ui fix

app.py

@@ -1,6 +1,7 @@
 import logging
+
 logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.DEBUG)
 
 import gradio as gr
 import torah
@@ -12,7 +13,7 @@ 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
+from datetime import datetime, timedelta
 import math
 import json
 import re
@@ -24,6 +25,7 @@ from typing import List, Tuple
 DATABASE_FILE = 'gematria.db'
 MAX_PHRASE_LENGTH_LIMIT = 20
 
+
 # --- Database Initialization ---
 def initialize_database():
     global conn
@@ -54,15 +56,18 @@ def initialize_database():
     ''')
     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:
@@ -75,6 +80,7 @@ def search_gematria_in_db(gematria_sum: int, max_words: int) -> List[Tuple[str,
         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:
@@ -82,16 +88,18 @@ def get_most_frequent_phrase(results):
     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
+        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}"
@@ -104,22 +112,30 @@ 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, merge_results, include_torah, include_bible, include_quran):
+
+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 = []
-    
+
     if include_torah:
-        torah_results.extend(torah.process_json_files(1, 39, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces, strip_diacritics))
-    
+        torah_results.extend(
+            torah.process_json_files(1, 39, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces,
+                                     strip_diacritics))
+
     if include_bible:
-        bible_results.extend(bible.process_json_files(40, 66, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces, strip_diacritics))
-    
+        bible_results.extend(
+            bible.process_json_files(40, 66, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces,
+                                     strip_diacritics))
+
     if include_quran:
-        quran_results.extend(quran.process_json_files(1, 114, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces, strip_diacritics))
+        quran_results.extend(
+            quran.process_json_files(1, 114, step, rounds_combination, 0, tlang, strip_spaces, strip_in_braces,
+                                     strip_diacritics))
 
     if merge_results:
         results = []
@@ -136,13 +152,59 @@ def perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_b
 
     return results
 
+
+def generate_json_dump(start, end, 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."""
+    config = {
+        "Start Book": start,
+        "End Book": end,
+        "Step": step,
+        "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
+    }
+    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))
+    }
+    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')
-        selected_date = Calendar(type="datetime", label="Date to investigate (optional)", info="Pick a date from the calendar")
-        date_language_input = create_language_dropdown("Language of the person/topic (optional) (Date Word Language)", default_value='english')
-        date_words_output = gr.Textbox(label="Date in Words Translated (optional)")
+        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")
@@ -150,14 +212,14 @@ with gr.Blocks() as app:
 
     with gr.Row():
         step = gr.Number(label="Jump Width (Steps) for ELS")
-        float_step = gr.Number(visible=False, value=1) 
+        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():
@@ -165,7 +227,7 @@ with gr.Blocks() as app:
         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)
-        
+
         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)
@@ -175,101 +237,128 @@ with gr.Blocks() as app:
     # --- 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")
 
-    # --- Event Handlers ---
-    def update_date_words(selected_date, date_language_input):
-        return translate_date_to_words(selected_date, date_language_input)
 
+    # --- 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(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, merge_results, include_torah, include_bible, include_quran, gematria_text, date_words_output):
-        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 = []
-        for result in els_results:
-            print("DEBUG: Result from perform_els_search:", result)
-            try:
-                gematria_sum = calculate_gematria(result['result_text'])
-            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
+    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
+
+        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
+
+            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 = []
+            for result in els_results:
+                try:
+                    gematria_sum = calculate_gematria(result['result_text'])
+                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)
 
-            # 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 to the result dictionary
-            result['Most Frequent Phrase'] = most_frequent_phrase
-
-            updated_els_results.append(result)
+                # 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)
+
+            all_results.extend(updated_els_results)
+            current_date += delta
 
         # --- Prepare Dataframe ---
-        df = pd.DataFrame(updated_els_results)
+        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)
 
-        return df, most_frequent_phrase
+        # 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, 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)
+
 
     # --- 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], outputs=[date_words_output])
-    date_language_input.change(update_date_words, inputs=[selected_date, date_language_input], 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])
-
     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, merge_results_chk, include_torah_chk, include_bible_chk, include_quran_chk, gematria_text, date_words_output],
-        outputs=[markdown_output, most_frequent_phrase_output]
+        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]
     )
 
-    app.load(
-        update_date_words, 
-        inputs=[selected_date, date_language_input], 
-        outputs=[date_words_output]
-    )
-    app.load(
-        update_journal_sum, 
-        inputs=[gematria_text, date_words_output], 
-        outputs=[gematria_result, step, float_step]
+    json_download_btn.click(
+        handle_json_download,
+        inputs=[json_output, step, rounds_combination, strip_spaces, strip_in_braces, strip_diacritics_chk],
+        outputs=[json_file]
     )
 
 if __name__ == "__main__":
-    app.launch(share=False)
+    app.launch(share=False)

bible.py

@@ -57,32 +57,62 @@ import os
 import re
 import csv
 
-def process_json_files(start=1, end=66, step=1, rounds="1", length=0, tlang="en", strip_spaces=True, strip_in_braces=True, strip_diacritics=True, average_compile=False):
+
+def process_json_files(start=1, end=66, step=1, rounds="1", length=0, tlang="en", strip_spaces=True,
+                       strip_in_braces=True, strip_diacritics=True, average_compile=False):
     file_name = "texts/bible/OpenGNT_version3_3.csv"
     translator = GoogleTranslator(source='auto', target=tlang)
     results = []
 
+    # Dictionary für die 27 Bücher des Neuen Testaments (Englische Namen)
+    nt_books = {
+        40: "Matthew",
+        41: "Mark",
+        42: "Luke",
+        43: "John",
+        44: "Acts",
+        45: "Romans",
+        46: "1. Corinthians",
+        47: "2. Corinthians",
+        48: "Galatians",
+        49: "Ephesians",
+        50: "Philippians",
+        51: "Colossians",
+        52: "1. Thessalonians",
+        53: "2. Thessalonians",
+        54: "1. Timothy",
+        55: "2. Timothy",
+        56: "Titus",
+        57: "Philemon",
+        58: "Hebrews",
+        59: "James",
+        60: "1. Peter",
+        61: "2. Peter",
+        62: "1. John",
+        63: "2. John",
+        64: "3. John",
+        65: "Jude",
+        66: "Revelation"
+    }
+
     try:
         with open(file_name, 'r', encoding='utf-8') as file:
             reader = csv.DictReader(file, delimiter='\t')
-            
+
             book_texts = {}
             current_book = None
             for row in reader:
-                #logger.debug(f"Processing row: {row}")
                 book = int(row['〔Book｜Chapter｜Verse〕'].split('｜')[0][1:])
                 if book < start or book > end:
-                    #logger.debug(f"Skipping book {book} (out of range)")
                     continue
                 if current_book != book:
                     current_book = book
                     book_texts[book] = ""
                 greek_text = row['〔OGNTk｜OGNTu｜OGNTa｜lexeme｜rmac｜sn〕']
-                greek_text = greek_text.split('〔')[1]  
+                greek_text = greek_text.split('〔')[1]
                 greek_text = greek_text.split('｜')[0]
-                #print(greek_text)
                 book_texts[book] += greek_text + " "
-            #print(book_texts)
+
             for book, full_text in book_texts.items():
                 logger.debug(f"Processing book {book}")
                 clean_text = full_text
@@ -103,7 +133,7 @@ def process_json_files(start=1, end=66, step=1, rounds="1", length=0, tlang="en"
                 for round_num in map(int, rounds.split(',')):
                     if not (round_num == 1 and step > text_length) and not (round_num == -1 and step > text_length):
                         if round_num > 0:
-                            current_position = step - 1 
+                            current_position = step - 1
                         else:
                             current_position = text_length - 1 if step == 1 else text_length - step
 
@@ -133,24 +163,25 @@ def process_json_files(start=1, end=66, step=1, rounds="1", length=0, tlang="en"
 
                 translated_text = translator.translate(result_text) if result_text else ""
 
+                result_sum = calculate_gematria(result_text)
+
                 if result_text:
                     logger.debug(f"Result for book {book}: {result_text}")
-                    results.append({
-                        "book": book,
-                        "result_text": result_text,
-                        "result_sum": calculate_gematria(result_text),
-                        "translated_text": translated_text
-                    })
+                    result = {
+                        'book': book,  # Use the correct 'book' variable
+                        'title': nt_books.get(book, "Unknown Book"),  # Get book name from dictionary
+                        'result_text': result_text,
+                        'result_sum': result_sum,  # Make sure result_sum is calculated correctly
+                        'translated_text': translated_text
+                    }
+                    results.append(result)
+
 
     except FileNotFoundError:
         results.append({"error": f"File {file_name} not found."})
 
     return results
-
-
-
-
-# Tests
+        # Tests
 test_results = [
     #(process_json_files(1, 1, 21, rounds="3", length=0), ""),
     #(process_json_files(1, 1, 22, rounds="1", length=0), ""), 

gematria.py

@@ -1,4 +1,7 @@
 import unicodedata
+import logging
+
+logger = logging.getLogger(__name__)
 
 def strip_diacritics(text):
     """
@@ -10,7 +13,7 @@ def strip_diacritics(text):
         if unicodedata.category(char) not in ['Mn', 'Cf']:
             stripped_text += char
         else:
-            print(f"Info: Diakritisches Zeichen '{char}' wird ignoriert.")
+            logger.info(f"Info: Diakritisches Zeichen '{char}' wird ignoriert.")
     return stripped_text
 
 def letter_to_value(letter):
@@ -75,6 +78,8 @@ def letter_to_value(letter):
     'Σ': 200, 'Τ': 300, 'Υ': 400, 'Φ': 500, 'Χ': 600, 'Ψ': 700, 'Ω': 800, 'Ϡ': 900,
     'σ': 200,  # Sigma
     'ς': 200,  # Final Sigma
+    'ϲ': 200,  # Lunate Sigma (Greek)
+    'Ϲ': 200,  # Uppercase Lunate Sigma (Greek)
     }
 
     # Stelle sicher, dass Diakritika entfernt werden, bevor auf das Wörterbuch zugegriffen wird
@@ -86,7 +91,7 @@ def letter_to_value(letter):
         return 0
     else:
         # Gib eine spezifische Warnung aus, wenn das Zeichen unbekannt ist
-        print(f"Warnung: Unbekanntes Zeichen '{letter}' ignoriert.")
+        logger.info(f"Warnung: Unbekanntes Zeichen '{letter}' ignoriert.")
         return 0