Update app.py

app.py

@@ -1,162 +1,381 @@
-import gradio as gr
+import pathlib
+import textwrap
 import pandas as pd
+import numpy as np
 from fuzzywuzzy import fuzz
-import tempfile
-
-
-def process_csv(file):
-  import pandas as pd
-  # import pyodbc
-  from fuzzywuzzy import fuzz
-  from openpyxl import load_workbook
-  from openpyxl.styles import PatternFill
-
-  df = pd.read_excel(file)
-
-  df['Address'] = df['Address (street)'].astype(str) + '-' + df['Postal code'].astype(str) + '-' + df['City'].astype(str) + '-' + df['Country'].astype(str) + df['Region'].astype(str)
-  df['Name'] = df['Vendor Name'].astype(str)
-
-  df['Name']=df['Name'].str.lower()
-  df['Address']=df['Address'].str.lower()
-
-  df.sort_values(['Name'], inplace=True)
-  df = df.reset_index(drop=True)
-
-  df['name_fuzzy_ratio']=''
-  df['address_fuzzy_ratio']=''
-  df['name_based_group']=''
-  df['address_based_group']=''
-
-  last_row_index = len(df)-1
-  df.at[0,'name_fuzzy_ratio']=100
-  df.at[0,'address_fuzzy_ratio']=100
-  df.at[last_row_index,'name_fuzzy_ratio']=100
-  df.at[last_row_index,'address_fuzzy_ratio']=100
-
-  for i in range(1,last_row_index):
-      current_name = df['Name'].iloc[i]
-      previous_name = df['Name'].iloc[i-1]
-      fuzzy_ratio = fuzz.ratio(previous_name,current_name)
-      df.at[i,'name_fuzzy_ratio'] = fuzzy_ratio
-
-  df['name_fuzzy_ratio'] = pd.to_numeric(df['name_fuzzy_ratio'], errors='coerce')
-
-  group_counter = 1
-  df.at[0,'name_based_group'] = group_counter
-
-  for i in range (1, len(df)):
-      if df.at[i,'name_fuzzy_ratio'] > 80:
-          df.at[i,'name_based_group'] = df.at[i-1,'name_based_group']
+from openpyxl import load_workbook
+from openpyxl.styles import PatternFill
+import google.generativeai as genai
+from IPython.display import display
+from IPython.display import Markdown
+from openpyxl.styles.alignment import Alignment
+from google.colab import userdata
+GOOGLE_API_KEY='AIzaSyCtACPu9EOnEa1_iAWsv_u__PQRpaCT564'
+genai.configure(api_key=GOOGLE_API_KEY)
+model = genai.GenerativeModel('gemini-1.0-pro')
+def to_markdown(text):
+  text = text.replace('•', '  *')
+  return Markdown(textwrap.indent(text, '> ', predicate=lambda _: True))
+# Function to apply to df1 to create the cont_person_name column
+def process_fuzzy_ratios(rows_dict):
+    fuzz_data = {}
+    for key, row in enumerate(rows_dict):
+        if key == 0:
+            # For the first row, delete specified columns
+            del row["address_fuzzy_ratio"]
+            del row["bank_fuzzy_ratio"]
+            del row["name_fuzzy_ratio"]
+            del row["accgrp_fuzzy_ratio"]
+            del row["tax_fuzzy_ratio"]
+            del row["postal_fuzzy_ratio"]
+        else:
+            # For subsequent rows, store data in fuzz_data dictionary
+            fuzz_data["row_" + str(key + 1)] = {
+                "address_fuzzy_ratio": row.pop("address_fuzzy_ratio"),
+                "bank_fuzzy_ratio": row.pop("bank_fuzzy_ratio"),
+                "name_fuzzy_ratio": row.pop("name_fuzzy_ratio"),
+                "accgrp_fuzzy_ratio": row.pop("accgrp_fuzzy_ratio"),
+                "tax_fuzzy_ratio": row.pop("tax_fuzzy_ratio"),
+                "postal_fuzzy_ratio": row.pop("postal_fuzzy_ratio")
+            }
+    return fuzz_data, rows_dict
+def gemini_analysis(dataframe):
+    prev_row_duplicate = False
+    prev_row_number = None
+
+    for index, row in dataframe.iterrows():
+        if row['Remarks'] == 'Duplicate':
+            if prev_row_duplicate:
+                duplicate_pairs=[]
+                row1 = dataframe.loc[index-1].to_dict()
+                row2 = row.to_dict()
+                duplicate_pairs.append(row1)
+                duplicate_pairs.append(row2)
+                fuzzy_ratios, duplicate_pairs = process_fuzzy_ratios(duplicate_pairs)
+                for dictionary in duplicate_pairs:
+                    for _ in range(12):
+                        if dictionary:
+                            dictionary.popitem()
+                main_data_str = "[{}]".format(', '.join([str(d) for d in duplicate_pairs]))
+                fuzzy_data_str = "{}".format(fuzzy_ratios)
+                qs="I have the data",main_data_str,"The corresponding fuzzy ratios are here: ",fuzzy_data_str,"Give a concise explanation why these two rows are duplicate based on analyzing the main data and explaining which column values are same and which column values are different?"
+                try:
+                    response = model.generate_content(qs)
+                    dataframe.at[index-1, 'Explanation'] = response.text
+                except requests.HTTPError as e:
+                    print(f"Error fetching Gemini response': {e}")
+                except ValueError as ve:
+                    print(f"ValueError occurred: {ve}")
+                except Exception as ex:
+                    print(f"An error occurred: {ex}")
+                dataframe.at[index-1, 'Explanation'] = response.text
+            prev_row_duplicate = True
+            prev_row_number = index
+        else:
+            prev_row_duplicate = False
+            prev_row_number = None
+
+def process_csv(file, remove_null_columns):
+    sheet_name1 = 'General Data '
+    sheet_name2 = 'Contact Person'
+    df = pd.read_excel(file, sheet_name=sheet_name1,engine='openpyxl')
+    # Replace null values with a blank space
+    df=df.fillna(" ")
+    df1 = pd.read_excel(file, sheet_name=sheet_name2)
+    # Replace null values with a blank space
+    df1 = df1.fillna(" ")
+    # Creating new columns by concatenating original columns
+    df['Address'] = df['STREET'].astype(str) +'-'+ df['CITY1'].astype(str) +'-'+ df['COUNTRY'].astype(str) + '-' + df['REGION'].astype(str)
+    df['Name'] = df['NAMEFIRST'].astype(str)+'-'+ df['NAMELAST'].astype(str) +'-'+ df['NAME3'].astype(str) + '-' + df['NAME4'].astype(str)
+    df['Bank'] = df['BANKL'].astype(str)+'-'+df['BANKN'].astype(str)
+    df['Tax'] = df['TAXTYPE'].astype(str)+'-'+df['TAXNUM'].astype(str)
+    df1['cont_person_name'] = df1['PARNR'].astype(str)+'-'+ df1['VNAME'].astype(str) +'-'+ df1['LNAME'].astype(str)
+    df1['cont_person_address'] = df1['COUNTRY'].astype(str) +'-'+ df1['REGION'].astype(str) +'-'+ df1['POSTLCD'].astype(str) +'-'+ df1['CITY'].astype(str) + '-' + df1['STREET'].astype(str)
+
+    # Converting all concatenated columns to lowercase
+    df['Name']=df['Name'].str.lower()
+    df['Address']=df['Address'].str.lower()
+    df['Bank']=df['Bank'].str.lower()
+    df['Tax']=df['Tax'].str.lower()
+    df1['cont_person_name']=df1['cont_person_name'].str.lower()
+    df1['cont_person_address']=df1['cont_person_address'].str.lower()
+    #Adding contact_person_name and address to sheet1(General Data)
+
+    # Grouping names in df2 based on LIFNR (ID)
+    grouped_names = df1.groupby("LIFNR")["cont_person_name"].agg(lambda x: ', '.join(x)).reset_index()
+
+    # Create a dictionary mapping LIFNR to concatenated names
+    name_map = dict(zip(grouped_names["LIFNR"], grouped_names["cont_person_name"]))
+    def create_cont_person_name(row):
+      if row["LIFNR"] in name_map:
+          return name_map[row["LIFNR"]]
       else:
