implement result word count

app.py

@@ -21,6 +21,9 @@ book_names = {}
 # Pre-load Gematria values for common phrases to speed up search
 gematria_cache = {}
 
+# Dictionary to store translations
+translation_cache = {}
+
 def initialize_database():
     """Initializes the SQLite database."""
     global conn
@@ -45,6 +48,12 @@ def initialize_database():
         max_phrase_length INTEGER
     )
     ''')
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS translations (
+        hebrew_phrase TEXT PRIMARY KEY,
+        english_translation TEXT
+    )
+    ''')
 
 def initialize_translator():
     """Initializes the Google Translator."""
@@ -103,6 +112,12 @@ def populate_database(start_book, end_book, max_phrase_length=1):
                             gematria_sum = calculate_gematria(phrase_candidate.replace(" ", ""))
                             yield gematria_sum, phrase_candidate, title, chapter_id + 1, verse_id + 1
 
+            # Mark the book as processed with the current max_phrase_length
+            cursor.execute('''
+            INSERT OR REPLACE INTO processed_books (book, max_phrase_length)
+            VALUES (?, ?)
+            ''', (title, max_phrase_length))
+
 def insert_phrases_to_db(phrases):
     """Inserts a list of phrases into the database efficiently."""
     global conn
@@ -119,23 +134,26 @@ def insert_phrases_to_db(phrases):
 
 def get_translation(phrase):
     """Retrieves or generates the English translation of a Hebrew phrase."""
-    global translator, conn
-    cursor = conn.cursor()
-    cursor.execute('''
-    SELECT translation FROM results
-    WHERE words = ?
-    ''', (phrase,))
-    result = cursor.fetchone()
-    if result and result[0]:
-        return result[0]
+    global translator, conn, translation_cache
+    if phrase in translation_cache:
+        return translation_cache[phrase]
     else:
-        translation = translate_and_store(phrase)
+        cursor = conn.cursor()
         cursor.execute('''
-        UPDATE results
-        SET translation = ?
-        WHERE words = ?
-        ''', (translation, phrase))
-        return translation
+        SELECT english_translation FROM translations
+        WHERE hebrew_phrase = ?
+        ''', (phrase,))
+        result = cursor.fetchone()
+        if result and result[0]:
+            translation = result[0]
+            return translation
+        else:
+            translation = translate_and_store(phrase)
+            cursor.execute('''
+            INSERT OR IGNORE INTO translations (hebrew_phrase, english_translation)
+            VALUES (?, ?)
+            ''', (phrase, translation))
+            return translation
 
 def translate_and_store(phrase):
     """Translates a Hebrew phrase to English using Google Translate and handles potential errors."""
@@ -157,15 +175,22 @@ def translate_and_store(phrase):
     return "[Translation Error]"
 
 def search_gematria_in_db(gematria_sum, max_words):
-    """Searches the database for phrases with a given Gematria value and word count."""
+    """Searches the database for phrases with a given Gematria value and word count.
+       Returns phrases with word count <= max_words."""
     global conn
     cursor = conn.cursor()
     cursor.execute('''
-    SELECT words, book, chapter, verse FROM results WHERE gematria_sum = ? AND words LIKE '% %'
-    ''', (gematria_sum,))  # Add condition for phrases with at least 2 words
+    SELECT words, book, chapter, verse FROM results WHERE gematria_sum = ?
+    ''', (gematria_sum,))  # Retrieve all matching phrases first
     results = cursor.fetchall()
-    logging.debug(f"Found {len(results)} matching phrases for Gematria: {gematria_sum}")
-    return results
+    filtered_results = []
+    for words, book, chapter, verse in results:
+        # Filter by word count (including phrases with fewer words)
+        word_count = words.count(' ') + 1  # Count spaces to get word count
+        if word_count <= max_words:  # Include phrases with word count <= max_words
+            filtered_results.append((words, book, chapter, verse))
+    logging.debug(f"Found {len(filtered_results)} matching phrases for Gematria: {gematria_sum} after filtering.")
+    return filtered_results
 
 def gematria_search_interface(phrase, max_words, show_translation):
     """The main function for the Gradio interface."""
