Update app.py

app.py

@@ -3,6 +3,7 @@ from difflib import SequenceMatcher
 import requests
 import xml.etree.ElementTree as ET
 import gradio as gr
+from concurrent.futures import ThreadPoolExecutor
 
 areaData = {
     "Hong Kong": {
@@ -80,15 +81,14 @@ areaData = {
     }
 }
 
+
 def normalize_text(text):
-    normalized = text.lower().strip()
-    standardized = re.sub(r'\s+', ' ', normalized)
-    return standardized
+    return re.sub(r'\s+', ' ', text.lower().strip())
+
 
 def normalize_address(address):
-    address = re.sub(r'[^\w\s]', '', address)
-    address = re.sub(r'\s+', ' ', address)
-    return address.strip().upper()
+    return re.sub(r'[^\w\s]', '', re.sub(r'\s+', ' ', address)).strip().upper()
+
 
 def load_and_normalize_address_pool(file_paths):
     address_pool = []
@@ -106,15 +106,19 @@ def load_and_normalize_address_pool(file_paths):
             print(f"Error reading file {file_path}: {e}")
     return address_pool
 
+
 def similarity(a, b):
+    a, b = a.replace(' ', ''), b.replace(' ', '')
     return SequenceMatcher(None, a, b).ratio()
 
+
 def extract_relevant_part(user_input):
     number_part = re.findall(r'\d+', user_input)
     number_part = number_part[0] if number_part else ''
     address_part = re.sub(r'^\d+', '', user_input).strip()
     return number_part, address_part
 
+
 def match_address(user_input, address_pool):
     number_part, address_part = extract_relevant_part(user_input)
     normalized_input = normalize_address(address_part)
@@ -129,6 +133,7 @@ def match_address(user_input, address_pool):
         best_match = f"{number_part} {best_match}".strip() if number_part else best_match
     return best_match, highest_similarity
 
+
 def fetch_address_from_als_api(user_input):
     api_url = f"https://www.als.gov.hk/lookup?q={requests.utils.quote(user_input)}"
     try:
@@ -175,27 +180,34 @@ def fetch_address_from_als_api(user_input):
 def extract_building_from_address(user_input):
     normalized_input = normalize_text(user_input)
     match = re.match(r'([^,]+)', normalized_input)
-    building_part = match.group(1).strip() if match else normalized_input
+    return match.group(1).strip() if match else normalized_input
+
 
-    return building_part
+def address_search(user_inputs):
+    results = []
+    user_inputs_list = user_inputs.splitlines()
 
+    def process_input(user_input):
+        building_part = extract_building_from_address(user_input)
+        normalized_input = normalize_address(building_part)
+        best_match, similarity_score = match_address(normalized_input, address_pool)
+        als_result = fetch_address_from_als_api(best_match) if best_match else "No match found."
 
-def address_search(user_input):
-    building_part = extract_building_from_address(user_input)
-    normalized_input = normalize_address(building_part)
-    best_match, similarity_score = match_address(normalized_input, address_pool)
-    als_result = fetch_address_from_als_api(best_match) if best_match else "No match found."
+        result_str = f"Best match: {best_match} (Similarity: {similarity_score:.2f})\n"
+        if isinstance(als_result, dict):
+            for address_type, details in als_result.items():
+                result_str += f"\n{address_type}:\n"
+                for key, value in details.items():
+                    result_str += f"{key}: {value}\n"
+        else:
+            result_str += als_result
 
-    result_str = f"Best match: {best_match} (Similarity: {similarity_score:.2f})\n"
-    if isinstance(als_result, dict):
-        for address_type, details in als_result.items():
-            result_str += f"\n{address_type}:\n"
-            for key, value in details.items():
-                result_str += f"{key}: {value}\n"
-    else:
-        result_str += als_result
+        return result_str
 
-    return result_str
+    with ThreadPoolExecutor() as executor:
+        results = list(executor.map(process_input, user_inputs_list))
+
+    return "\n\n".join(results)
 
 
 def clean_area_data(area_data):
@@ -203,11 +215,13 @@ def clean_area_data(area_data):
     for region, districts in area_data.items():
         cleaned_districts = {}
         for district, subdistricts in districts.items():
-            valid_subdistricts = [normalize_text(name) for name in subdistricts if not re.search(r'Non-Building|Invalid|Other', name, re.I)]
+            valid_subdistricts = [normalize_text(name) for name in subdistricts if
+                                  not re.search(r'Non-Building|Invalid|Other', name, re.I)]
             cleaned_districts[normalize_text(district)] = valid_subdistricts
         cleaned_area_data[normalize_text(region)] = cleaned_districts
     return cleaned_area_data
 
+
 cleaned_area_data = clean_area_data(areaData)
 file_paths = [
     'EngBuilding.txt',
@@ -219,10 +233,10 @@ address_pool = load_and_normalize_address_pool(file_paths)
 
 interface = gr.Interface(
     fn=address_search,
-    inputs=gr.Textbox(label="Enter Address"),
-    outputs=gr.Textbox(label="ALS API Result"),
+    inputs=gr.Textbox(label="Enter Addresses (one per line, allow Batch Processing)", lines=10),
+    outputs=gr.Textbox(label="ALS API Results"),
     title="Address Lookup and Matching (English)",
-    description="Enter an address to find the closest match and fetch details from the ALS API."
+    description="Enter addresses to find the closest matches and fetch details from the ALS API."
 )
 
-interface.launch()
+interface.launch()