rounds combination

app.py

@@ -372,7 +372,8 @@ 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
-        els_result = quran_module.get_first_els_result_quran(initial_gematria_sum, tlang='en')
+        # 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")
         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:837c8d8c8dce31b1d06f4541f63130bb84b63a9507faa958ddb3ee304f93ad53
-size 20480
+oid sha256:ebdf43f0d50fc9a1ea4174cc233f2017f4c4dbe56b5390ecfdf06bf3b91d23f6
+size 24576

quran.py

@@ -157,25 +157,32 @@ 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") -> Dict[str, Any]:
+def get_first_els_result_quran(gematria_sum: int, tlang: str = "en", rounds_combination: str = "1,-1") -> Dict[str, Any]:
     """
-    Gets the first ELS result from the Quran using the gematria sum as the step.
+    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
     
     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
-    from gematria import strip_diacritics
+    import math
+    from gematria import strip_diacritics, calculate_gematria
     
-    logger.debug(f"Entering get_first_els_result_quran with gematria_sum: {gematria_sum}, tlang: {tlang}")
+    logger.debug(f"Entering get_first_els_result_quran with gematria_sum: {gematria_sum}, tlang: {tlang}, rounds_combination: {rounds_combination}")
     
-    # Create a cache key
-    cache_key = f"quran_els_{gematria_sum}_{tlang}"
+    # Create a cache key including the rounds_combination
+    cache_key = f"quran_els_{gematria_sum}_{tlang}_{rounds_combination}"
     cache_file = "els_cache.db"
     
     # Check cache first
@@ -195,89 +202,125 @@ def get_first_els_result_quran(gematria_sum: int, tlang: str = "en") -> Dict[str
     # Cache miss, perform ELS search
     logger.info(f"Cache miss for Quran ELS query: {cache_key}, performing search")
     
-    # Load all Quran text
-    sura_count = get_sura_count()
-    quran_data = process_quran_files(1, sura_count)
+    # 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
     
-    # Concatenate all verses from all suras into a single text
+    # Concatenate verses 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
-        verses = sura_info['text']
+        # Add all verses from this sura and track the mapping
+        sura_start_pos = len(all_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 any special characters, etc.
+    # Clean up the text: strip diacritics, remove special characters
     clean_text = strip_diacritics(all_text)
     clean_text = ''.join(c for c in clean_text if c.isalpha() or c.isspace())
     
-    # Perform ELS search with the gematria_sum as the step
+    # 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(',')))
+    
     result = None
-    if clean_text:
-        # Remove spaces for ELS search
-        text_no_spaces = clean_text.replace(" ", "")
+    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)
         
-        # Track character positions to their original sura/verse
-        char_map = []  # List of (sura_id, verse_id) for each character
+        # Set step and direction
+        step = gematria_sum
+        direction = 1 if is_forward else -1
         
-        # 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']
-            
-            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
+        # Extract ELS characters
+        round_text = ""
+        positions = []
+        pos = start_index
+        
+        # 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
         
-        # 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
+        if len(round_text) >= 3:
+            # Save this round's results
+            complete_result += round_text
+            complete_positions.extend(positions)
             
-            # 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
+            # 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 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
+            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]
+            
+            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
+            }
+            
+            # Calculate gematria of the result text
+            result["result_sum"] = calculate_gematria(complete_result)
+            
+            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)}")
     
     # Cache the result
     if result:
@@ -299,7 +342,7 @@ def get_first_els_result_quran(gematria_sum: int, tlang: str = "en") -> Dict[str
                 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}), json.dumps(result)))
+                     json.dumps([gematria_sum]), json.dumps({"tlang": tlang, "rounds_combination": rounds_combination}), json.dumps(result)))
                 conn.commit()
                 logger.debug("Cached Quran ELS results in database.")
         except sqlite3.Error as e: