Fix rebase conflict

Dockerfile

@@ -0,0 +1,25 @@
+# Dockerfile for Translator App
+
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file and application files into the container
+COPY requirements.txt ./
+COPY translator_app.py ./Translator/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Jupyter and necessary extensions
+# RUN pip install jupyter jupyter-server jupyterlab
+
+# Expose port for Jupyter Notebook
+EXPOSE 7860
+
+# Run Jupyter Notebook
+# CMD ["jupyter", "notebook",  "./Translator/translator_app.ipynb", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]
+# Run Gradio application
+CMD ["python", "/app/Translator/translator_app.py"]

requirements.txt

@@ -1 +1,10 @@
-huggingface_hub==0.25.2
+<<<<<<< HEAD
+huggingface_hub==0.25.2
+=======
+gradio==4.44.0
+langchain-openai
+xlsxwriter==3.2.0
+pandas==2.0.3
+numpy==1.24.3
+openpyxl==3.1.5
+>>>>>>> 9a3f3c9 (first app commited)

translator_app.ipynb

@@ -0,0 +1,422 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {
+    "id": "dKoye1NqPPWX"
+   },
+   "outputs": [],
+   "source": [
+    "# pip install -q -U gradio langchain-openai xlsxwriter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Library Import\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "from langchain_core.output_parsers import JsonOutputParser\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "from langchain_core.runnables import RunnableLambda\n",
+    "import gradio as gr\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# API Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Process"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using ChatGPT-4o-mini"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def using_model(chosen_model, api_key):\n",
+    "    if chosen_model == 'ChatGPT (4o-mini)':\n",
+    "        model = chat_gpt_4o_mini(api_key = api_key)\n",
+    "    else:\n",
+    "        pass\n",
+    "    return model\n",
+    "\n",
+    "def chat_gpt_4o_mini(api_key = None):\n",
+    "    model = ChatOpenAI(model_name=\"gpt-4o-mini\", api_key=api_key)\n",
+    "\n",
+    "    str_prompt =\"\"\"\n",
+    "    You will be provided with a sentence in {source_lang}, and your task is to translate it into {target_lang}.\n",
+    "    Answer in Json format with key 'translated'\n",
+    "    Sentence: {sentence}\n",
+    "    \"\"\"\n",
+    "\n",
+    "    output_parser = JsonOutputParser()\n",
+    "    prompt = PromptTemplate(\n",
+    "        template = str_prompt,\n",
+    "        input_variables=[\"source_lang\",\"target_lang\",\"sentence\"],\n",
+    "        partial_variables={\"format_instructions\": output_parser.get_format_instructions()}\n",
+    "    )\n",
+    "    def get_class(x:dict)->str:\n",
+    "        return x[\"translated\"]\n",
+    "\n",
+    "    chain = prompt | model | output_parser | RunnableLambda(get_class)  \n",
+    "\n",
+    "    return chain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Translate (excel) for Chat GPT"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 682
+    },
+    "id": "-0K4um1jPEk4",
+    "outputId": "9fc1316b-36db-47e8-a3c1-fa85953b1524"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "def chat_gpt_translate_excel(file, sheet_name, col_name, source_lang, target_lang, where_to_place, keep_original, chosen_model, api_key = None, progress=gr.Progress()):\n",
+    "    if where_to_place is None:\n",
+    "        where_to_place = 'append_all'\n",
+    "\n",
+    "    model = using_model(chosen_model = chosen_model, api_key = api_key)\n",
+    "\n",
+    "    df = pd.read_excel(file.name, sheet_name=sheet_name, header=0)\n",
+    "    original_col = df.columns\n",
+    "    total_columns = len(df.columns)\n",
+    "    current_step = 0\n",
+    "\n",
+    "    progress(0, desc=\"Starting translation process...\")\n",
+    "\n",
+    "    # Automatically detect string columns if col_name is None\n",
+    "    if col_name is None:\n",
+    "        col_name = [col for col in df.columns if df[col].dtype == 'object']\n",
+    "\n",
+    "    # Determine columns that are not selected for translation\n",
+    "    all_col = [col for col in df.columns if col not in col_name]\n",
+    "\n",
+    "    # Dictionary to store unique values and their translations\n",
+    "    translation_map = {}\n",
+    "    print(col_name)\n",
+    "\n",
+    "    # Process the selected columns for translation\n",
+    "    for idx, col in enumerate(col_name):\n",
+    "        current_step += 1\n",
+    "        progress(current_step / total_columns, desc=f\"Translating {col} ({current_step}/{total_columns})...\")\n",
+    "\n",
+    "        try:\n",
+    "            # Extract unique values from the column\n",
+    "            unique_values = df[col].dropna().unique()\n",
+    "            unique_values = list(set(unique_values))  # Ensure uniqueness\n",
+    "\n",
+    "            # Prepare data for translation\n",
+    "            zh_sentence = [{\"sentence\": value, \"source_lang\": source_lang, \"target_lang\": target_lang} for value in unique_values]\n",
+    "\n",
+    "            # Translate unique values\n",
+    "            answers = model.batch(zh_sentence, config={\"max_concurrency\": 3})\n",
+    "            \n",
+    "            # Create a mapping from original values to translated values\n",
+    "            translations = dict(zip(unique_values, answers))\n",
+    "            translation_map[col] = translations\n",
+    "\n",
+    "            # Map translations back to the original DataFrame\n",
+    "            df[col + \"_translated\"] = df[col].map(translations).fillna(df[col])\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error in column {col}: {e}\")\n",
+    "            continue\n",
+    "\n",
+    "    # Process remaining columns\n",
+    "    for column in all_col:\n",
+    "        current_step += 1\n",
+    "        progress(current_step / total_columns, desc=f\"Translating column name: {column} ({current_step}/{total_columns})...\")\n",
+    "\n",
+    "        try:\n",
+    "            # We do not translate all_col which remaining col\n",
+    "            # all_col_translation = chain.batch([{\"sentence\": column, \"source_lang\": source_lang, \"target_lang\": target_lang}])\n",
+    "            name_col = column + '_translated'  # Assuming the translation returns a list of translations\n",
+    "            df.loc[:, name_col] = df.loc[:, column]\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error in column {column}: {e}\")\n",
+    "            continue\n",
+    "\n",
+    "    \n",
+    "    output_file = \"translated_output.xlsx\"\n",
+    "    if not os.path.exists(output_file):\n",
+    "        pd.DataFrame().to_excel(output_file, index=False)\n",
+    "\n",
+    "    if keep_original == 'keep original':\n",
+    "        output_col = original_col\n",
+    "    else:\n",
+    "        output_col = col_name\n",
+    "\n",
+    "        \n",
+    "    try:\n",
+    "        if where_to_place == 'append_all (ต่อ column สุดท้าย)':\n",
+    "            final_cols = list(output_col) + [col + '_translated' for col in output_col]\n",
+    "            result = df[final_cols]\n",
+    "            result.to_excel(output_file, index=False)\n",
+    "        elif where_to_place == 'append_compare (เปรียบเทียบ column by column)':\n",
+    "            final_cols = []\n",
+    "            for col in output_col:\n",
+    "                final_cols = final_cols + [col, col + '_translated']\n",
+    "            result = df[final_cols]\n",
+    "            result.to_excel(output_file, index=False)\n",
+    "        elif where_to_place == 'replace':\n",
+    "            final_cols = [col + '_translated' for col in output_col] \n",
+    "            result = df[final_cols]\n",
+    "            result.to_excel(output_file, index=False)\n",
+    "        elif where_to_place == 'new_sheet':\n",
+    "            final_cols = [col for col in output_col]\n",
+    "            new_tab_cols = [col + '_translated' for col in output_col]\n",
+    "\n",
+    "            result = df[final_cols]\n",
+    "            result1 = df[new_tab_cols]\n",
+    "            # Use ExcelWriter to write multiple sheets\n",
+    "            with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer:\n",
+    "                result.to_excel(writer, sheet_name=sheet_name, index=False)  # First sheet\n",
+    "                result1.to_excel(writer, sheet_name=f'{sheet_name}_translated', index=False)  # Second sheet\n",
+    "\n",
+    "        progress(1.0, desc=\"Saving translated file... Completed!\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error saving the file: {e}\")\n",
+    "        raise gr.Error(f\"Error saving the file: {e}\")\n",
+    "\n",
+    "    progress(1.0, desc=\"Completed all tasks!\")\n",
+    "    return output_file\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Main function\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "x8Njoc4fROSp"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/petchakrit_pinyopawasutthi/anaconda3/lib/python3.11/site-packages/gradio/analytics.py:106: UserWarning: IMPORTANT: You are using gradio version 4.44.0, however version 4.44.1 is available, please upgrade. \n",
+      "--------\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Thai', 'English', 'ABC']\n",
+      "Keyboard interruption in main thread... closing server.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with gr.Blocks() as iface:\n",
+    "    gr.Markdown(\"## Excel Translation Interface\")\n",
+    "\n",
+    "    excel_file = gr.File(label=\"Upload Excel File\")\n",
+    "    sheet_name = gr.Dropdown(label=\"Select Sheet\", interactive=True)\n",
+    "    column_name= gr.Dropdown(label = \"Select Column to Translate (Not require)\", multiselect=True, interactive=True)\n",
+    "                             \n",
+    "    with gr.Row():\n",
+    "        source_language = gr.Textbox(label=\"Source Language Code\")\n",
+    "        target_language = gr.Textbox(label=\"Target Language Code\")\n",
+    "    with gr.Row():\n",
+    "        where_to_place = gr.Dropdown(multiselect=False ,label=\"How translated columns should be placed\"\n",
+    "                                     , choices = ['replace', \n",
+    "                                                  'append_all (ต่อ column สุดท้าย)', \n",
+    "                                                  'append_compare (เปรียบเทียบ column by column)', \n",
+    "                                                  'new_sheet']\n",
+    "                                    , interactive=True\n",
+    "                                     )\n",
+    "        keep_original = gr.Dropdown(multiselect=False ,label=\"You want to keep original column or just only the translated column\"\n",
+    "                                     , choices = ['keep original', \n",
+    "                                                  'translated_column']\n",
+    "                                                  , interactive=True\n",
+    "                                     )\n",
+    "   \n",
+    "    def get_sheet_names(file):\n",
+    "      xls = pd.ExcelFile(file.name)\n",
+    "      return xls.sheet_names\n",
+    "\n",
+    "    def update_sheets(file):\n",
+    "        sheets = get_sheet_names(file)\n",
+    "        return gr.update(choices=sheets)\n",
+    "\n",
+    "    def update_columns(file, sheet_name):\n",
+    "        columns = get_column_names(file, sheet_name)\n",
+    "        return gr.update(choices=columns)\n",
+    "\n",
+    "    def get_column_names(file, sheet_name):\n",
+    "        dd = pd.read_excel(file.name, sheet_name=sheet_name)\n",
+    "        return list(dd.columns)\n",
+    "    \n",
+    "\n",
+    "    excel_file.change(fn=update_sheets, inputs=excel_file, outputs=sheet_name)\n",
+    "    sheet_name.change(fn=update_columns, inputs=[excel_file, sheet_name], outputs=column_name)\n",
+    "\n",
+    "    model_choosing = gr.Dropdown(multiselect = False , \n",
+    "                                 label = \"Choosing Model you want\", \n",
+    "                                 choices = ['ChatGPT (4o-mini)', 'another (In Progress)']\n",
+    "                                 , interactive=True\n",
+    "                                 )\n",
+    "\n",
+    "    needed_require = gr.Textbox(label=\"API Key(require if Chatgpt)\")\n",
+    "    translate_button = gr.Button(\"Translate\")\n",
+    "    output_file = gr.File(label=\"Download Translated Excel File\", interactive=True)\n",
+    "\n",
+    "     # Unified translation function\n",
+    "    def translate_excel(\n",
+    "        file, sheet_name, columns, source_lang, target_lang, place_option, keep_opt, model, api_key\n",
+    "    ):\n",
+    "        if model == \"ChatGPT (4o-mini)\":\n",
+    "            # Call ChatGPT-based translation\n",
+    "            return chat_gpt_translate_excel(\n",
+    "                file, sheet_name, columns, source_lang, target_lang, place_option, keep_opt, model, api_key\n",
+    "            )\n",
+    "        else:\n",
+    "            # Handle other models (currently in progress)\n",
+    "            raise gr.Error(\"Translation with the selected model is not yet implemented.\")\n",
+    "\n",
+    "    # Register button click\n",
+    "    translate_button.click(\n",
+    "        fn=translate_excel,\n",
+    "        inputs=[\n",
+    "            excel_file,\n",
+    "            sheet_name,\n",
+    "            column_name,\n",
+    "            source_language,\n",
+    "            target_language,\n",
+    "            where_to_place,\n",
+    "            keep_original,\n",
+    "            model_choosing,\n",
+    "            needed_require,\n",
+    "        ],\n",
+    "        outputs=output_file,\n",
+    "    )\n",
+    "iface.launch(debug=True)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": [
+    {
+     "file_id": "1SaYuZQocnldkcDTIWwqSYfInBXiPqNbN",
+     "timestamp": 1727236548844
+    }
+   ]
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