@@ -179,25 +204,33 @@ def gematria_search_interface(phrase, max_words, show_translation):
     phrase_gematria = calculate_gematria(phrase.replace(" ", ""))
     logging.info(f"Searching for phrases with Gematria: {phrase_gematria}")
 
+    # Debugging output
+    logging.debug(f"Phrase Gematria: {phrase_gematria}")
+    logging.debug(f"Max Words: {max_words}")
+
     # Check if Gematria is in cache
     if phrase_gematria in gematria_cache:
         matching_phrases = gematria_cache[phrase_gematria]
+        logging.debug(f"Retrieved matching phrases from cache.")
     else:
         # Search in the database
         matching_phrases = search_gematria_in_db(phrase_gematria, max_words)
         # Cache the results for future searches
         gematria_cache[phrase_gematria] = matching_phrases
+        logging.debug(f"Retrieved matching phrases from database.")
 
     if not matching_phrases:
         return "No matching phrases found."
 
     # Sort results by book, chapter, and verse
     sorted_phrases = sorted(matching_phrases, key=lambda x: (int(list(book_names.keys())[list(book_names.values()).index(x[1])]), x[2], x[3]))
+    logging.debug(f"Sorted matching phrases: {sorted_phrases}")
 
     # Group results by book
     results_by_book = defaultdict(list)
     for words, book, chapter, verse in sorted_phrases:
         results_by_book[book].append((words, chapter, verse))
+    logging.debug(f"Grouped results by book: {results_by_book}")
 
     # Format results for display
     results = []
@@ -265,20 +298,21 @@ def run_app():
     # Pre-populate the database
     logging.info("Starting database population...")
     phrases_to_insert = []  # Collect phrases before inserting in bulk
-    for gematria_sum, phrase, book, chapter, verse in tqdm(populate_database(1, 39, max_phrase_length=3), desc="Populating Database"):  # Books 1 to 39
-        phrases_to_insert.append((gematria_sum, phrase, book, chapter, verse))
-        if len(phrases_to_insert) >= 1000:  # Insert in batches of 1000 for efficiency
+    for max_phrase_length in range(1, 5):  # Populate for phrases up to 5 words
+        for gematria_sum, phrase, book, chapter, verse in tqdm(populate_database(1, 39, max_phrase_length=max_phrase_length), desc=f"Populating Database (Max Length: {max_phrase_length})"):  # Books 1 to 39
+            phrases_to_insert.append((gematria_sum, phrase, book, chapter, verse))
+            if len(phrases_to_insert) >= 1000:  # Insert in batches of 1000 for efficiency
+                insert_phrases_to_db(phrases_to_insert)
+                phrases_to_insert = []
+        if phrases_to_insert:  # Insert remaining phrases
             insert_phrases_to_db(phrases_to_insert)
-            phrases_to_insert = []
-    if phrases_to_insert:  # Insert remaining phrases
-        insert_phrases_to_db(phrases_to_insert)
     logging.info("Database population complete.")
 
     iface = gr.Interface(
         fn=gematria_search_interface,
         inputs=[
             gr.Textbox(label="Enter phrase"),
-            gr.Number(label="Max Word Count", value=2, minimum=1, maximum=10),
+            gr.Number(label="Max Word Count in Results", value=1, minimum=1, maximum=10),
             gr.Checkbox(label="Show Translation", value=True)
         ],
         outputs=gr.HTML(label="Results"),

gematria.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:608f20665f9880dbf665ef83b7a655d66cb01c5f1756aaa21dcc23d2bae5586e
-size 84742144
+oid sha256:a3fff2778c6444cf9818af0a203c662ca75d295b93c5921e1de8414dcaaf7650
+size 101384192

gematria.db-journal

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:df20400802de5bf6a4cb7e49dd564de73907a76b093ce7e9c523114544c2a325
-size 443744