fix word position

app.py

@@ -6,6 +6,7 @@ import gradio as gr
 from deep_translator import GoogleTranslator, exceptions
 
 from utils import process_json_files, flatten_text_with_line_breaks, calculate_tanach_statistics, build_word_index
+import unittest
 
 # Set up logging
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -16,13 +17,22 @@ WORD_INDEX = build_word_index(TANACH_DATA)
 
 # --- Utility Functions ---
 
-def get_current_word_data():
-    """Gets data about the current word based on the current time."""
-    total_seconds = int(datetime.datetime.now().strftime("%H")) * 3600 + \
-                   int(datetime.datetime.now().strftime("%M")) * 60 + \
-                   int(datetime.datetime.now().strftime("%S"))
-    word_position = total_seconds % len(WORD_INDEX)
-    return WORD_INDEX.get(word_position), word_position
+def get_current_word_data(client_time_str):
+    """Gets data about the current word based on the client's time."""
+    try:
+        client_time = datetime.datetime.strptime(client_time_str, "%H:%M:%S")
+        total_seconds = int(client_time.strftime("%H")) * 3600 + \
+                        int(client_time.strftime("%M")) * 60 + \
+                        int(client_time.strftime("%S"))
+
+        # Find the closest key in WORD_INDEX
+        word_position = min(WORD_INDEX.keys(), key=lambda k: abs(k - total_seconds))
+
+        return WORD_INDEX[word_position], word_position
+    except Exception as e:
+        logging.error(f"Error processing client time: {e}")
+        return None, None
+
 
 def get_formatted_verse(book_id, chapter_id, verse_id, highlight_word=True):
     """Returns a formatted verse with optional word highlighting."""
@@ -31,7 +41,7 @@ def get_formatted_verse(book_id, chapter_id, verse_id, highlight_word=True):
 
     if highlight_word:
         flattened_chapter[verse_id - 1] = \
-            f"<span class='highlight'>{flattened_chapter[verse_id - 1]}</span>"
+          f"<span class='highlight'>{flattened_chapter[verse_id - 1]}</span>"
 
     return '<br>'.join(flattened_chapter)
 
@@ -52,19 +62,21 @@ def translate_verse(hebrew_verse, verse_id, highlight_word=True):
 
 # --- Gradio Interface ---
 
-def update_tanach_display():
-    """Updates the Gradio interface with current time, verse info, and translations."""
-    current_time = datetime.datetime.now().strftime("%H:%M:%S")
-    word_data, word_position = get_current_word_data()
+def update_tanach_display(client_time_str):
+    """Updates the Gradio interface with client time, verse info, and translations."""
+
+    word_data, word_position = get_current_word_data(client_time_str)
 
     if word_data is None:
         logging.error(f"Word position {word_position} not found in index.")
-        return current_time, "Error: Word not found", "", ""
+        return "Error: Word not found", "", ""
 
     book_id = word_data["book_id"]
     chapter_id = word_data["chapter_id"]
     verse_id = word_data["verse_id"]
 
+    logging.debug(f"Book ID: {book_id}, Chapter ID: {chapter_id}, Verse ID: {verse_id}")
+
     # Format verse information
     verse_info = f"""
     **{TANACH_DATA[book_id]['title']}**
@@ -75,48 +87,47 @@ def update_tanach_display():
     hebrew_verse = get_formatted_verse(book_id, chapter_id, verse_id)
     english_verse = translate_verse('\n'.join(hebrew_verse.split('<br>')), verse_id)
 
-    return current_time, verse_info, hebrew_verse, english_verse
+    return verse_info, hebrew_verse, english_verse
 
 with gr.Blocks(css="""
     .container {
-        display: flex;
-        flex-direction: column;
-        align-items: center;
-        font-family: 'Times New Roman', serif;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    font-family: 'Times New Roman', serif;
     }
     .highlight {
-        background-color: #FFFF00;
-        padding: 2px 5px;
-        border-radius: 5px;
+    background-color: #FFFF00;
+    padding: 2px 5px;
+    border-radius: 5px;
     }
     #verse-info {
-        margin-bottom: 20px;
-        text-align: center;
+    margin-bottom: 20px;
+    text-align: center;
     }
     #verses {
-        display: flex;
-        flex-direction: row;
-        justify-content: center;
-        align-items: flex-start;
-        gap: 50px;
+    display: flex;
+    flex-direction: row;
+    justify-content: center;
+    align-items: flex-start;
+    gap: 50px;
     }
     #hebrew-verse {
-        font-size: 18px;
-        line-height: 1.5;
-        margin-bottom: 20px;
-        text-align: right;
-        direction: rtl;
+    font-size: 18px;
+    line-height: 1.5;
+    margin-bottom: 20px;
+    text-align: right;
+    direction: rtl;
     }
     #english-verse {
-        font-size: 18px;
-        line-height: 1.5;
-        margin-bottom: 20px;
+    font-size: 18px;
+    line-height: 1.5;
+    margin-bottom: 20px;
     }
 """) as iface:
-    # ... (no changes in the Markdown component)
 
     with gr.Row():
-        time_output = gr.Textbox(label="Current Time", elem_id="current-time")
+        client_time_input = gr.Textbox(label="Enter your current time (HH:MM:SS)")
 
     with gr.Row():
         verse_info_output = gr.Markdown(label="Verse Information", elem_id="verse-info")
@@ -126,6 +137,29 @@ with gr.Blocks(css="""
         hebrew_verse_output = gr.HTML(label="Hebrew Verse", elem_id="hebrew-verse")
         english_verse_output = gr.HTML(label="English Translation", elem_id="english-verse")
 
-    iface.load(update_tanach_display, [],
-               [time_output, verse_info_output, hebrew_verse_output, english_verse_output])
+    client_time_input.submit(
+        fn=update_tanach_display,
+        inputs=[client_time_input],
+        outputs=[verse_info_output, hebrew_verse_output, english_verse_output]
+    )
+
+class TestWordIndex(unittest.TestCase):
+    def test_word_index_boundaries(self):
+        # Test for 0:00:00
+        word_data_start, _ = get_current_word_data("00:00:00")
+        self.assertEqual(word_data_start["book_id"], 1)
+        self.assertEqual(word_data_start["chapter_id"], 0)
+        self.assertEqual(word_data_start["verse_id"], 1)
+
+        # Test for 23:59:59
+        word_data_end, _ = get_current_word_data("23:59:59")
+        self.assertEqual(word_data_end["book_id"], 39)
+        self.assertEqual(word_data_end["chapter_id"], 35)
+        self.assertEqual(word_data_end["verse_id"], 23)
+
+if __name__ == '__main__':
+    # Run tests first
+    suite = unittest.TestLoader().loadTestsFromTestCase(TestWordIndex)
+    unittest.TextTestRunner().run(suite)
+
     iface.launch(share=True)

utils.py

@@ -2,107 +2,85 @@ import json
 import logging
 
 def process_json_files(start, end):
-    """
-    Processes JSON files containing Tanach text and returns a dictionary
-    mapping book IDs to their data.
+  """
+  Processes JSON files containing Tanach text and returns a dictionary
+  mapping book IDs to their data.
 
-    Args:
-      start: The starting book ID (inclusive).
-      end: The ending book ID (inclusive).
+  Args:
+    start: The starting book ID (inclusive).
+    end: The ending book ID (inclusive).
 
-    Returns:
-      A dictionary where keys are book IDs and values are dictionaries
-      containing 'title' and 'text' fields.
-    """
-    base_path = "texts"
-    results = {}
+  Returns:
+    A dictionary where keys are book IDs and values are dictionaries
+    containing 'title' and 'text' fields.
+  """
+  base_path = "texts"
+  results = {}
 
