simple calculation for Sura

app.py

@@ -372,8 +372,7 @@ with gr.Blocks() as app:
             logger.debug(f"Adjusted Gematria Sum (using formula): {initial_gematria_sum}")
 
         # Use ELS search on the Quran text, not Genesis
-        # Use combined +1,-1 rounds as requested
-        els_result = quran_module.get_first_els_result_quran(initial_gematria_sum, tlang='en', rounds_combination="1,-1")
+        els_result = quran_module.get_first_els_result_quran(initial_gematria_sum, tlang='en')
         if not els_result:
             logger.debug("No ELS result. Returning error message.")
             return "No ELS result found in the Quran text."

els_cache.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ebdf43f0d50fc9a1ea4174cc233f2017f4c4dbe56b5390ecfdf06bf3b91d23f6
+oid sha256:92f45b840047aa969a71057a9c7635071c96c4a6ed32c01c156f1d26abe92f0e
 size 24576

quran.py

@@ -157,32 +157,25 @@ def get_sura_count() -> int:
         return 114  # Default number of suras in the Quran
 
 
-def get_first_els_result_quran(gematria_sum: int, tlang: str = "en", rounds_combination: str = "1,-1") -> Dict[str, Any]:
+def get_first_els_result_quran(gematria_sum: int, tlang: str = "en") -> Dict[str, Any]:
     """
-    Gets the first ELS result from the Quran using the gematria sum as the step,
-    following the same method as Torah ELS: combined +1/-1 rounds.
-    
-    For Quran, the implementation specifically:
-    1. Takes +1 ELS round from the start of book 1 to the end of book 2
-    2. Takes -1 ELS round from the end of book 2 to the start of book 1
+    Gets the first ELS result from the Quran using the gematria sum as the step.
     
     Args:
         gematria_sum: The gematria value to use as the ELS step
         tlang: Target language for results
-        rounds_combination: Comma-separated string of round directions, defaults to "1,-1"
         
     Returns:
         The first ELS result found or None
     """
     import hashlib
     import json
-    import math
-    from gematria import strip_diacritics, calculate_gematria
+    from gematria import strip_diacritics
     
-    logger.debug(f"Entering get_first_els_result_quran with gematria_sum: {gematria_sum}, tlang: {tlang}, rounds_combination: {rounds_combination}")
+    logger.debug(f"Entering get_first_els_result_quran with gematria_sum: {gematria_sum}, tlang: {tlang}")
     
-    # Create a cache key including the rounds_combination
-    cache_key = f"quran_els_{gematria_sum}_{tlang}_{rounds_combination}"
+    # Create a cache key
+    cache_key = f"quran_els_{gematria_sum}_{tlang}"
     cache_file = "els_cache.db"
     
     # Check cache first
