change to multi-line input (comparison)

app.py

@@ -6,6 +6,7 @@ import logging
 from collections import defaultdict
 from typing import Tuple, Dict, List
 
+# Assuming you have these files in your project
 from util import process_json_files
 from gematria import calculate_gematria
 from deep_translator import GoogleTranslator, exceptions
@@ -18,7 +19,7 @@ MAX_PHRASE_LENGTH_LIMIT = 20
 BATCH_SIZE = 10000
 
 # Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Global variables
 conn: sqlite3.Connection = None
@@ -45,7 +46,7 @@ def initialize_database() -> None:
         verse INTEGER,
         phrase_length INTEGER,
         word_position TEXT, 
-        PRIMARY KEY (gematria_sum, words, book, chapter, verse, word_position)  -- Primary key constraint
+        PRIMARY KEY (gematria_sum, words, book, chapter, verse, word_position)
     )
     ''')
 
@@ -208,82 +209,192 @@ def search_gematria_in_db(gematria_sum: int, max_words: int) -> List[Tuple[str,
     return results
 
 
-def gematria_search_interface(phrase: str, max_words: int, show_translation: bool) -> str:
-    """The main function for the Gradio interface."""
-    if not phrase.strip():
-        return "Please enter a phrase."
-
+def gematria_search_interface(phrases: str, max_words: int, show_translation: bool) -> str:
+    """The main function for the Gradio interface, handling multiple phrases."""
     global conn, book_names, gematria_cache
 
-    numbers = re.findall(r'\d+', phrase)
-    text_without_numbers = re.sub(r'\d+', '', phrase)
-    phrase_gematria = calculate_gematria(text_without_numbers.replace(" ", ""))
-    phrase_gematria += sum(int(number) for number in numbers)
-
-    if (phrase_gematria, max_words) in gematria_cache:
-        matching_phrases = gematria_cache[(phrase_gematria, max_words)]
-    else:
-        matching_phrases = search_gematria_in_db(phrase_gematria, max_words)
-        gematria_cache[(phrase_gematria, max_words)] = matching_phrases
-
-    if not matching_phrases:
-        return "No matching phrases found."
-
-    sorted_phrases = sorted(matching_phrases,
-                            key=lambda x: (int(list(book_names.keys())[list(book_names.values()).index(x[1])]), x[2], x[3]))
-    results_by_book = defaultdict(list)
-    for words, book, chapter, verse, phrase_length, word_position in sorted_phrases:
-        results_by_book[book].append((words, chapter, verse, phrase_length, word_position))
-
     results = []
-    results.append("<div class='results-container'>")
-    for book, phrases in results_by_book.items():
-        for words, chapter, verse, phrase_length, word_position in phrases:
+    all_results = []  # Store results for each phrase
+    middle_words_results = []  # Store middle word results for all books
+
+    phrases = phrases.strip().splitlines()
+    if not phrases:
+        return "Please enter at least one phrase."
+
+    for phrase in phrases:
+        if not phrase.strip():
+            continue  # Skip empty lines
+
+        numbers = re.findall(r'\d+', phrase)
+        text_without_numbers = re.sub(r'\d+', '', phrase)
+        phrase_gematria = calculate_gematria(text_without_numbers.replace(" ", ""))
+        phrase_gematria += sum(int(number) for number in numbers)
+
+        if (phrase_gematria, max_words) in gematria_cache:
+            matching_phrases = gematria_cache[(phrase_gematria, max_words)]
+        else:
+            matching_phrases = search_gematria_in_db(phrase_gematria, max_words)
+            gematria_cache[(phrase_gematria, max_words)] = matching_phrases
+
+        if not matching_phrases:
+            results.append(f"No matching phrases found for: {phrase}")
+            continue
+
+        sorted_phrases = sorted(matching_phrases,
+                                key=lambda x: (int(list(book_names.keys())[list(book_names.values()).index(x[1])]), x[2],
+                                               x[3]))
+        results_by_book = defaultdict(list)
+        for words, book, chapter, verse, phrase_length, word_position in sorted_phrases:
+            results_by_book[book].append((words, chapter, verse, phrase_length, word_position))
+
+        results.append(f"<h2>Results for: {phrase} (Gematria: {phrase_gematria})</h2>")
+        results.append("<div class='results-container'>")
+        for book, phrases in results_by_book.items():
+            for words, chapter, verse, phrase_length, word_position in phrases:
+                translation = get_translation(words) if show_translation else ""
+                link = f"https://www.biblegateway.com/passage/?search={quote_plus(book)}+{chapter}%3A{verse}&version=CJB"
+                results.append(f"""
+                <div class='result-item'>
+                  <p><b>Book:</b> {book}</p>
+                  <p><b>Chapter:</b> {chapter}, <b>Verse:</b> {verse}</p>
+                  <p class='hebrew-phrase'><b>Hebrew Phrase:</b> {words}</p>
+                  <p><b>Translation:</b> {translation}</p>
+                  <p><b>Phrase Length:</b> {phrase_length} words</p>
+                  <p><b>Phrase Gematria:</b> {phrase_gematria}</p>
+                  <p><b>Word Position in the Tanach:</b> {word_position}</p> 
+                  <a href='{link}' target='_blank' class='bible-link'>[See on Bible Gateway]</a>
+                </div>
+                """)
+        results.append("</div>")
+
+        all_results.append(results_by_book)  # Store results by book without the phrase
+
+    # Calculate middle words for all input lines
+    if len(all_results) >= 2:
+        results.append("<h2>Middle Words:</h2>")
+        results.append("<div class='results-container'>")
+
+        common_books = set.intersection(*[set(results.keys()) for results in all_results])
+        logging.debug(f"Common books: {common_books}")
+
+        for book in common_books:
+            logging.debug(f"Processing book: {book}")
+
+            # Find nearest positions for all phrases in the current book
+            nearest_positions = find_nearest_positions([results[book] for results in all_results])
+            logging.debug(f"Nearest positions in {book}: {nearest_positions}")
+
+            if nearest_positions:
+                middle_word_position = sum(nearest_positions) / len(nearest_positions)
+                logging.debug(f"Calculated middle word position in {book}: {middle_word_position}")
+
+                start_position = int(middle_word_position)
+                end_position = start_position + 1 if middle_word_position % 1 != 0 else start_position
+                logging.debug(f"Middle word position range in {book}: {start_position}-{end_position}")
+
+                middle_words_data = get_words_from_db(book, start_position, end_position)
+                logging.debug(f"Middle words data fetched from database: {middle_words_data}")
+
+                if middle_words_data:
+                    # Store middle word data along with book name for sorting
+                    middle_words_results.extend([(book, data) for data in middle_words_data])
+                else:
+                    # Handle edge case: fetch words independently for start and end positions
+                    logging.debug(f"No middle words found for range {start_position}-{end_position}. "
+                                  f"Fetching words independently.")
+                    middle_words_data_start = get_words_from_db(book, start_position, start_position)
+                    middle_words_data_end = get_words_from_db(book, end_position, end_position)
+
+                    if middle_words_data_start or middle_words_data_end:
+                        middle_words_results.extend([(book, data) for data in middle_words_data_start + middle_words_data_end])
+
+        # Sort middle words results by book order before displaying
+        middle_words_results.sort(key=lambda x: int(list(book_names.keys())[list(book_names.values()).index(x[0])]))
+
+        for book, (words, chapter, verse, phrase_length, word_position) in middle_words_results:
             translation = get_translation(words) if show_translation else ""
             link = f"https://www.biblegateway.com/passage/?search={quote_plus(book)}+{chapter}%3A{verse}&version=CJB"
             results.append(f"""
-            <div class='result-item'>
-              <p><b>Book:</b> {book}</p>
-              <p><b>Chapter:</b> {chapter}, <b>Verse:</b> {verse}</p>
-              <p class='hebrew-phrase'><b>Hebrew Phrase:</b> {words}</p>
-              <p><b>Translation:</b> {translation}</p>
-              <p><b>Phrase Length:</b> {phrase_length} words</p>
-              <p><b>Phrase Gematria:</b> {phrase_gematria}</p>
-              <p><b>Word Position in the Tanach:</b> {word_position}</p> 
-              <a href='{link}' target='_blank' class='bible-link'>[See on Bible Gateway]</a>
-            </div>
-            """)
-    results.append("</div>")
+                        <div class='result-item'>  
+                          <p><b>Book:</b> {book}</p>
+                          <p><b>Chapter:</b> {chapter}, <b>Verse:</b> {verse}</p>
+                          <p class='hebrew-phrase'><b>Hebrew Phrase:</b> {words}</p>
+                          <p><b>Translation:</b> {translation}</p>
+                          <p><b>Phrase Length:</b> {phrase_length} words</p>
+                          <p><b>Word Position in the Tanach:</b> {word_position}</p>
+                          <a href='{link}' target='_blank' class='bible-link'>[See on Bible Gateway]</a>
+                        </div>
+                        """)
+        results.append("</div>")
 
     # Style modified to position search on top and results below
     style = """
-    <style>
-      .results-container {
-        display: grid;
-        grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-        gap: 20px;
-        width: 100%;  /* Make results container take full width */
-      }
-      .result-item {
-        border: 1px solid #ccc;
-        padding: 15px;
-        border-radius: 5px;
-        box-shadow: 2px 2px 5px rgba(0, 0, 0, 0.1);
-      }
-      .hebrew-phrase {
-        font-family: 'SBL Hebrew', 'Ezra SIL', serif;
-        direction: rtl;
-      }
-      .bible-link {
-        display: block;
-        margin-top: 10px;
-        color: #007bff;
-        text-decoration: none;
-      }
-    </style>
-    """
+        <style>
+          .results-container {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 20px;
+            width: 100%;  /* Make results container take full width */
+          }
+          .result-item {
+            border: 1px solid #ccc;
+            padding: 15px;
+            border-radius: 5px;
+            box-shadow: 2px 2px 5px rgba(0, 0, 0, 0.1);
+          }
+          .hebrew-phrase {
+            font-family: 'SBL Hebrew', 'Ezra SIL', serif;
+            direction: rtl;
+          }
+          .bible-link {
+            display: block;
+            margin-top: 10px;
+            color: #007bff;
+            text-decoration: none;
+          }
+        </style>
+        """
     return style + "\n".join(results)
 
+def find_nearest_positions(results_lists: List[List]) -> List[int]:
+    """Finds the nearest word positions among multiple lists of results."""
+    nearest_positions = []
+    for i in range(len(results_lists)):
+        positions_i = [(int(pos.split('-')[0]), int(pos.split('-')[1])) for _, _, _, _, pos in results_lists[i]]  # Get start and end positions
+        min_distance = float('inf')
+        nearest_pos_start = None
+        nearest_pos_end = None
+        for j in range(len(results_lists)):
+            if i == j:
+                continue
+            positions_j = [(int(pos.split('-')[0]), int(pos.split('-')[1])) for _, _, _, _, pos in results_lists[j]]  # Get start and end positions
+            for pos_i_start, pos_i_end in positions_i:
+                for pos_j_start, pos_j_end in positions_j:
+                    distance = abs((pos_i_start + pos_i_end) // 2 - (pos_j_start + pos_j_end) // 2)
+                    if distance < min_distance:
+                        min_distance = distance
+                        nearest_pos_start = pos_i_start  # Take the start position from the first list
+                        nearest_pos_end = pos_i_end  # Take the end position from the first list
+        if nearest_pos_start is not None and nearest_pos_end is not None:
+            nearest_positions.extend([nearest_pos_start, nearest_pos_end])
+    return nearest_positions
+
+
+def get_words_from_db(book: str, start_position: int, end_position: int) -> List[Tuple]:
+    """Fetches words from the database based on the book and exact word position range."""
+    global conn
+    logging.debug(f"Fetching words from database for {book} at positions {start_position}-{end_position}")
+    with sqlite3.connect(DATABASE_FILE) as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+            SELECT words, chapter, verse, phrase_length, word_position
+            FROM results
+            WHERE book = ? AND word_position = ?
+        """, (book, f"{start_position}-{end_position}"))  # Directly compare word_position
+        results = cursor.fetchall()
+        logging.debug(f"Words fetched from database: {results}")
+    return results
+
 
 def flatten_text(text: List) -> str:
     """Flattens nested lists into a single list."""
@@ -305,8 +416,9 @@ def run_app() -> None:
 
     with gr.Blocks() as iface:  # Use gr.Blocks() for layout control
         with gr.Row():  # Place inputs in a row
-            textbox = gr.Textbox(label="Enter word(s) or numbers")
-            slider = gr.Slider(label="Max Word Count in Result Phrases", minimum=1, maximum=MAX_PHRASE_LENGTH_LIMIT, step=1,
+            textbox = gr.Textbox(label="Enter word(s) or numbers (one phrase per line)", lines=5)
+            slider = gr.Slider(label="Max Word Count in Result Phrases", minimum=1,
+                              maximum=MAX_PHRASE_LENGTH_LIMIT, step=1,
                               value=1)
             checkbox = gr.Checkbox(label="Show Translation", value=True)
         with gr.Row():  # Place buttons in a row