Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| from transformers import pipeline | |
| import openpyxl | |
| import tempfile | |
| import pycountry | |
| from deep_translator import GoogleTranslator | |
| from langdetect import detect | |
| classifier = pipeline("zero-shot-classification", | |
| model="LogicSpine/address-large-text-classifier") | |
| def translate_text(text: str): | |
| text = text.strip() | |
| translator = GoogleTranslator(source='auto', target='en') | |
| detected_lang = detect(text) | |
| if detected_lang == 'en': | |
| return text | |
| translated = translator.translate(text) | |
| return translated | |
| def check_for_third(address: str) -> bool: | |
| countries = [country.name.lower() for country in pycountry.countries] | |
| old_country_names = [ | |
| "burma", | |
| "ceylon", | |
| "persia", | |
| "zaire", | |
| "upper volta", | |
| "swaziland", | |
| "macedonia", | |
| "czech republic", | |
| "turkey", | |
| "holland", | |
| "kampuchea", | |
| "dahomey", | |
| "bechuanaland", | |
| "gold coast", | |
| "nyasaland", | |
| "korea", | |
| "russia", | |
| "usa", | |
| "uk" | |
| ] | |
| countries = countries + old_country_names | |
| if "," in address: | |
| address = address.split(",") | |
| else: | |
| address = [address.strip()] | |
| for ad in address: | |
| if ad.lower().strip() in countries: | |
| return True | |
| return False | |
| def check_for_first(address: str) -> bool: | |
| keyword_list = ["school", "laboratory", "department"] | |
| for key in keyword_list: | |
| if key.lower() in address.lower(): | |
| return True | |
| return False | |
| def check_for_second(address: str) -> bool: | |
| keyword_list = ["university"] | |
| for key in keyword_list: | |
| if key.lower() in address.lower().strip(): | |
| return True | |
| return False | |
| def compaire_two(bigger: str, smaller: str, mid: int) -> bool: | |
| """Helps to find the result according to the priority | |
| Args: | |
| bigger (str): Pass the bigger | |
| smaller (str): And smaller | |
| mid (int): Pass the mid where 1 reffer to 1st and 2 as 2nd and 3 as 3rd | |
| Raises: | |
| ValueError: If invalid mid is passed | |
| Returns: | |
| bool: if bigger have more priority then True else False | |
| """ | |
| if mid == 1: | |
| if check_for_first(bigger): | |
| return True | |
| lab = ["School", "Department", "Laboratory"] | |
| elif mid == 2: | |
| if check_for_second(bigger): | |
| return True | |
| lab = ["University", "Polytechnic"] | |
| elif mid == 3: | |
| if check_for_third(bigger): | |
| return True | |
| lab = ["State", "District", "Country"] | |
| else: | |
| raise ValueError(f"Invalid value passed in mid : {mid}") | |
| sb = classifier(bigger, lab) | |
| ss = classifier(smaller, lab) | |
| result_bigger = sum(sb["scores"]) | |
| result_smaller = sum(ss["scores"]) | |
| if result_bigger > result_smaller: | |
| return True | |
| return False | |
| def get_ai_position(address: str) -> int: | |
| """This function use AI to find the position of the address | |
| Args: | |
| address (str): Pass the address here | |
| Returns: | |
| int: Return the mid 1 for 4th and 2 for 5th and 3 for 6th | |
| """ | |
| if check_for_first(address): | |
| return 1 | |
| if check_for_second(address): | |
| return 2 | |
| if check_for_third(address): | |
| return 3 | |
| result_first = sum(classifier(address, ["School", "Department", "Laboratory"])["scores"]) | |
| result_second = sum(classifier(address, ["University", "Polytechnic"])["scores"]) | |
| result_third = sum(classifier(address, ["State", "District", "Country"])["scores"]) | |
| total = max(result_first, result_second, result_third) | |
| if total == result_first: | |
| return 1 | |
| elif total == result_second: | |
| return 2 | |
| if total == result_third: | |
| return 3 | |
| else: | |
| return 3 | |
| def compare_by_mid(bigger: int, smaller: int, address: str, threshold: float = 0.1) -> bool: | |
| """Helps to find the proper position for the address according to the mid | |
| Args: | |
| bigger (int): Pass the mid 1, 2 or 3 | |
| smaller (int): Pass the mid 1, 2 or 3 | |
| address (str): If possibility of bigger is more then return True else False | |
| threshold (float): Minimum score difference to consider valid comparison | |
| Returns: | |
| bool: Boolean | |
| """ | |
| if bigger == 1: | |
| if check_for_first(address): | |
| return True | |
| bigger_l = ["School", "Department", "Laboratory"] | |
| elif bigger == 2: | |
| if check_for_second(address): | |
| return True | |
| bigger_l = ["University", "Polytechnic"] | |
| else: | |
| if check_for_third(address): | |
| return True | |
| bigger_l = ["State", "District", "Country"] | |
| if smaller == 1: | |
| smaller_l = ["School", "Department", "Laboratory"] | |
| elif smaller == 2: | |
| smaller_l = ["University", "Polytechnic"] | |
| else: | |
| smaller_l = ["State", "District", "Country"] | |
| result_bigger = classifier(address, bigger_l) | |
| result_smaller = classifier(address, smaller_l) | |
| max_bigger = max(result_bigger["scores"]) | |
| max_smaller = max(result_smaller["scores"]) | |
| score_difference = max_smaller - max_bigger | |
| return score_difference > threshold | |
| def find_missing_data(data1: str, data2: str, data3: str, var1: str, var2: str, var3: str) -> str: | |
| """Helps to find the missing data | |
| Args: | |
| data1 (str): Pass the first data or you can say address | |
| data2 (str): Pass the 2nd address | |
| data3 (str): pass third address | |
| var1 (str): pass the first variable to check | |
| var2 (str): pass 2nd variable to check | |
| var3 (str): pass the third variable to check the 3rd address | |
| Returns: | |
| str: return the address as string | |
| """ | |
| data_set = {data1, data2, data3} | |
| variables_filled = {var1, var2, var3} | |
| missing_data = data_set - variables_filled | |
| if missing_data: | |
| return ', '.join(missing_data) | |
| else: | |
| return "All data has been assigned correctly." | |
| def swapper(i1, i2, i3): | |
| first, second, third = None, None, None | |
| inputs = [i1, i2, i3] | |
| first_candidates = [] | |
| for data in inputs: | |
| original_data = data | |
| if check_for_third(translate_text(data)): | |
| if third is None: | |
| third = data | |
| else: | |
| third, data = data, third | |
| if check_for_first(translate_text(data)): | |
| first_candidates.append(data) | |
| elif check_for_second(translate_text(data)): | |
| if second is None: | |
| second = data | |
| else: | |
| second, data = data, second | |
| elif check_for_first(translate_text(data)): | |
| first_candidates.append(data) | |
| elif check_for_second(translate_text(data)): | |
| if second is None: | |
| second = data | |
| else: | |
| second, data = data, second | |
| if first_candidates: | |
| first = first_candidates[0] if first is None else first | |
| if len(first_candidates) > 1: | |
| second = first_candidates[1] if second is None else second | |
| remaining_data = [i1, i2, i3] | |
| if first is None: | |
| try: | |
| first = remaining_data.pop(remaining_data.index(next(filter(lambda x: x not in {first, second, third}, remaining_data), None))) | |
| except: | |
| first = i1 | |
| if second is None: | |
| try: | |
| second = remaining_data.pop(remaining_data.index(next(filter(lambda x: x not in {first, second, third}, remaining_data), None))) | |
| except: | |
| second = i2 | |
| if third is None: | |
| try: | |
| third = remaining_data.pop(remaining_data.index(next(filter(lambda x: x not in {first, second, third}, remaining_data), None))) | |
| except: | |
| third = i3 | |
| return first, second, third | |
| def settle_all_address(address_first: str, address_second: str, address_third: str): | |
| address_1 = address_first | |
| address_2 = address_second | |
| address_3 = address_third | |
| r_add1 = None | |
| r_add2 = None | |
| r_add3 = None | |
| # Check for first function | |
| if check_for_first(address_first): | |
| r_add1 = address_first | |
| elif check_for_first(address_second): | |
| r_add1 = address_second | |
| elif check_for_first(address_third): | |
| r_add1 = address_third | |
| # Check for second function | |
| if check_for_second(address_first): | |
| r_add2 = address_first | |
| elif check_for_second(address_second): | |
| r_add2 = address_second | |
| elif check_for_second(address_third): | |
| r_add2 = address_third | |
| # Check for third function | |
| if check_for_third(address_first): | |
| r_add3 = address_first | |
| elif check_for_third(address_second): | |
| r_add3 = address_second | |
| elif check_for_third(address_third): | |
| r_add3 = address_third | |
| if r_add1 == r_add2 or r_add1 == r_add3 or r_add2 == r_add3: | |
| # Duplicate data found now perform the comparizon in here | |
| if r_add1 == r_add2 == r_add3: | |
| r_add1 = None | |
| r_add2 = None | |
| r_add3 = None | |
| else: | |
| if r_add1 == r_add2 and r_add1 != None: # If address 1 and address 2 is same then use AI for checking | |
| m_add = find_missing_data(address_1, address_2, address_3, r_add1, r_add2, r_add3) # Find the missing address and add it to the r_add3 | |
| if compaire_two(m_add, r_add2, 1): | |
| r_add2 = m_add | |
| else: | |
| r_add1 = m_add | |
| elif r_add1 == r_add3 and r_add1 != None: | |
| m_add = find_missing_data(address_1, address_2, address_3, r_add1, r_add2, r_add3) # Find the missing address and add it to the r_add3 | |
| if compaire_two(m_add, r_add3, 1): | |
| r_add1 = m_add | |
| else: | |
| r_add3 = m_add | |
| elif r_add2 == r_add3 and r_add2 != None: | |
| m_add = find_missing_data(address_1, address_2, address_3, r_add1, r_add2, r_add3) # Find the missing address and add it to the r_add3 | |
| if compaire_two(m_add, r_add3, 3): | |
| r_add3 = m_add | |
| else: | |
| r_add2 = m_add | |
| if r_add1 == None or r_add2 == None or r_add3 == None: | |
| # if any of them is None then calculate the address | |
| ai_position1 = get_ai_position(address_1) | |
| ai_position2 = get_ai_position(address_2) | |
| ai_position3 = get_ai_position(address_3) | |
| if ai_position1 == 3: | |
| if r_add3: | |
| pass | |
| else: | |
| r_add3 = address_1 | |
| if r_add1 == None or r_add2 == None: | |
| if r_add3 == address_1: | |
| if compare_by_mid(1, 2, address_2): | |
| r_add1 = address_2 | |
| r_add2 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add2 = address_2 | |
| elif r_add3 == address_2: | |
| if compare_by_mid(1, 2, address_1): | |
| r_add1 = address_1 | |
| r_add2 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add2 = address_1 | |
| elif r_add3 == address_3: | |
| if compare_by_mid(1, 2, address_1): | |
| r_add1 = address_1 | |
| r_add2 = address_2 | |
| else: | |
| r_add1 = address_2 | |
| r_add2 = address_1 | |
| elif ai_position1 == 2: | |
| if r_add2: | |
| pass | |
| else: | |
| r_add2 = address_1 | |
| if r_add1 == None or r_add3 == None: | |
| if r_add2 == address_1: | |
| if compare_by_mid(1, 3, address_2): | |
| r_add1 = address_2 | |
| r_add3 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add3 = address_2 | |
| elif r_add2 == address_2: | |
| if compare_by_mid(1, 3, address_1): | |
| r_add1 = address_1 | |
| r_add3 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add3 = address_1 | |
| elif r_add2 == address_3: | |
| if compare_by_mid(1, 3, address_1): | |
| r_add1 = address_1 | |
| r_add3 = address_2 | |
| else: | |
| r_add1 = address_2 | |
| r_add3 = address_1 | |
| else: | |
| if r_add1: | |
| pass | |
| else: | |
| r_add1 = address_1 | |
| if r_add2 == None or r_add3 == None: | |
| if r_add1 == address_1: | |
| if compare_by_mid(2, 3, address_2): | |
| r_add2 = address_2 | |
| r_add3 = address_3 | |
| else: | |
| r_add2 = address_3 | |
| r_add3 = address_2 | |
| elif r_add1 == address_2: | |
| if compare_by_mid(2, 3, address_1): | |
| r_add2 = address_1 | |
| r_add3 = address_3 | |
| else: | |
| r_add2 = address_3 | |
| r_add3 = address_1 | |
| elif r_add1 == address_3: | |
| if compare_by_mid(2, 3, address_1): | |
| r_add2 = address_1 | |
| r_add3 = address_2 | |
| else: | |
| r_add2 = address_2 | |
| r_add3 = address_1 | |
| if ai_position2 == 3: | |
| if r_add3: | |
| pass | |
| else: | |
| r_add3 = address_2 | |
| if r_add1 == None or r_add2 == None: | |
| if r_add3 == address_1: | |
| if compare_by_mid(1, 2, address_2): | |
| r_add1 = address_2 | |
| r_add2 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add2 = address_2 | |
| elif r_add3 == address_2: | |
| if compare_by_mid(1, 2, address_1): | |
| r_add1 = address_1 | |
| r_add2 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add2 = address_1 | |
| elif r_add3 == address_3: | |
| if compare_by_mid(1, 2, address_1): | |
| r_add1 = address_1 | |
| r_add2 = address_2 | |
| else: | |
| r_add1 = address_2 | |
| r_add2 = address_1 | |
| elif ai_position2 == 2: | |
| if r_add2: | |
| pass | |
| else: | |
| r_add2 = address_2 | |
| if r_add1 == None or r_add3 == None: | |
| if r_add2 == address_1: | |
| if compare_by_mid(1, 3, address_2): | |
| r_add1 = address_2 | |
| r_add3 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add3 = address_2 | |
| elif r_add2 == address_2: | |
| if compare_by_mid(1, 3, address_1): | |
| r_add1 = address_1 | |
| r_add3 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add3 = address_1 | |
| elif r_add2 == address_3: | |
| if compare_by_mid(1, 3, address_1): | |
| r_add1 = address_1 | |
| r_add3 = address_2 | |
| else: | |
| r_add1 = address_2 | |
| r_add3 = address_1 | |
| else: | |
| if r_add1: | |
| pass | |
| else: | |
| r_add1 = address_2 | |
| if r_add2 == None or r_add3 == None: | |
| if r_add1 == address_1: | |
| if compare_by_mid(2, 3, address_2): | |
| r_add2 = address_2 | |
| r_add3 = address_3 | |
| else: | |
| r_add2 = address_3 | |
| r_add3 = address_2 | |
| elif r_add1 == address_2: | |
| if compare_by_mid(2, 3, address_1): | |
| r_add2 = address_1 | |
| r_add3 = address_3 | |
| else: | |
| r_add2 = address_3 | |
| r_add3 = address_1 | |
| elif r_add1 == address_3: | |
| if compare_by_mid(2, 3, address_1): | |
| r_add2 = address_1 | |
| r_add3 = address_2 | |
| else: | |
| r_add2 = address_2 | |
| r_add3 = address_1 | |
| if ai_position3 == 3: | |
| if r_add3: | |
| pass | |
| else: | |
| r_add3 = address_3 | |
| if r_add1 == None or r_add2 == None: | |
| if r_add3 == address_1: | |
| if compare_by_mid(1, 2, address_2): | |
| r_add1 = address_2 | |
| r_add2 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add2 = address_2 | |
| elif r_add3 == address_2: | |
| if compare_by_mid(1, 2, address_1): | |
| r_add1 = address_1 | |
| r_add2 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add2 = address_1 | |
| elif r_add3 == address_3: | |
| if compare_by_mid(1, 2, address_1): | |
| r_add1 = address_1 | |
| r_add2 = address_2 | |
| else: | |
| r_add1 = address_2 | |
| r_add2 = address_1 | |
| elif ai_position3 == 2: | |
| if r_add2: | |
| pass | |
| else: | |
| r_add2 = address_3 | |
| if r_add1 == None or r_add3 == None: | |
| if r_add2 == address_1: | |
| if compare_by_mid(1, 3, address_2): | |
| r_add1 = address_2 | |
| r_add3 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add3 = address_2 | |
| elif r_add2 == address_2: | |
| if compare_by_mid(1, 3, address_1): | |
| r_add1 = address_1 | |
| r_add3 = address_3 | |
| else: | |
| r_add1 = address_3 | |
| r_add3 = address_1 | |
| elif r_add2 == address_3: | |
| if compare_by_mid(1, 3, address_1): | |
| r_add1 = address_1 | |
| r_add3 = address_2 | |
| else: | |
| r_add1 = address_2 | |
| r_add3 = address_1 | |
| else: | |
| if r_add1: | |
| pass | |
| else: | |
| r_add1 = address_3 | |
| if r_add2 == None or r_add3 == None: | |
| if r_add1 == address_1: | |
| if compare_by_mid(2, 3, address_2): | |
| r_add2 = address_2 | |
| r_add3 = address_3 | |
| else: | |
| r_add2 = address_3 | |
| r_add3 = address_2 | |
| elif r_add1 == address_2: | |
| if compare_by_mid(2, 3, address_1): | |
| r_add2 = address_1 | |
| r_add3 = address_3 | |
| else: | |
| r_add2 = address_3 | |
| r_add3 = address_1 | |
| elif r_add1 == address_3: | |
| if compare_by_mid(2, 3, address_1): | |
| r_add2 = address_1 | |
| r_add3 = address_2 | |
| else: | |
| r_add2 = address_2 | |
| r_add3 = address_1 | |
| return swapper(r_add1, r_add2, r_add3) | |
| def process_file(filepath: str): | |
| wb = openpyxl.load_workbook(filepath, data_only=True) | |
| ws = wb.active | |
| new_wb = openpyxl.Workbook() | |
| new_ws = new_wb.active | |
| temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx') | |
| temp_path = temp_file.name | |
| columns_to_process = [4, 5, 6] | |
| for col in range(1, ws.max_column + 1): | |
| new_ws.cell(row=1, column=col).value = ws.cell(row=1, column=col).value | |
| empty_rows = 0 | |
| # for row in ws.iter_rows(min_row=2, max_row=ws.max_row): | |
| # if any(cell.value not in (None, "") for cell in row): | |
| # total_row += 1 | |
| for row in ws.iter_rows(min_row=2, max_row=ws.max_row): | |
| if empty_rows > 3: | |
| break | |
| row_num = row[0].row | |
| for col in range(1, ws.max_column + 1): | |
| if col not in columns_to_process: | |
| new_ws.cell(row=row_num, column=col).value = ws.cell(row=row_num, column=col).value | |
| else: | |
| new_ws.cell(row=row_num, column=col).value = None | |
| address_first = ws.cell(row=row_num, column=4).value | |
| address_second = ws.cell(row=row_num, column=5).value | |
| address_third = ws.cell(row=row_num, column=6).value | |
| if address_first != None and address_second != None and address_third != None: | |
| # print(f"Processing {address_first} | {address_second} | {address_third}") | |
| ad1, ad2, ad3 = settle_all_address(address_first, address_second, address_third) | |
| new_ws.cell(row=row_num, column=4).value = ad1 | |
| new_ws.cell(row=row_num, column=5).value = ad2 | |
| new_ws.cell(row=row_num, column=6).value = ad3 | |
| print(f"Adding : {ad1} | {ad2} | {ad3}") | |
| else: | |
| empty_rows += 1 | |
| new_wb.save(temp_path) | |
| return temp_path | |
| def gradio_process(file): | |
| file_path = file.name | |
| output_file_path = process_file(file_path) | |
| return output_file_path | |
| iface = gr.Interface( | |
| fn=gradio_process, | |
| inputs=gr.File(), | |
| outputs=gr.File(), | |
| title="AI Address Processor", | |
| description="Upload an Excel file, and the AI will process the addresses." | |
| ) | |
| iface.launch() |