translator_app.py

@@ -0,0 +1,236 @@
+import pandas as pd
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers import JsonOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnableLambda
+import gradio as gr
+import pandas as pd
+
+
+def using_model(chosen_model, api_key):
+    if chosen_model == 'ChatGPT (4o-mini)':
+        model = chat_gpt_4o_mini(api_key = api_key)
+    else:
+        pass
+    return model
+
+def chat_gpt_4o_mini(api_key = None):
+    model = ChatOpenAI(model_name="gpt-4o-mini", api_key=api_key)
+
+    str_prompt ="""
+    You will be provided with a sentence in {source_lang}, and your task is to translate it into {target_lang}.
+    Answer in Json format with key 'translated'
+    Sentence: {sentence}
+    """
+
+    output_parser = JsonOutputParser()
+    prompt = PromptTemplate(
+        template = str_prompt,
+        input_variables=["source_lang","target_lang","sentence"],
+        partial_variables={"format_instructions": output_parser.get_format_instructions()}
+    )
+    def get_class(x:dict)->str:
+        return x["translated"]
+
+    chain = prompt | model | output_parser | RunnableLambda(get_class)  
+
+    return chain
+
+
+def chat_gpt_translate_excel(file, sheet_name, col_name, source_lang, target_lang, where_to_place, keep_original, chosen_model, api_key = None, progress=gr.Progress()):
+    if where_to_place is None:
+        where_to_place = 'append_all'
+
+    model = using_model(chosen_model = chosen_model, api_key = api_key)
+
+    df = pd.read_excel(file.name, sheet_name=sheet_name, header=0)
+    original_col = df.columns
+    total_columns = len(df.columns)
+    current_step = 0
+
+    progress(0, desc="Starting translation process...")
+
+    # Automatically detect string columns if col_name is None
+    if col_name is None:
+        col_name = [col for col in df.columns if df[col].dtype == 'object']
+
+    # Determine columns that are not selected for translation
+    all_col = [col for col in df.columns if col not in col_name]
+
+    # Dictionary to store unique values and their translations
+    translation_map = {}
+    print(col_name)
+
+    # Process the selected columns for translation
+    for idx, col in enumerate(col_name):
+        current_step += 1
+        progress(current_step / total_columns, desc=f"Translating {col} ({current_step}/{total_columns})...")
+
+        try:
+            # Extract unique values from the column
+            unique_values = df[col].dropna().unique()
+            unique_values = list(set(unique_values))  # Ensure uniqueness
+
+            # Prepare data for translation
+            zh_sentence = [{"sentence": value, "source_lang": source_lang, "target_lang": target_lang} for value in unique_values]
+
+            # Translate unique values
+            answers = model.batch(zh_sentence, config={"max_concurrency": 3})
+            
+            # Create a mapping from original values to translated values
+            translations = dict(zip(unique_values, answers))
+            translation_map[col] = translations
+
+            # Map translations back to the original DataFrame
+            df[col + "_translated"] = df[col].map(translations).fillna(df[col])
+
+        except Exception as e:
+            print(f"Error in column {col}: {e}")
+            continue
+
+    # Process remaining columns
+    for column in all_col:
+        current_step += 1
+        progress(current_step / total_columns, desc=f"Translating column name: {column} ({current_step}/{total_columns})...")
+
+        try:
+            # We do not translate all_col which remaining col
+            # all_col_translation = chain.batch([{"sentence": column, "source_lang": source_lang, "target_lang": target_lang}])
+            name_col = column + '_translated'  # Assuming the translation returns a list of translations
+            df.loc[:, name_col] = df.loc[:, column]
+
+        except Exception as e:
+            print(f"Error in column {column}: {e}")
+            continue
+
+    
+    output_file = "translated_output.xlsx"
+    if not os.path.exists(output_file):
+        pd.DataFrame().to_excel(output_file, index=False)
+
+    if keep_original == 'keep original':
+        output_col = original_col
+    else:
+        output_col = col_name
+    try:
+        if where_to_place == 'append_all (ต่อ column สุดท้าย)':
+            final_cols = list(output_col) + [col + '_translated' for col in output_col]
+            result = df[final_cols]
+            result.to_excel(output_file, index=False)
+        elif where_to_place == 'append_compare (เปรียบเทียบ column by column)':
+            final_cols = []
+            for col in output_col:
+                final_cols = final_cols + [col, col + '_translated']
+            result = df[final_cols]
+            result.to_excel(output_file, index=False)
+        elif where_to_place == 'replace':
+            final_cols = [col + '_translated' for col in output_col] 
+            result = df[final_cols]
+            result.to_excel(output_file, index=False)
+        elif where_to_place == 'new_sheet':
+            final_cols = [col for col in output_col]
+            new_tab_cols = [col + '_translated' for col in output_col]
+
+            result = df[final_cols]
+            result1 = df[new_tab_cols]
+            # Use ExcelWriter to write multiple sheets
+            with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer:
+                result.to_excel(writer, sheet_name=sheet_name, index=False)  # First sheet
+                result1.to_excel(writer, sheet_name=f'{sheet_name}_translated', index=False)  # Second sheet
+
+        progress(1.0, desc="Saving translated file... Completed!")
+    except Exception as e:
+        print(f"Error saving the file: {e}")
+        raise gr.Error(f"Error saving the file: {e}")
+
+    progress(1.0, desc="Completed all tasks!")
+    return output_file
+
+
+if __name__ == "__main__" :
+    with gr.Blocks() as iface:
+        gr.Markdown("## Excel Translation Interface")
+
+        excel_file = gr.File(label="Upload Excel File")
+        sheet_name = gr.Dropdown(label="Select Sheet", interactive=True)
+        column_name= gr.Dropdown(label = "Select Column to Translate (Not require)", multiselect=True, interactive=True)
+                                
+        with gr.Row():
+            source_language = gr.Textbox(label="Source Language Code")
+            target_language = gr.Textbox(label="Target Language Code")
+        with gr.Row():
+            where_to_place = gr.Dropdown(multiselect=False ,label="How translated columns should be placed"
+                                        , choices = ['replace', 
+                                                    'append_all (ต่อ column สุดท้าย)', 
+                                                    'append_compare (เปรียบเทียบ column by column)', 
+                                                    'new_sheet']
+                                        , interactive=True
+                                        )
+            keep_original = gr.Dropdown(multiselect=False ,label="You want to keep original column or just only the translated column"
+                                        , choices = ['keep original', 
+                                                    'translated_column']
+                                                    , interactive=True
+                                        )
+    
+        def get_sheet_names(file):
+            xls = pd.ExcelFile(file.name)
+            return xls.sheet_names
+
+        def update_sheets(file):
+            sheets = get_sheet_names(file)
+            return gr.update(choices=sheets)
+
+        def update_columns(file, sheet_name):
+            columns = get_column_names(file, sheet_name)
+            return gr.update(choices=columns)
+
+        def get_column_names(file, sheet_name):
+            dd = pd.read_excel(file.name, sheet_name=sheet_name)
+            return list(dd.columns)
+        
+
+        excel_file.change(fn=update_sheets, inputs=excel_file, outputs=sheet_name)
+        sheet_name.change(fn=update_columns, inputs=[excel_file, sheet_name], outputs=column_name)
+
+        model_choosing = gr.Dropdown(multiselect = False , 
+                                    label = "Choosing Model you want", 
+                                    choices = ['ChatGPT (4o-mini)', 'another (In Progress)']
+                                    , interactive=True
+                                    )
+
+        needed_require = gr.Textbox(label="API Key(require if Chatgpt)")
+        translate_button = gr.Button("Translate")
+        output_file = gr.File(label="Download Translated Excel File", interactive=True)
+
+        # Unified translation function
+        def translate_excel(
+            file, sheet_name, columns, source_lang, target_lang, place_option, keep_opt, model, api_key
+        ):
+            if model == "ChatGPT (4o-mini)":
+                # Call ChatGPT-based translation
+                return chat_gpt_translate_excel(
+                    file, sheet_name, columns, source_lang, target_lang, place_option, keep_opt, model, api_key
+                )
+            else:
+                # Handle other models (currently in progress)
+                raise gr.Error("Translation with the selected model is not yet implemented.")
+
+        # Register button click
+        translate_button.click(
+            fn=translate_excel,
+            inputs=[
+                excel_file,
+                sheet_name,
+                column_name,
+                source_language,
+                target_language,
+                where_to_place,
+                keep_original,
+                model_choosing,
+                needed_require,
+            ],
+            outputs=output_file,
+        )
+    iface.launch(debug=True, server_port= 7860, server_name="0.0.0.0")
+