Update app.py

app.py

@@ -103,88 +103,55 @@ def call_search_sdk(api_key, payload_text):
         return {"ok": False, "error": str(e)}
 
 
-def extract_udise_candidates_from_search(search_json, school_name="", state_name=""):
+def extract_udise_candidates_from_search(search_json):
     """
-    Extract UDISE codes from Tavily search results with scoring based on relevance.
-    
-    Args:
-        search_json: The raw Tavily API response
-        school_name: Optional school name for better matching
-        state_name: Optional state name for better matching
-        
-    Returns:
-        List of UDISE codes sorted by relevance
+    Extract UDISE codes from Tavily search results.
+    Returns a list of unique UDISE codes found in the search results.
     """
+    print("\n===== Extracting UDISE Codes =====")
     found = set()
-    candidates = []
-    
-    # Normalize search terms for matching
-    school_tokens = [t for t in re.sub(r"\s+", " ", school_name).strip().lower().split() if t]
-    state_norm = re.sub(r"\s+", " ", state_name).strip().lower()
     
     # Check if we have valid search results
     if not search_json or not isinstance(search_json, dict):
+        print("Invalid search JSON")
         return []
         
-    results = search_json.get('data', {}).get('results', [])
-    if not isinstance(results, list):
+    results = search_json.get('results', []) or search_json.get('data', {}).get('results', [])
+    if not results:
+        print("No results found in search JSON")
         return []
     
+    print(f"Found {len(results)} search results")
+    
     # Patterns to match UDISE codes
     patterns = [
-        r'UDISE\s*[Cc]ode\s*:?\s*(\d{11})(?![0-9])',  # Matches "UDISE Code: 12345678901"
-        r'Udise\s+School\s+Code\s*:?\s*(\d{11})(?![0-9])',  # Matches "Udise School Code: 12345678901"
-        r'udise\s+code:?\s*(\d{11})(?![0-9])',  # Case-insensitive match
-        r'(?<![0-9])(\d{11})(?![0-9])'  # Matches exactly 11 digits not part of a longer number
+        r'UDISE[^\d]*(?:code|Code|CODE)[^\d]*(\d{11})(?![0-9])',
+        r'Udise[^\d]*(?:School[^\d]*Code|Code)[^\d]*(\d{11})(?![0-9])',
+        r'(?<![0-9])(\d{11})(?![0-9])'  # Fallback: any 11-digit number
     ]
     
     for result in results:
         if not isinstance(result, dict):
             continue
             
-        # Combine title and content for better matching
-        title = str(result.get('title', ''))
-        content = str(result.get('content', ''))
-        snippet = f"{title} {content}"
-        snippet_low = snippet.lower()
+        # Combine title and content for searching
+        text = f"{result.get('title', '')} {result.get('content', '')}"
         
-        # Skip if no UDISE code pattern found
-        if not any(re.search(p, snippet, re.IGNORECASE) for p in patterns):
-            continue
-            
-        # Calculate relevance score
-        score = 0
-        
-        # Higher score if school name tokens are found
-        if school_tokens and any(tok in snippet_low for tok in school_tokens):
-            score += 2
-            
-        # Higher score if state name is mentioned
-        if state_norm and state_norm in snippet_low:
-            score += 1
-            
-        # Extra points for exact school name match
-        if school_name and school_name.lower() in snippet_low:
-            score += 3
-            
-        # Extract all UDISE codes from this result
+        # Check for UDISE codes using all patterns
         for pattern in patterns:
-            for match in re.finditer(pattern, snippet, re.IGNORECASE):
+            matches = re.finditer(pattern, text, re.IGNORECASE)
+            for match in matches:
                 udise_code = match.group(1) if len(match.groups()) > 0 else match.group(0)
                 if udise_code and is_valid_udise(udise_code):
+                    print(f"Found UDISE code: {udise_code}")
                     found.add(udise_code)
-                    # Store with score for sorting
-                    candidates.append((score, udise_code))
     
-    # Sort by score (descending) and return unique codes
-    candidates.sort(key=lambda x: x[0], reverse=True)
-    seen = set()
-    result = []
+    # Convert set to list and sort
+    result = sorted(list(found))
     
-    for score, code in candidates:
-        if code not in seen:
-            seen.add(code)
-            result.append(code)
+    if not result:
+        print("No valid UDISE codes found")
+        return []
     
     return result