@@ -202,125 +195,89 @@ def get_first_els_result_quran(gematria_sum: int, tlang: str = "en", rounds_comb
     # Cache miss, perform ELS search
     logger.info(f"Cache miss for Quran ELS query: {cache_key}, performing search")
     
-    # Load Quran text for books 1 and 2 only (based on the requirement)
-    quran_data = process_quran_files(1, 2)  # Only books 1 and 2 as specified
+    # Load all Quran text
+    sura_count = get_sura_count()
+    quran_data = process_quran_files(1, sura_count)
     
-    # Concatenate verses into a single text
+    # Concatenate all verses from all suras into a single text
     all_text = ""
-    sura_verse_map = []  # Track (sura_id, sura_name, verse_idx) for each character
-    
     for sura_id, sura_info in sorted(quran_data.items()):
-        sura_name = sura_info['name']
-        verses = sura_info['text']
-        
         # Add a space between suras to prevent cross-sura word formation
         if all_text:
             all_text += " "
         
-        # Add all verses from this sura and track the mapping
-        sura_start_pos = len(all_text)
+        # Add all verses from this sura
+        verses = sura_info['text']
         all_text += " ".join(verses)
-        
-        # Track character positions to their original sura/verse for later lookup
-        current_verse_start = sura_start_pos
-        for verse_idx, verse in enumerate(verses, 1):
-            for _ in range(len(verse) + (1 if verse_idx < len(verses) else 0)):  # Add 1 for space between verses
-                sura_verse_map.append((sura_id, sura_name, verse_idx))
     
-    # Clean up the text: strip diacritics, remove special characters
+    # Clean up the text: strip diacritics, remove any special characters, etc.
     clean_text = strip_diacritics(all_text)
     clean_text = ''.join(c for c in clean_text if c.isalpha() or c.isspace())
     
-    # Remove spaces for ELS search
-    text_no_spaces = clean_text.replace(" ", "")
-    text_length = len(text_no_spaces)
-    
-    if text_length == 0:
-        logger.warning("No text available after cleaning")
-        return None
-    
-    # Build a more accurate character map without spaces
-    char_map = []
-    char_idx = 0
-    for i, c in enumerate(clean_text):
-        if c.isalpha():
-            if char_idx < len(sura_verse_map):
-                char_map.append(sura_verse_map[i])
-            char_idx += 1
-    
-    # Parse rounds combination - default is "1,-1"
-    rounds_list = list(map(float, rounds_combination.split(',')))
-    
+    # Perform ELS search with the gematria_sum as the step
     result = None
-    complete_result = ""
-    complete_positions = []
-    first_position = None
-    last_position = None
-    
-    # Process each round direction (similar to Torah ELS)
-    for round_dir in rounds_list:
-        # Determine if this is a forward or backward search
-        is_forward = round_dir > 0
-        start_index = 0 if is_forward else (text_length - 1)
-        
-        # Set step and direction
-        step = gematria_sum
-        direction = 1 if is_forward else -1
-        
-        # Extract ELS characters
-        round_text = ""
-        positions = []
-        pos = start_index
+    if clean_text:
+        # Remove spaces for ELS search
+        text_no_spaces = clean_text.replace(" ", "")
         
-        # Extract up to 10 characters, but we'll use at least 3 for a valid result
-        for _ in range(10):
-            if 0 <= pos < text_length:
-                round_text += text_no_spaces[pos]
-                positions.append(pos)
-                pos += direction * step
-            else:
-                break
+        # Track character positions to their original sura/verse
+        char_map = []  # List of (sura_id, verse_id) for each character
         
-        if len(round_text) >= 3:
-            # Save this round's results
-            complete_result += round_text
-            complete_positions.extend(positions)
-            
-            # Track first and last positions for the overall result
-            if first_position is None or (is_forward and positions[0] < first_position):
-                first_position = positions[0]
-                first_loc = char_map[first_position] if first_position < len(char_map) else None
-            
-            if last_position is None or (not is_forward and positions[-1] > last_position):
-                last_position = positions[-1]
-                last_loc = char_map[last_position] if last_position < len(char_map) else None
-    
-    # Create result if we found something
-    if complete_result and len(complete_result) >= 3 and first_position is not None and last_position is not None:
-        if first_position < len(char_map) and last_position < len(char_map):
-            first_loc = char_map[first_position]
-            last_loc = char_map[last_position]
+        # Build character position mapping
+        current_pos = 0
+        for sura_id, sura_info in sorted(quran_data.items()):
+            sura_name = sura_info['name']
+            verses = sura_info['text']
             
-            result = {
-                "result_text": complete_result,
-                "source": "Quran",
-                "step": gematria_sum,
-                "start_sura": first_loc[0],
-                "start_sura_name": first_loc[1],
-                "start_verse": first_loc[2],
-                "end_sura": last_loc[0],
-                "end_sura_name": last_loc[1],
-                "end_verse": last_loc[2],
-                "positions": complete_positions,
-                "rounds_combination": rounds_combination
-            }
+            for verse_idx, verse in enumerate(verses, 1):
+                cleaned_verse = strip_diacritics(verse).replace(" ", "")
+                for _ in cleaned_verse:
+                    if current_pos < len(text_no_spaces):
+                        char_map.append((sura_id, sura_name, verse_idx))
+                        current_pos += 1
+        
+        # Start positions to try (we'll try the first 100 positions for better coverage)
+        for start_pos in range(min(100, len(text_no_spaces))):
+            # Extract characters at positions: start_pos, start_pos+step, start_pos+2*step, etc.
+            extracted = ""
+            positions = []
+            pos = start_pos
             
-            # Calculate gematria of the result text
-            result["result_sum"] = calculate_gematria(complete_result)
+            # Extract up to 7 characters (typical ELS result length)
+            for _ in range(7):
+                if pos < len(text_no_spaces):
+                    extracted += text_no_spaces[pos]
+                    positions.append(pos)
+                    pos += gematria_sum
+                else:
+                    break
             
-            logger.debug(f"Found ELS result: {complete_result} with gematria {result['result_sum']}")
-        else:
-            logger.warning(f"Character position mapping inconsistency: {first_position}, {last_position} vs {len(char_map)}")
+            if len(extracted) >= 3:  # At least 3 characters
+                # Look up the sura/verse for the first and last character
+                first_pos = positions[0]
+                last_pos = positions[-1]
+                
+                if first_pos < len(char_map) and last_pos < len(char_map):
+                    first_loc = char_map[first_pos]
+                    last_loc = char_map[last_pos]
+                    
+                    result = {
+                        "result_text": extracted,
+                        "source": "Quran",
+                        "start_position": start_pos,
+                        "step": gematria_sum,
+                        "start_sura": first_loc[0],
+                        "start_sura_name": first_loc[1],
+                        "start_verse": first_loc[2],
+                        "end_sura": last_loc[0],
+                        "end_sura_name": last_loc[1],
+                        "end_verse": last_loc[2],
+                        "positions": positions
+                    }
+                    break  # Found a result, stop searching
+                else:
+                    logger.warning(f"Character position mapping inconsistency: {first_pos}, {last_pos} vs {len(char_map)}")
+                    continue
     
     # Cache the result
     if result:
@@ -342,7 +299,7 @@ def get_first_els_result_quran(gematria_sum: int, tlang: str = "en", rounds_comb
                 cursor.execute(
                     "INSERT OR REPLACE INTO els_cache (query_hash, function_name, args, kwargs, results) VALUES (?, ?, ?, ?, ?)",
                     (hashlib.sha256(cache_key.encode()).hexdigest(), "get_first_els_result_quran", 
-                     json.dumps([gematria_sum]), json.dumps({"tlang": tlang, "rounds_combination": rounds_combination}), json.dumps(result)))
+                     json.dumps([gematria_sum]), json.dumps({"tlang": tlang}), json.dumps(result)))
                 conn.commit()
                 logger.debug("Cached Quran ELS results in database.")
         except sqlite3.Error as e: