word update

.env

@@ -1 +1,2 @@
-GEMINI_API_KEY = AIzaSyAk1LTwWMZyTfPAKmsn6JzFtI1MpnI7FH8
+GEMINI_API_KEY = AIzaSyAk1LTwWMZyTfPAKmsn6JzFtI1MpnI7FH8
+MONGODB_URI = mongodb+srv://admin:[email protected]/?retryWrites=true&w=majority&appName=Cluster0

pages/upload.py

@@ -4,7 +4,7 @@ from db.mongodb import save_file_to_mongodb, fetch_file_from_mongodb, detect_fil
 from powerpoint.pptx import translate_pptx
 from excel.xlsx import translate_xlsx
 from excel.excel_translate import translate_csv
-from word.word_translate import translate_docx
+from word.word_helper import translate_docx
 import dotenv
 import os
 
@@ -33,7 +33,7 @@ def process_file(file, file_type):
     elif file_type == "CSV":
         final_id = translate_csv(file_id = file_id, source_lang = source_lang, target_lang = target_lang)
     elif file_type == "Word":
-        final_id = translate_docx(file_id, source_lang = source_lang, target_lang = target_lang)
+        final_id = translate_docx(file_id = file_id, file_name = file_name , source_lang = source_lang, target_lang = target_lang)
     else:
         st.error("❌ Loại file không hỗ trợ!")
         return

word/{word_translate.py → word_helper.py}

@@ -5,16 +5,21 @@ import google.generativeai as genai
 import ast
 import json
 import re
+import time
 import dotenv
+import os
 from pymongo import MongoClient
-from gridfs import GridFS
-from docx import Document
+import gridfs
 from io import BytesIO
 
-
 dotenv.load_dotenv(".env")
-api_key = os.getenv("GEMINI_API_KEY")
 
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+
+
+time_spent_sleeping = 0
+mismatches = 0
 
 def batch_translate(texts, source_lang = 'English', target_lang="Vietnamese"):
     """ Translates multiple text segments in a single API call. """
@@ -28,11 +33,12 @@ def batch_translate(texts, source_lang = 'English', target_lang="Vietnamese"):
         1. You will be given three inputs: source language, target language, and a JSON file.
         2. The JSON file contains a Python dictionary where each key is an integer, and each value is a string.
         3. Ensure one-to-one correspondence—each input item must correspond to exactly one output item with the same number of items.
-        4. Preserve spaces before or after strings. Do not remove, merge, split, or omit any strings.
-        5. Translate paragraphs and ensure the translation makes sense when text is put together.
-        6. Translate split words so that the word is not split in the translation.
-        7. Return a JSON object that is a Python dictionary containing as many items as the original JSON file, with keys and order preserved.
-        8. The output must be a syntactically correct Python dictionary.
+        4. The names of people, places, and organizations should be preserved in the translation.
+        5. Preserve spaces before or after strings. Do not remove, merge, split, or omit any strings.
+        6. Translate paragraphs and ensure the translation makes sense when text is put together.
+        7. Translate split words so that the word is not split in the translation.
+        8. Return a JSON object that is a Python dictionary containing as many items as the original JSON file, with keys and order preserved.
+        9. The output must be a syntactically correct Python dictionary.
 
         Additional Examples:
         **Input 1**: 
@@ -230,7 +236,7 @@ def full_translate(texts, source_lang = 'English', target_lang="Vietnamese"):
     global time_spent_sleeping
 
     for string in texts:
-        if len(string.split()) + word_count >= 1000:
+        if len(string.split()) + word_count >= 2000:
             print('Translating a batch.')
 
             translated_batch = batch_translate_loop(batch, source_lang, target_lang)
@@ -368,35 +374,46 @@ def merge_elements(doc):
                     current_run = [element]
     return doc
 
-def translate_docx(word_id, source_lang = "English", target_lang="Vietnamese", output_num = ''):
-    """ Translates a Word document efficiently using batch processing. """
+def translate_docx(file_id, source_lang="English", target_lang="Vietnamese", file_name=''):
+    """Translates a Word document and saves the output to MongoDB."""
+    client = MongoClient(os.getenv("MONGODB_URI"))
+    db = client["word"]
+    fs_input = gridfs.GridFS(db, collection="root_file")
+    fs_output = gridfs.GridFS(db, collection="final_file")
 
-    client = MongoClient("mongodb+srv://admin:[email protected]/?retryWrites=true&w=majority&appName=Cluster0")
-    db = client['pptx']
-    fs = GridFS(db, collection='root_file')
-    word_file = fs.get(word_id)
-
-    doc = Document(BytesIO(word_file.read()))
-    output_file = os.path.join(os.path.dirname(input_file), f"{output_num}{target_language}_translated_{os.path.basename(input_file)}")
+    # Lấy file gốc từ MongoDB
+    input_file = fs_input.get(file_id)
+    doc = Document(BytesIO(input_file.read()))
 
+    # Dịch nội dung
     doc = merge_elements(doc)
-    
+
     print('Translating paragraphs.')
     para_texts = get_text_elements_para(doc)
-    translated_para = full_translate(para_texts, source_lang = source_lang, target_lang = target_lang)
-    print('Done translating pararaphs.')
+    translated_para = full_translate(para_texts, source_lang=source_lang, target_lang=target_lang)
+    print('Done translating paragraphs.')
 
     print('Translating tables.')
     table_texts = get_text_elements_table(doc)
-    translated_tables = full_translate(table_texts, source_lang = source_lang, target_lang = target_lang)
+    translated_tables = full_translate(table_texts, source_lang=source_lang, target_lang=target_lang)
     print('Done translating tables.')
 
-    print('Inserting paragaphs')
+    print('Inserting paragraphs.')
     doc, _ = translate_paragraphs(doc, translated_para)
+
     print('Inserting tables.')
     doc = translate_tables(doc, translated_tables)
 
     translate_header_footer(doc, source_lang, target_lang)
     print('Done translating headers & footers.')
 
-    doc.save(output_file)
+    # Lưu tài liệu đã dịch vào MongoDB
+    output_stream = BytesIO()
+    doc.save(output_stream)
+    output_stream.seek(0)
+
+    translated_file_id = fs_output.put(output_stream, filename=file_name)
+    client.close()
+
+    print(f"Translation complete! Saved to MongoDB with id: {translated_file_id}")
+    return translated_file_id

word/word_translate.ipynb

@@ -1,580 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import docx\n",
-    "from docx import Document\n",
-    "import google.generativeai as genai\n",
-    "import ast\n",
-    "import json\n",
-    "import re\n",
-    "import time\n",
-    "\n",
-    "genai.configure(api_key=\"AIzaSyAk1LTwWMZyTfPAKmsn6JzFtI1MpnI7FH8\")\n",
-    "target_language = 'English'  \n",
-    "source_language = 'VietNamese'\n",
-    "\n",
-    "time_spent_sleeping = 0\n",
-    "mismatches = 0\n",
-    "\n",
-    "def batch_translate(texts, source_lang = 'English', target_lang=\"Vietnamese\"):\n",
-    "    \"\"\" Translates multiple text segments in a single API call. \"\"\"\n",
-    "    if not texts:\n",
-    "        return texts  # Skip if empty\n",
-    "    \n",
-    "    system_prompt = \"\"\"\n",
-    "    Translate the contents of a JSON file from the specified source language to the specified target language while preserving the structure, spaces, and context of the original text.\n",
-    "\n",
-    "        Instructions:\n",
-    "        1. You will be given three inputs: source language, target language, and a JSON file.\n",
-    "        2. The JSON file contains a Python dictionary where each key is an integer, and each value is a string.\n",
-    "        3. Ensure one-to-one correspondence—each input item must correspond to exactly one output item with the same number of items.\n",
-    "        4. Preserve spaces before or after strings. Do not remove, merge, split, or omit any strings.\n",
-    "        5. Translate paragraphs and ensure the translation makes sense when text is put together.\n",
-    "        6. Translate split words so that the word is not split in the translation.\n",
-    "        7. Return a JSON object that is a Python dictionary containing as many items as the original JSON file, with keys and order preserved.\n",
-    "        8. The output must be a syntactically correct Python dictionary.\n",
-    "\n",
-    "        Additional Examples:\n",
-    "        **Input 1**: \n",
-    "        - Source language: English\n",
-    "        - Target language: Vietnamese\n",
-    "        - JSON file: \n",
-    "        ```json\n",
-    "        {\"0\": \"My name is \", \"1\": \"Huy\", \"2\": \".\", \"3\": \" Today is \", \"4\": \"a \", \"5\": \"good day\", \"6\": \".\", \"7\": \"\"}\n",
-    "        ```\n",
-    "        **Output 1**:\n",
-    "        ```json\n",
-    "        {\"0\": \"Tên tôi là \", \"1\": \"Huy\", \"2\": \".\", \"3\": \" Hôm nay là \", \"4\": \"một \", \"5\": \"ngày đẹp\", \"6\": \".\", \"7\": \"\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Input 2**: \n",
-    "        - Source language: English\n",
-    "        - Target language: Spanish\n",
-    "        - JSON file: \n",
-    "        ```json\n",
-    "        {\"0\": \"The sky is \", \"1\": \"blue\", \"2\": \".\", \"3\": \" Water is \", \"4\": \"essential\", \"5\": \" for \", \"6\": \"life\", \"7\": \".\"}\n",
-    "        ```\n",
-    "        **Output 2**:\n",
-    "        ```json\n",
-    "        {\"0\": \"El cielo es \", \"1\": \"azul\", \"2\": \".\", \"3\": \" El agua es \", \"4\": \"esencial\", \"5\": \" para \", \"6\": \"la vida\", \"7\": \".\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Input 3**: \n",
-    "        - Source language: English\n",
-    "        - Target language: French   \n",
-    "        - JSON file: \n",
-    "        ```json\n",
-    "        {\"0\": \"The quick brown \", \"1\": \"fox \", \"2\": \"jumps \", \"3\": \"over \", \"4\": \"the \", \"5\": \"lazy \", \"6\": \"dog\", \"7\": \".\"}\n",
-    "        ```\n",
-    "        **Output 3**:\n",
-    "        ```json\n",
-    "        {\"0\": \"Le renard brun \", \"1\": \"rapide \", \"2\": \"saute \", \"3\": \"par-dessus \", \"4\": \"le \", \"5\": \"chien \", \"6\": \"paresseux\", \"7\": \".\"}\n",
-    "        ```\n",
-    "\n",
-    "        Perform the translation and return the result as specified above. Do not include any additional text other than the translated JSON object.\n",
-    "    \"\"\"\n",
-    "    json_data = json.dumps({i: t for i, t in enumerate(texts)})\n",
-    "    user_prompt = f\"Source language: {source_lang}. Target language: {target_lang}. JSON file: {json_data}\" \n",
-    "  \n",
-    "    model = genai.GenerativeModel('gemini-2.0-flash')\n",
-    "    response = model.generate_content(contents = system_prompt.strip() + \"\\n\" + user_prompt.strip(), generation_config={\n",
-    "            'temperature': 1,  # Adjust temperature for desired creativity\n",
-    "            'top_p': 1,\n",
-    "            'top_k': 1,})\n",
-    "    # response_dict = ast.literal_eval(response.text.strip().strip(\"json```\").strip(\"```\").strip().strip(\"\\\"\"))\n",
-    "    # print(len(texts), len(list(response_dict.values())))\n",
-    "    # return list(response_dict.values())\n",
-    "\n",
-    "    return response\n",
-    "\n",
-    "def response_to_dict(response):\n",
-    "    return list(ast.literal_eval(response.text.strip().strip(\"json```\").strip(\"```\").strip().strip(\"\\\"\")).values())\n",
-    "\n",
-    "def fix_translate(texts, translated_text):\n",
-    "    \"\"\" Translates multiple text segments in a single API call. \"\"\"\n",
-    "    if not texts:\n",
-    "        return texts  # Skip if empty\n",
-    "    \n",
-    "    system_prompt = \"\"\"\n",
-    "    You are given the original JSON dictionary and the translated response text. Your task is to ensure that the translated text is in the correct format and has the same number of items as the original JSON dictionary.\n",
-    "\n",
-    "        Steps to follow:\n",
-    "        1. Parse the original and translated JSON dictionaries.\n",
-    "        2. Ensure that the keys in both dictionaries are strings (i.e., \"1\" instead of 1).\n",
-    "        3. Compare the number of items in both dictionaries.\n",
-    "        4. If the number of items in the translated dictionary is not equal to the number of items in the original dictionary, adjust the translated dictionary by:\n",
-    "            a. Adding missing items with empty strings if there are fewer items.\n",
-    "            b. Merging or splitting items to ensure correspondence with the original items if there are more items.\n",
-    "        5. Ensure that each item in the translated dictionary is in the correct order, with the same key as the original item.\n",
-    "        6. Preserve any leading or trailing spaces in the original strings.\n",
-    "        7. Ensure the output is a syntactically correct Python dictionary, with proper opening and closing braces.\n",
-    "        8. If the translated dictionary is already correct, return it as is.\n",
-    "        9. Return the corrected JSON dictionary in proper Python dictionary format.\n",
-    "\n",
-    "        Example Inputs and Outputs:\n",
-    "\n",
-    "        **Input:**\n",
-    "        - Original JSON dictionary:\n",
-    "        ```json\n",
-    "        {\"0\": \"My name is \", \"1\": \"Huy\", \"2\": \".\", \"3\": \" Today is \", \"4\": \"a \", \"5\": \"good day\", \"6\": \".\", \"7\": \"\"}\n",
-    "        ```\n",
-    "        - Translated response text with fewer items:\n",
-    "        ```json\n",
-    "        {\"0\": \"Tên tôi là \", \"1\": \"Huy\", \"2\": \".\", \"3\": \"Hôm nay \", \"4\": \"là một \", \"5\": \"ngày đẹp\", \"6\": \".\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Output:**\n",
-    "        ```json\n",
-    "        {\"0\": \"Tên tôi là \", \"1\": \"Huy\", \"2\": \".\", \"3\": \"Hôm nay \", \"4\": \"là một \", \"5\": \"ngày đẹp\", \"6\": \".\", \"7\": \"\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Input:**\n",
-    "        - Original JSON dictionary:\n",
-    "        ```json\n",
-    "        {\"0\": \"The sky is \", \"1\": \"blue\", \"2\": \".\", \"3\": \" Water is \", \"4\": \"essential\", \"5\": \" for \", \"6\": \"life\", \"7\": \".\"}\n",
-    "        ```\n",
-    "        - Translated response text with more items:\n",
-    "        ```json\n",
-    "        {\"0\": \"El cielo es \", \"1\": \"azul\", \"2\": \".\", \"3\": \" El agua es \", \"4\": \"esencial\", \"5\": \" para \", \"6\": \"la\", \"7\": \" vida\", \"8\": \".\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Output:**\n",
-    "        ```json\n",
-    "        {\"0\": \"El cielo es \", \"1\": \"azul\", \"2\": \".\", \"3\": \" El agua es \", \"4\": \"esencial\", \"5\": \" para \", \"6\": \"la vida\", \"7\": \".\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Input:**\n",
-    "        - Original JSON dictionary:\n",
-    "        ```json\n",
-    "        {\"0\": \"The quick brown \", \"1\": \"fox \", \"2\": \"jumps \", \"3\": \"over \", \"4\": \"the \", \"5\": \"lazy \", \"6\": \"dog\", \"7\": \".\"}\n",
-    "        ```\n",
-    "        - Translated response text with issues:\n",
-    "        ```json\n",
-    "        {\"0\": \"Le renard \", \"1\": \"brun \", 2: \"rapide \", 3: \"saute \", 4: \"par-dessus \", \"5\": \"le \", \"6\": \"chien \", \"7\": \"paresseux\", 8: \".\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Output:**\n",
-    "        ```json\n",
-    "        {\"0\": \"Le renard brun \", \"1\": \"rapide \", \"2\": \"saute \", \"3\": \"par-dessus \", \"4\": \"le \", \"5\": \"chien \", \"6\": \"paresseux\", \"7\": \".\"}\n",
-    "        ```\n",
-    "\n",
-    "        **Input:**\n",
-    "        - Original JSON dictionary:\n",
-    "        ```json\n",
-    "        {\"0\": \"The quick brown \", \"1\": \"fox \", \"2\": \"jumps \", \"3\": \"over \", \"4\": \"the \", \"5\": \"lazy \", \"6\": \"dog.\"}\n",
-    "        ```\n",
-    "        - Translated response text with wrong formatting:\n",
-    "        ```json\n",
-    "        {\"0\": \"Le renard brun \", \"1\": \"rapide \", \"2\": \"saute \", \"3\": \"par-dessus \", \"4\": \"le \", \"5\": \"chien \", \"6\": \"paresseux\".}\n",
-    "        ```\n",
-    "\n",
-    "        **Output:**\n",
-    "        ```json\n",
-    "        {\"0\": \"Le renard brun \", \"1\": \"rapide \", \"2\": \"saute \", \"3\": \"par-dessus \", \"4\": \"le \", \"5\": \"chien \", \"6\": \"paresseux.\"}\n",
-    "        ```\n",
-    "\n",
-    "        Perform the corrections and return the result as a properly formatted Python dictionary.\n",
-    "\"\"\"\n",
-    "    json_data = json.dumps({i: t for i, t in enumerate(texts)})\n",
-    "    user_prompt = f\"Original JSON dictionary: {json_data}. Translated response text: {translated_text}\" \n",
-    "  \n",
-    "    model = genai.GenerativeModel('gemini-2.0-flash')\n",
-    "    response = model.generate_content(contents = system_prompt.strip() + \"\\n\" + user_prompt.strip(), generation_config={\n",
-    "            'temperature': 1,  # Adjust temperature for desired creativity\n",
-    "            'top_p': 1,\n",
-    "            'top_k': 1,})\n",
-    "    return response_to_dict(response)\n",
-    "    # return response    \n",
-    "\n",
-    "def brute_force_fix(batch, translated_batch):\n",
-    "    if len(batch) > len(translated_batch):\n",
-    "        translated_batch += [\"\"] * (len(batch) - len(translated_batch))\n",
-    "    elif len(batch) < len(translated_batch):\n",
-    "        translated_batch = translated_batch[:len(batch)]\n",
-    "    return translated_batch\n",
-    "\n",
-    "def batch_translate_loop(batch, source_lang, target_lang):\n",
-    "    translated_batch_response = batch_translate(batch, source_lang, target_lang)\n",
-    "    try:\n",
-    "        translated_batch = response_to_dict(translated_batch_response)\n",
-    "        assert(len(translated_batch) == len(batch))\n",
-    "\n",
-    "    except:\n",
-    "        for i in range(10):\n",
-    "            print(f'I am ChatGPT and I am retarded, retrying translation time {i}:')\n",
-    "            try: \n",
-    "                translated_batch = fix_translate(batch, translated_batch_response.text.strip().strip(\"json```\").strip(\"```\").strip().strip(\"\\\"\"))\n",
-    "                assert(len(translated_batch) == len(batch))\n",
-    "                break\n",
-    "            except:\n",
-    "                pass\n",
-    "    try: \n",
-    "        translated_batch = fix_translate(batch, translated_batch_response.text.strip().strip(\"json```\").strip(\"```\").strip().strip(\"\\\"\"))\n",
-    "    except:\n",
-    "        try:\n",
-    "            translated_batch = response_to_dict(translated_batch_response)\n",
-    "        except:\n",
-    "            raise ValueError(\"The translated batch is not a list.\")\n",
-    "    if len(translated_batch) != len(batch):\n",
-    "        print(\"Length mismatch after translation. Brute Force Fixing...\")\n",
-    "        translated_batch = brute_force_fix(batch, translated_batch)\n",
-    "        global mismatches\n",
-    "        mismatches += 1\n",
-    "    print(len(batch), len(translated_batch))\n",
-    "    return translated_batch\n",
-    "\n",
-    "def full_translate(texts, source_lang = 'English', target_lang=\"Vietnamese\"):\n",
-    "    full_translated_texts = []\n",
-    "    batch = []\n",
-    "    word_count = 0\n",
-    "    global time_spent_sleeping\n",
-    "\n",
-    "    for string in texts:\n",
-    "        if len(string.split()) + word_count >= 2000:\n",
-    "            print('Translating a batch.')\n",
-    "\n",
-    "            translated_batch = batch_translate_loop(batch, source_lang, target_lang)\n",
-    "            full_translated_texts += translated_batch\n",
-    "            \n",
-    "            time.sleep(1)\n",
-    "            time_spent_sleeping += 1\n",
-    "            batch = []\n",
-    "            word_count = 0\n",
-    "        batch.append(string)\n",
-    "        word_count += len(string)\n",
-    "    \n",
-    "    print('Translating a batch.')\n",
-    "    if len(batch) == 0:\n",
-    "        return full_translated_texts\n",
-    "    \n",
-    "    translated_batch = batch_translate_loop(batch, source_lang, target_lang)\n",
-    "    full_translated_texts += translated_batch\n",
-    "    \n",
-    "    return full_translated_texts\n",
-    "\n",
-    "def merge_runs(runs):\n",
-    "    \"\"\" Merges adjacent runs with the same style. \"\"\"\n",
-    "    merged_runs = []\n",
-    "    for run in runs:\n",
-    "        if (merged_runs and isinstance(run, docx.text.run.Run) and isinstance(merged_runs[-1], docx.text.run.Run) and \n",
-    "            run.style == merged_runs[-1].style and \n",
-    "            merged_runs[-1].bold == run.bold and\n",
-    "            merged_runs[-1].italic == run.italic and\n",
-    "            merged_runs[-1].underline == run.underline and \n",
-    "            merged_runs[-1].font.size == run.font.size and\n",
-    "            merged_runs[-1].font.color.rgb == run.font.color.rgb and\n",
-    "            merged_runs[-1].font.name == run.font.name):\n",
-    "                merged_runs[-1].text += run.text\n",
-    "        else:\n",
-    "                merged_runs.append(run)\n",
-    "    return merged_runs\n",
-    "\n",
-    "NS_W = \"{http://schemas.openxmlformats.org/wordprocessingml/2006/main}\"\n",
-    "def translate_header_footer(doc, source_lang, target_lang):\n",
-    "    head_foot = []\n",
-    "    for section in doc.sections:\n",
-    "        for header in section.header.paragraphs:\n",
-    "            for run in header.runs:\n",
-    "                head_foot.append(run.text) \n",
-    "        for footer in section.footer.paragraphs:\n",
-    "            for run in footer.runs:\n",
-    "                head_foot.append(run.text)  \n",
-    "    translated_head_foot = full_translate(head_foot, source_lang, target_lang)\n",
-    "\n",
-    "    i = 0\n",
-    "    for section in doc.sections:\n",
-    "        for header in section.header.paragraphs:\n",
-    "            for run in header.runs:\n",
-    "                run.text = translated_head_foot[i]\n",
-    "                i += 1\n",
-    "        for footer in section.footer.paragraphs:\n",
-    "            for run in footer.runs:\n",
-    "                run.text = translated_head_foot[i]\n",
-    "                i += 1 \n",
-    "\n",
-    "def get_text_elements_para(doc):\n",
-    "    para_texts = []\n",
-    "    for para in doc.paragraphs:\n",
-    "        for element in para._element.iter():\n",
-    "            if element.tag.endswith('t'):\n",
-    "                if element.text:\n",
-    "                    emoji_pattern = r'[\\U00010000-\\U0010FFFF]'    \n",
-    "                    # Split the text but keep emojis as separate elements\n",
-    "                    parts = re.split(f'({emoji_pattern})', element.text)\n",
-    "                    for part in parts:\n",
-    "                        if re.match(emoji_pattern, part):\n",
-    "                            continue\n",
-    "                        if len(part.strip()) != 0:\n",
-    "                            para_texts.append(part)\n",
-    "\n",
-    "    return para_texts\n",
-    "\n",
-    "def get_text_elements_table(doc):\n",
-    "    table_texts = []\n",
-    "    for table in doc.tables:\n",
-    "        for row in table.rows:\n",
-    "            for cell in row.cells:\n",
-    "                table_texts += get_text_elements_para(cell)\n",
-    "    return table_texts\n",
-    "\n",
-    "def translate_paragraphs(doc, translated_texts, i = 0):\n",
-    "    for para in doc.paragraphs:\n",
-    "        for element in para._element.iter():\n",
-    "            if element.tag.endswith('t'):\n",
-    "                if element.text:\n",
-    "                    emoji_pattern = r'[\\U00010000-\\U0010FFFF]'    \n",
-    "                    # Split the text but keep emojis as separate elements\n",
-    "                    parts = re.split(f'({emoji_pattern})', element.text)\n",
-    "                    for j in range(len(parts)):\n",
-    "                        if re.match(emoji_pattern, parts[j]):\n",
-    "                            continue\n",
-    "                        if len(parts[j].strip()) != 0: \n",
-    "                            translated_text = translated_texts[i]\n",
-    "                            i += 1\n",
-    "                            parts[j] = translated_text\n",
-    "                    element.text = \"\".join(parts)                        \n",
-    "    return doc, i\n",
-    "\n",
-    "def translate_tables(doc, translated_texts):\n",
-    "    i = 0\n",
-    "    for table in doc.tables:\n",
-    "        for row in table.rows:\n",
-    "            for cell in row.cells:\n",
-    "                cell, i = translate_paragraphs(cell, translated_texts, i)\n",
-    "    return doc\n",
-    "\n",
-    "def is_same_formatting(text1, text2):\n",
-    "    \"\"\"\n",
-    "    Check if two texts have the same formatting.\n",
-    "    \"\"\"\n",
-    "    return (text1.bold == text2.bold \\\n",
-    "            and text1.italic == text2.italic \\\n",
-    "            and text1.underline == text2.underline \\\n",
-    "            and text1.font.size == text2.font.size \\\n",
-    "            and text1.font.color.rgb == text2.font.color.rgb \\\n",
-    "            and text1.font.name == text2.font.name)\n",
-    "    \n",
-    "def merge_elements(doc):\n",
-    "    for para in doc.paragraphs:\n",
-    "        current_run = []\n",
-    "        for element in para.iter_inner_content():\n",
-    "            if isinstance(element, docx.text.run.Run):\n",
-    "                if current_run  == []:\n",
-    "                    current_run = [element]\n",
-    "                elif is_same_formatting(current_run[0], element):\n",
-    "                    current_run[0].text += element.text\n",
-    "                    element.text = \"\"\n",
-    "                else:\n",
-    "                    current_run = [element]\n",
-    "    return doc\n",
-    "\n",
-    "def translate_docx(input_file, source_lang = \"English\", target_lang=\"Vietnamese\", output_num = ''):\n",
-    "    \"\"\" Translates a Word document efficiently using batch processing. \"\"\"\n",
-    "    doc = Document(input_file)\n",
-    "    output_file = os.path.join(os.path.dirname(input_file), f\"{output_num}{target_language}_translated_{os.path.basename(input_file)}\")\n",
-    "\n",
-    "    doc = merge_elements(doc)\n",
-    "    \n",
-    "    print('Translating paragraphs.')\n",
-    "    para_texts = get_text_elements_para(doc)\n",
-    "    translated_para = full_translate(para_texts, source_lang = source_lang, target_lang = target_lang)\n",
-    "    print('Done translating pararaphs.')\n",
-    "\n",
-    "    print('Translating tables.')\n",
-    "    table_texts = get_text_elements_table(doc)\n",
-    "    translated_tables = full_translate(table_texts, source_lang = source_lang, target_lang = target_lang)\n",
-    "    print('Done translating tables.')\n",
-    "\n",
-    "    print('Inserting paragaphs')\n",
-    "    doc, _ = translate_paragraphs(doc, translated_para)\n",
-    "    print('Inserting tables.')\n",
-    "    doc = translate_tables(doc, translated_tables)\n",
-    "\n",
-    "    translate_header_footer(doc, source_lang, target_lang)\n",
-    "    print('Done translating headers & footers.')\n",
-    "\n",
-    "    doc.save(output_file)\n",
-    "    print(f\"Translation complete! Saved as {output_file}\")\n",
-    "\n",
-    "    # return para_texts, translated_para\n",
-    "\n",
-    "\n",
-    "# input_file = r\"C:\\Users\\huyvu\\Downloads\\wordnet-an-electronic-lexical-database-language-speech-and-communication.9780262061971.33119-1.docx\"\n",
-    "input_file = r\"D:\\Show_me_everything\\Machine Translation\\input\\test1.docx\"\n",
-    "# input_file = r\"C:\\Users\\huyvu\\Documents\\Machine Translation\\Machine-Translation\\data\\input\\Data Engineering Practice.docx\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "input_file = r\"D:\\Show_me_everything\\Machine Translation\\input\\Tổng quan cuộc thi_ Data Unlock.docx\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Translating paragraphs.\n",
-      "Translating a batch.\n",
-      "37 37\n",
-      "Translating a batch.\n",
-      "27 27\n",
-      "Translating a batch.\n",
-      "28 28\n",
-      "Translating a batch.\n",
-      "20 20\n",
-      "Translating a batch.\n",
-      "16 16\n",
-      "Translating a batch.\n",
-      "23 23\n",
-      "Translating a batch.\n",
-      "37 37\n",
-      "Translating a batch.\n",
-      "32 32\n",
-      "Translating a batch.\n",
-      "28 28\n",
-      "Translating a batch.\n",
-      "13 13\n",
-      "Translating a batch.\n",
-      "36 36\n",
-      "Translating a batch.\n",
-      "23 23\n",
-      "Translating a batch.\n",
-      "25 25\n",
-      "Translating a batch.\n",
-      "10 10\n",
-      "Translating a batch.\n",
-      "14 14\n",
-      "Translating a batch.\n",
-      "13 13\n",
-      "Translating a batch.\n",
-      "11 11\n",
-      "Translating a batch.\n",
-      "18 18\n",
-      "Translating a batch.\n",
-      "14 14\n",
-      "Translating a batch.\n",
-      "23 23\n",
-      "Translating a batch.\n",
-      "24 24\n",
-      "Translating a batch.\n",
-      "21 21\n",
-      "Translating a batch.\n",
-      "10 10\n",
-      "Translating a batch.\n",
-      "23 23\n",
-      "Translating a batch.\n",
-      "12 12\n",
-      "Translating a batch.\n",
-      "18 18\n",
-      "Translating a batch.\n",
-      "17 17\n",
-      "Translating a batch.\n",
-      "29 29\n",
-      "Translating a batch.\n",
-      "15 15\n",
-      "Translating a batch.\n",
-      "21 21\n",
-      "Translating a batch.\n",
-      "2 2\n",
-      "Done translating pararaphs.\n",
-      "Translating tables.\n",
-      "Translating a batch.\n",
-      "21 21\n",
-      "Done translating tables.\n",
-      "Inserting paragaphs\n",
-      "Inserting tables.\n",
-      "Translating a batch.\n",
-      "Done translating headers & footers.\n",
-      "Translation complete! Saved as D:\\Show_me_everything\\Machine Translation\\input\\English_translated_test1.docx\n"
-     ]
-    }
-   ],
-   "source": [
-    "translate_docx(input_file, source_lang = source_language, target_lang = target_language)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "30"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "time_spent_sleeping"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "mismatches"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "machine_translate",
-   "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.10.16"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}