-          group_counter += 1
-          df.at[i,'name_based_group'] = group_counter
-
-  group = df.at[0,'name_based_group']
-
-  df.sort_values(['name_based_group','Address'], inplace=True)
-  df = df.reset_index(drop=True)
-
-  for i in range(1,last_row_index):
-      current_address = df['Address'].iloc[i]
-      previous_address = df['Address'].iloc[i-1]
-      fuzzy_ratio = fuzz.ratio(previous_address, current_address)
-      df.at[i,'address_fuzzy_ratio'] = fuzzy_ratio
-
-  df['address_fuzzy_ratio'] = pd.to_numeric(df['address_fuzzy_ratio'], errors='coerce')
+          return ""
 
-  address_group_counter = 1
-  df.at[0,'address_based_group'] = str(address_group_counter)
-
-  for i in range(1,len(df)):
-      if df.at[i,'address_fuzzy_ratio'] > 70:
-          df.at[i,'address_based_group'] = df.at[i-1, 'address_based_group']
+    grouped_names = df1.groupby("LIFNR")["cont_person_address"].agg(lambda x: ', '.join(x)).reset_index()
+    add_map = dict(zip(grouped_names["LIFNR"], grouped_names["cont_person_address"]))
+    def create_cont_person_add(row):
+      if row["LIFNR"] in add_map:
+          return add_map[row["LIFNR"]]
       else:
-        if df.at[i,'name_based_group'] != group:
-            address_group_counter = 1
-            group = df.at[i,'name_based_group']
+          return ""
+
+    # Apply the function to create the cont_person_name column
+    df["cont_person_name"] = df.apply(create_cont_person_name, axis=1)
+    df["cont_person_address"] = df.apply(create_cont_person_add, axis=1)
+    df['name_fuzzy_ratio']=''
+    df['accgrp_fuzzy_ratio']=''
+    df['address_fuzzy_ratio']=''
+    df['bank_fuzzy_ratio']=''
+    df['tax_fuzzy_ratio']=''
+    df['postal_fuzzy_ratio']=''
+    df1['cont_person_name_fuzzy_ratio']=''
+    df1['cont_person_address_fuzzy_ratio']=''
+
+    df['name_based_group']=''
+    df['accgrp_based_group']=''
+    df['address_based_group']=''
+    df['bank_based_group']=''
+    df['tax_based_group']=''
+    df['postal_based_group']=''
+    df1['cont_person_name_based_group']=''
+    df1['cont_person_address_based_group']=''
+
+    last_row_index = len(df)-1
+    last_row_index1 = len(df1)-1
+
+    df.sort_values(['Tax'], inplace=True)
+    df = df.reset_index(drop=True)
+    df.at[0,'tax_fuzzy_ratio']=100
+    df.at[last_row_index,'tax_fuzzy_ratio']=100
+    for i in range(1,last_row_index):
+        current_tax = df['Tax'].iloc[i]
+        previous_tax = df['Tax'].iloc[i-1]
+        fuzzy_ratio = fuzz.ratio(previous_tax,current_tax)
+        df.at[i,'tax_fuzzy_ratio'] = fuzzy_ratio
+
+    df['tax_fuzzy_ratio'] = pd.to_numeric(df['tax_fuzzy_ratio'], errors='coerce')
+
+    group_counter = 1
+    df.at[0,'tax_based_group'] = group_counter
+
+    for i in range (1, len(df)):
+        if df.at[i,'tax_fuzzy_ratio'] > 90:
+            df.at[i,'tax_based_group'] = df.at[i-1,'tax_based_group']
         else:
-                address_group_counter +=1
-      df.at[i,'address_based_group'] = str(address_group_counter)
-
-
-  #Concatenate for unique group name
-  df['Group'] = df.apply(lambda row: 'Group_{}_{}'.format(row['name_based_group'], row['address_based_group']), axis = 1)
-
-  columns_to_drop = ['name_fuzzy_ratio','address_fuzzy_ratio','Address','Name']
-  df.drop(columns=columns_to_drop, inplace=True)
-
-  # Check for duplicates in 'Group' column
-  duplicate_groups = df['Group'].duplicated(keep=False)
-
-  # Create 'Remarks' column and mark duplicates as 'Duplicate' and unique as 'Unique'
-  df['Remarks'] = ['Duplicate' if is_duplicate else 'Unique' for is_duplicate in duplicate_groups]
-
-  print(df)
-
-  # excel_writer = pd.ExcelWriter("C://Users//snigd//Downloads//output_vendor_2.xlsx", engine='openpyxl')
-  # df.to_excel(excel_writer, index=False, sheet_name='Sheet1')
-
-  # # Access the workbook
-  # workbook = excel_writer.book
-  # worksheet = workbook['Sheet1']
-
-  # # Apply row coloring based on the value in the 'Remarks' column
-  # duplicate_fill = PatternFill(start_color="FFFF00", end_color="FFFF00", fill_type="solid")
+            group_counter += 1
+            df.at[i,'tax_based_group'] = group_counter
+    group = df.at[0,'tax_based_group']
+
+    df.sort_values(['tax_based_group','Bank'], inplace=True)
+    df = df.reset_index(drop=True)
+    df.at[0,'bank_fuzzy_ratio']=100
+    df.at[last_row_index,'bank_fuzzy_ratio']=100
+    for i in range(1,last_row_index):
+        current_address = df['Bank'].iloc[i]
+        previous_address = df['Bank'].iloc[i-1]
+        fuzzy_ratio = fuzz.ratio(previous_address, current_address)
+        df.at[i,'bank_fuzzy_ratio'] = fuzzy_ratio
+
+    df['bank_fuzzy_ratio'] = pd.to_numeric(df['bank_fuzzy_ratio'], errors='coerce')
+
+    address_group_counter = 1
+    df.at[0,'bank_based_group'] = str(address_group_counter)
+
+    for i in range(1,len(df)):
+        if df.at[i,'bank_fuzzy_ratio'] >= 100:
+            df.at[i,'bank_based_group'] = df.at[i-1, 'bank_based_group']
+        else:
+          if df.at[i,'tax_based_group'] != group:
+              address_group_counter = 1
+              group = df.at[i,'tax_based_group']
+          else:
+                  address_group_counter +=1
+        df.at[i,'bank_based_group'] = str(address_group_counter)
+    df['Group_tax_bank'] = df.apply(lambda row: '{}_{}'.format(row['tax_based_group'], row['bank_based_group']), axis = 1)
+    group = df.at[0,'Group_tax_bank']
+
+    df.sort_values(['Group_tax_bank','Address'], inplace=True)
+    df = df.reset_index(drop=True)
+    df.at[0,'address_fuzzy_ratio']=100
+    df.at[last_row_index,'address_fuzzy_ratio']=100
+    for i in range(1,last_row_index):
+        current_address = df['Address'].iloc[i]
+        previous_address = df['Address'].iloc[i-1]
+        fuzzy_ratio = fuzz.ratio(previous_address, current_address)
+        df.at[i,'address_fuzzy_ratio'] = fuzzy_ratio
+
+    df['address_fuzzy_ratio'] = pd.to_numeric(df['address_fuzzy_ratio'], errors='coerce')
+
+    address_group_counter = 1
+    df.at[0,'address_based_group'] = str(address_group_counter)
+
+    for i in range(1,len(df)):
+        if df.at[i,'address_fuzzy_ratio'] > 70:
+            df.at[i,'address_based_group'] = df.at[i-1, 'address_based_group']
+        else:
+          if df.at[i,'Group_tax_bank'] != group:
+              address_group_counter = 1
+              group = df.at[i,'Group_tax_bank']
+          else:
+                  address_group_counter +=1
+        df.at[i,'address_based_group'] = str(address_group_counter)
+    df['Group_tax_bank_add'] = df.apply(lambda row: '{}_{}'.format(row['Group_tax_bank'], row['address_based_group']), axis = 1)
+    group = df.at[0,'Group_tax_bank_add']
+
+    df.sort_values(['Group_tax_bank_add','Name'], inplace=True)
+    df = df.reset_index(drop=True)
+    df.at[0,'name_fuzzy_ratio']=100
+    df.at[last_row_index,'name_fuzzy_ratio']=100
+    for i in range(1,last_row_index):
+        current_address = df['Name'].iloc[i]
+        previous_address = df['Name'].iloc[i-1]
+        fuzzy_ratio = fuzz.ratio(previous_address, current_address)
+        df.at[i,'name_fuzzy_ratio'] = fuzzy_ratio
+
+    df['name_fuzzy_ratio'] = pd.to_numeric(df['name_fuzzy_ratio'], errors='coerce')
+
+    address_group_counter = 1
+    df.at[0,'name_based_group'] = str(address_group_counter)
+
+    for i in range(1,len(df)):
+        if df.at[i,'name_fuzzy_ratio'] > 80:
+            df.at[i,'name_based_group'] = df.at[i-1, 'name_based_group']
+        else:
+          if df.at[i,'Group_tax_bank_add'] != group:
+              address_group_counter = 1
+              group = df.at[i,'Group_tax_bank_add']
+          else:
+                  address_group_counter +=1
+        df.at[i,'name_based_group'] = str(address_group_counter)
+    df['Group_tax_bank_add_name'] = df.apply(lambda row: '{}_{}'.format(row['Group_tax_bank_add'], row['name_based_group']), axis = 1)
+    group = df.at[0,'Group_tax_bank_add_name']
+
+    df.sort_values(['Group_tax_bank_add_name','POSTCODE1'], inplace=True)
+    df = df.reset_index(drop=True)
+    df.at[0,'postal_fuzzy_ratio']=100
+    df.at[last_row_index,'postal_fuzzy_ratio']=100
+    for i in range(1,last_row_index):
+        current_address = df['POSTCODE1'].iloc[i]
+        previous_address = df['POSTCODE1'].iloc[i-1]
+        fuzzy_ratio = fuzz.ratio(previous_address, current_address)
+        df.at[i,'postal_fuzzy_ratio'] = fuzzy_ratio
+
+    df['postal_fuzzy_ratio'] = pd.to_numeric(df['postal_fuzzy_ratio'], errors='coerce')
+
+    address_group_counter = 1
+    df.at[0,'postal_based_group'] = str(address_group_counter)
+
+    for i in range(1,len(df)):
+        if df.at[i,'postal_fuzzy_ratio'] > 90:
+            df.at[i,'postal_based_group'] = df.at[i-1, 'postal_based_group']
+        else:
+          if df.at[i,'Group_tax_bank_add_name'] != group:
+              address_group_counter = 1
+              group = df.at[i,'Group_tax_bank_add_name']
+          else:
+                  address_group_counter +=1
+        df.at[i,'postal_based_group'] = str(address_group_counter)
+    df['Group_tax_bank_add_name_post'] = df.apply(lambda row: '{}_{}'.format(row['Group_tax_bank_add_name'], row['postal_based_group']), axis = 1)
+    group = df.at[0,'Group_tax_bank_add_name_post']
+
+    df.sort_values(['Group_tax_bank_add_name_post','KTOKK'], inplace=True)
+    df = df.reset_index(drop=True)
+    df.at[0,'accgrp_fuzzy_ratio']=100
+    df.at[last_row_index,'accgrp_fuzzy_ratio']=100
+    for i in range(1,last_row_index):
+        current_address = df['KTOKK'].iloc[i]
+        previous_address = df['KTOKK'].iloc[i-1]
+        fuzzy_ratio = fuzz.ratio(previous_address, current_address)
+        df.at[i,'accgrp_fuzzy_ratio'] = fuzzy_ratio
+
+    df['accgrp_fuzzy_ratio'] = pd.to_numeric(df['accgrp_fuzzy_ratio'], errors='coerce')
+
+    address_group_counter = 1
+    df.at[0,'accgrp_based_group'] = str(address_group_counter)
+
+    for i in range(1,len(df)):
+        if df.at[i,'accgrp_fuzzy_ratio'] >=100:
+            df.at[i,'accgrp_based_group'] = df.at[i-1, 'accgrp_based_group']
+        else:
+          if df.at[i,'Group_tax_bank_add_name_post'] != group:
+              address_group_counter = 1
+              group = df.at[i,'Group_tax_bank_add_name_post']
+          else:
+                  address_group_counter +=1
+        df.at[i,'accgrp_based_group'] = str(address_group_counter)
+    df['Group_tax_bank_add_name_post_accgrp'] = df.apply(lambda row: '{}_{}'.format(row['Group_tax_bank_add_name_post'], row['accgrp_based_group']), axis = 1)
+    group = df.at[0,'Group_tax_bank_add_name_post_accgrp']
 
-  # for idx, row in df.iterrows():
-  #     if row['Remarks'] == 'Duplicate':
-  #         for cell in worksheet[idx + 2]:
-  #             cell.fill = duplicate_fill
+    duplicate_groups = df['Group_tax_bank_add_name_post_accgrp'].duplicated(keep=False)
+    df['Remarks'] = ['Duplicate' if is_duplicate else 'Unique' for is_duplicate in duplicate_groups]
 
-  # # Save the changes
-  # excel_writer.save()
 
-  # print("Excel file saved successfully.")
+    df.replace(" ", np.nan, inplace=True)
+    nan_percentage = df.isna().mean(axis=0)
 
-  # # Printing the resulting DataFrame
+    # Filter columns with more than 70% NaN values
+    columns_to_drop = nan_percentage[nan_percentage > 0.7].index
+    if remove_null_columns=='Yes':
+          df.drop(columns=columns_to_drop, inplace=True)
+    df.replace(np.nan, " ", inplace=True)
 
-  # # Saving the processed DataFrame to a new CSV file
 
-  # # Create SQLAlchemy engine to connect to SQL Server
-  # # This part is commented out, as it seems to be not used
+    # Call the function with your DataFrame
+    gemini_analysis(df)
 
-  # # Prepare the DataFrame for download as a CSV string
-  # with tempfile.NamedTemporaryFile(prefix="Outputs", suffix=".csv", delete=False) as temp_file:
-  #   df.to_excel(temp_file.name, index=False)
-  # return temp_file.name
+    columns_to_drop = ['name_fuzzy_ratio','accgrp_fuzzy_ratio','address_fuzzy_ratio','bank_fuzzy_ratio','tax_fuzzy_ratio','postal_fuzzy_ratio','name_based_group','accgrp_based_group','address_based_group','bank_based_group','tax_based_group','postal_based_group','Group_tax_bank','Group_tax_bank_add', 'Group_tax_bank_add_name', 'Group_tax_bank_add_name_post']
+    df = df.drop(columns=columns_to_drop, axis=1)
 
-  with tempfile.NamedTemporaryFile(prefix="Outputs", suffix=".xlsx", delete=False) as temp_file:
-      df.to_excel(temp_file.name, index=False)
 
-  excel_writer = pd.ExcelWriter(temp_file.name, engine='openpyxl')
-  df.to_excel(excel_writer, index=False, sheet_name='Sheet1')
+    with tempfile.NamedTemporaryFile(prefix="Outputs", suffix=".xlsx", delete=False) as temp_file:
+        df.to_excel(temp_file.name, index=False)
+    excel_writer = pd.ExcelWriter(temp_file.name, engine='openpyxl')
+    df.to_excel(excel_writer, index=False, sheet_name='Sheet1')
 
     # Access the workbook
-  workbook = excel_writer.book
-  worksheet = workbook['Sheet1']
+    workbook = excel_writer.book
+    worksheet = workbook['Sheet1']
 
     # Apply row coloring based on the value in the 'Remarks' column
-  duplicate_fill = PatternFill(start_color="FFFF00", end_color="FFFF00", fill_type="solid")
+    duplicate_fill = PatternFill(start_color="FFFF00", end_color="FFFF00", fill_type="solid")
+
+    for idx, row in df.iterrows():
+        if row['Remarks'] == 'Duplicate':
+            for cell in worksheet[idx + 2]:
+                cell.alignment = Alignment(wrap_text=True)
+                cell.fill = duplicate_fill
+
+    # Iterate over columns and set their width based on a specific calculation
+    for col in worksheet.columns:
+        col_letter = col[0].column_letter
+        worksheet.column_dimensions[col_letter].width = 28
 
-  for idx, row in df.iterrows():
-      if row['Remarks'] == 'Duplicate':
-          for cell in worksheet[idx + 2]:
-              cell.fill = duplicate_fill
+    # Iterate over rows and set their height based on a specific calculation
+    for row in worksheet.iter_rows():
+        worksheet.row_dimensions[row[0].row].height = 20  # Set the row height to 25 (adjust as needed)
 
     # Save the changes
-  excel_writer.close()
+    excel_writer.close()
 
-  print("Excel file saved successfully.")
+    print("Excel file saved successfully.")
 
-  return temp_file.name
+    return temp_file.name
 
 
 interface = gr.Interface(
     fn=process_csv,
-    inputs=gr.File(label="Upload XLSX File", file_count="single"),
+    inputs=[
+        gr.File(label="Upload XLSX File", file_count="single"),
+        gr.Radio(
+            ["Yes", "No"],
+            label="Remove Columns?",
+            info="The columns with 70% or More Null Values will be removed"
+        )
+    ],
     outputs=gr.File(label="Download File"),
-    title="Vendor Master De-Duplication Tool",
-    description="Upload a XLSX file and download a new one with duplicates removed."
+    title="Vendor Master De-Duplication Tool",
+    description="Upload a XLSX file and choose which column to check for duplicates."
 )
 
-interface.launch(share=True)
+interface.launch(share=True)