-    for i in range(start, end + 1):
-        file_name = f"{base_path}/{i:02}.json"
-        try:
-            with open(file_name, 'r', encoding='utf-8') as file:
-                data = json.load(file)
-                if data:
-                    results[i] = {"title": data.get("title", "No title"), "text": data.get("text", [])}
-        except FileNotFoundError:
-            logging.warning(f"File {file_name} not found.")
-        except json.JSONDecodeError as e:
-            logging.warning(f"File {file_name} could not be read as JSON: {e}")
-        except KeyError as e:
-            logging.warning(f"Expected key 'text' is missing in {file_name}: {e}")
+  for i in range(start, end + 1):
+    file_name = f"{base_path}/{i:02}.json"
+    try:
+      with open(file_name, 'r', encoding='utf-8') as file:
+        data = json.load(file)
+        if data:
+          results[i] = {"title": data.get("title", "No title"), "text": data.get("text", [])}
+    except FileNotFoundError:
+      logging.warning(f"File {file_name} not found.")
+    except json.JSONDecodeError as e:
+      logging.warning(f"File {file_name} could not be read as JSON: {e}")
+    except KeyError as e:
+      logging.warning(f"Expected key 'text' is missing in {file_name}: {e}")
 
-    return results
+  return results
 
 def flatten_text_with_line_breaks(text):
-    """
-    Flattens nested lists while preserving line breaks.
-    """
-    flattened_text = []
-    for item in text:
-        if isinstance(item, list):
-            flattened_text.extend(flatten_text_with_line_breaks(item))
-        elif isinstance(item, str):
-            flattened_text.append(item)
-        else:
-            flattened_text.append(str(item))
-    return flattened_text
+  """
+  Flattens nested lists while preserving line breaks.
+  """
+  flattened_text = []
+  for item in text:
+    if isinstance(item, list):
+      flattened_text.extend(flatten_text_with_line_breaks(item))
+    elif isinstance(item, str):
+      flattened_text.append(item)
+    else:
+      flattened_text.append(str(item))
+  return flattened_text
 
 def calculate_tanach_statistics(tanach_data):
+  """
+  Calculates statistics for the Tanach corpus.
+  """
+  # ... (rest of the function remains the same)
+
+def build_word_index(tanach_data):
     """
-    Calculates statistics for the Tanach corpus.
+    Builds a word index for efficient lookup, ensuring the last word
+    aligns with the last second of the day.
     """
-    book_stats = {}
-    total_chapters = 0
-    total_verses = 0
-    total_words = 0
+    word_index = {}
+    word_count = 0
+    total_seconds = 24 * 60 * 60  # Total seconds in a day
 
+    # Calculate total words first
+    total_words = 0
     for book_id in tanach_data:
-        book_title = tanach_data[book_id]["title"]
-        chapters = tanach_data[book_id]["text"]
-        book_chapters = len(chapters)
-        book_verses = 0
-        book_words = 0
-
-        for chapter in chapters:
+        for chapter in tanach_data[book_id]["text"]:
             flattened_chapter = flatten_text_with_line_breaks(chapter)
-            book_verses += len(flattened_chapter)
-            book_words += len(flattened_chapter)
+            total_words += len(flattened_chapter)
 
-        total_chapters += book_chapters
-        total_verses += book_verses
-        total_words += book_words
+    # Calculate the seconds per word
+    seconds_per_word = total_seconds / total_words if total_words > 0 else 0
 
-        book_stats[book_id] = {
-            "title": book_title,
-            "chapters": book_chapters,
-            "verses": book_verses,
-            "words": book_words
-        }
-
-    average_words_per_verse = total_words / total_verses if total_verses > 0 else 0
-
-    corpus_stats = {
-        "total_books": len(tanach_data),
-        "total_chapters": total_chapters,
-        "total_verses": total_verses,
-        "total_words": total_words,
-        "average_words_per_verse": average_words_per_verse,
-        "book_stats": book_stats
-    }
-
-    return corpus_stats
-
-def build_word_index(tanach_data):
-    """
-    Builds a word index for efficient lookup.
-    """
-    word_index = {}
-    word_count = 0
     for book_id in tanach_data:
         for chapter_index, chapter in enumerate(tanach_data[book_id]["text"]):
             flattened_chapter = flatten_text_with_line_breaks(chapter)
             for verse_index, word in enumerate(flattened_chapter):
-                word_index[word_count] = {
+                # Calculate the target second for the current word
+                target_second = int(word_count * seconds_per_word)
+
+                # Use the target second as the key
+                word_index[target_second] = {
                     "book_id": book_id,
                     "chapter_id": chapter_index,
                     "verse_id": verse_index + 1,