Upload folder using huggingface_hub

.gitignore

@@ -2,4 +2,5 @@
 downloaded_audio/
 figures/
 audio_cut/
-audio_cut.zip
+audio_cut.zip
+dataset/

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/Generate Audio Data.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.10 (Explanation)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,40 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="26">
+            <item index="0" class="java.lang.String" itemvalue="torch" />
+            <item index="1" class="java.lang.String" itemvalue="torchvision" />
+            <item index="2" class="java.lang.String" itemvalue="timm" />
+            <item index="3" class="java.lang.String" itemvalue="ellzaf_ml" />
+            <item index="4" class="java.lang.String" itemvalue="scipy" />
+            <item index="5" class="java.lang.String" itemvalue="scikit_learn" />
+            <item index="6" class="java.lang.String" itemvalue="matplotlib" />
+            <item index="7" class="java.lang.String" itemvalue="opencv_contrib_python" />
+            <item index="8" class="java.lang.String" itemvalue="model" />
+            <item index="9" class="java.lang.String" itemvalue="opencv_python" />
+            <item index="10" class="java.lang.String" itemvalue="Pillow" />
+            <item index="11" class="java.lang.String" itemvalue="pydriver" />
+            <item index="12" class="java.lang.String" itemvalue="pytest-pylint" />
+            <item index="13" class="java.lang.String" itemvalue="opencv-python" />
+            <item index="14" class="java.lang.String" itemvalue="pytest" />
+            <item index="15" class="java.lang.String" itemvalue="sklearn" />
+            <item index="16" class="java.lang.String" itemvalue="attrdict" />
+            <item index="17" class="java.lang.String" itemvalue="numpy" />
+            <item index="18" class="java.lang.String" itemvalue="albumentations" />
+            <item index="19" class="java.lang.String" itemvalue="pandas" />
+            <item index="20" class="java.lang.String" itemvalue="tqdm" />
+            <item index="21" class="java.lang.String" itemvalue="tensorboard" />
+            <item index="22" class="java.lang.String" itemvalue="pylint" />
+            <item index="23" class="java.lang.String" itemvalue="onnx" />
+            <item index="24" class="java.lang.String" itemvalue="opencv_python_headless" />
+            <item index="25" class="java.lang.String" itemvalue="PyQt5" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10 (Explanation)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (Explanation)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Generate Audio Data.iml" filepath="$PROJECT_DIR$/.idea/Generate Audio Data.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.idea/workspace.xml

@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="6348f10b-d99d-4a46-ac7b-9eed28d7fa2a" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 6
+}</component>
+  <component name="ProjectId" id="2mZJfy2ux2nxKThwMyI4nltiFiJ" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "Python.download_audio.executor": "Run",
+    "Python.gen_dataset.executor": "Run",
+    "Python.main.executor": "Run",
+    "Python.separate.executor": "Run",
+    "Python.test_dataset.executor": "Run",
+    "Python.upload_huggingface.executor": "Run",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "git-widget-placeholder": "master",
+    "last_opened_file_path": "E:/AI/Generate Audio Data",
+    "node.js.detected.package.eslint": "true",
+    "node.js.detected.package.tslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "settings.editor.selected.configurable": "project.propVCSSupport.DirectoryMappings",
+    "vue.rearranger.settings.migration": "true"
+  }
+}]]></component>
+  <component name="RecentsManager">
+    <key name="CopyFile.RECENT_KEYS">
+      <recent name="E:\AI\Generate Audio Data" />
+      <recent name="E:\AI\Generate Audio Data\dataset" />
+    </key>
+  </component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-js-predefined-1d06a55b98c1-91d5c284f522-JavaScript-PY-241.15989.155" />
+        <option value="bundled-python-sdk-babbdf50b680-7c6932dee5e4-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-241.15989.155" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="6348f10b-d99d-4a46-ac7b-9eed28d7fa2a" name="Changes" comment="" />
+      <created>1727278271929</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1727278271929</updated>
+      <workItem from="1727278276767" duration="149000" />
+      <workItem from="1727309175324" duration="14258000" />
+      <workItem from="1727340993328" duration="20898000" />
+      <workItem from="1727430990250" duration="574000" />
+      <workItem from="1727528882113" duration="16350000" />
+      <workItem from="1727755697813" duration="11670000" />
+      <workItem from="1727846631606" duration="10850000" />
+      <workItem from="1727864061128" duration="1144000" />
+      <workItem from="1727865356249" duration="3690000" />
+      <workItem from="1727870630865" duration="7260000" />
+      <workItem from="1727879789158" duration="302000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+  <component name="com.intellij.coverage.CoverageDataManagerImpl">
+    <SUITE FILE_PATH="coverage/Generate_Audio_Data$gen_dataset.coverage" NAME="gen_dataset Coverage Results" MODIFIED="1727855498024" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/Generate_Audio_Data$download_audio.coverage" NAME="download_audio Coverage Results" MODIFIED="1727855814027" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/Generate_Audio_Data$separate.coverage" NAME="separate Coverage Results" MODIFIED="1727772728510" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/Generate_Audio_Data$main.coverage" NAME="main Coverage Results" MODIFIED="1727532107608" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/Generate_Audio_Data$test_dataset.coverage" NAME="test_dataset Coverage Results" MODIFIED="1727356745919" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/Generate_Audio_Data$upload_huggingface.coverage" NAME="upload_huggingface Coverage Results" MODIFIED="1727878833042" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+  </component>
+</project>

converters/Cardinal.py

@@ -0,0 +1,189 @@
+from typing import List
+
+from singleton_decorator import singleton
+import re
+from .Roman import RomanVietnamese
+
+
+@singleton
+class CardinalVietnamese:
+    """
+    Các bước:
+    - 1 Loại bỏ dấu chấm
+    - 2 Kiểm tra xem có phải là số La Mã không
+    - 3 Nếu đúng, chuyển đổi số La Mã lớn nhất tìm thấy thành số nguyên, sau đó thành chuỗi đại diện cho số nguyên đó
+    - 4 Nếu đúng, kiểm tra xem có nên thêm hậu tố "'s" không (xem trường hợp đặc biệt)
+    - 5 Lọc bỏ các ký tự không phải số, trừ "-"
+    - 6 Kiểm tra xem có nên sử dụng tiền tố "âm" không
+    - 7 Loại bỏ tất cả các ký tự "-" còn lại
+    - 8 Nếu là "0", thêm "không" vào danh sách đầu ra
+    - 9 Nếu không phải "0", chia chuỗi thành các phần tối đa 3 chữ số, sao cho phần nhỏ nhất bao gồm các ký tự ngoài cùng bên trái
+    -   10 Chia mỗi phần thành `trăm` và `phần còn lại`
+    -   11 Thêm "x trăm" nếu `trăm` > 0
+    -   12 Thêm giá trị văn bản đại diện cho `phần còn lại`
+    -   13 Thêm hậu tố cho phần, ví dụ: triệu, tỷ, v.v.
+    -   14 Thêm đầu ra cho phần vào tổng đầu ra
+    - 15 Kết hợp danh sách đầu ra tổng thành một chuỗi
+    - 16 Thêm tiền tố và/hoặc hậu tố
+
+    Trường hợp đặc biệt:
+    II -> hai
+    -2 -> âm hai
+    I. -> một
+    IV's -> bốn's
+
+    Ghi chú:
+    - Không có "và" hoặc dấu gạch ngang trong kết quả, ví dụ: không có "hai mươi mốt" hoặc "một trăm lẻ một"
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.filter_regex = re.compile("[^0-9\-]")
+        self.filter_strict_regex = re.compile("[^0-9]")
+        self.dot_filter_regex = re.compile("[.]")
+
+        self.scale_suffixes = [
+            "nghìn",
+            "triệu",
+            "tỷ",
+            "nghìn tỷ",
+            "triệu tỷ",
+            "tỷ tỷ"
+        ]
+
+        self.small_trans_dict = {
+            "1": "một",
+            "2": "hai",
+            "3": "ba",
+            "4": "bốn",
+            "5": "năm",
+            "6": "sáu",
+            "7": "bảy",
+            "8": "tám",
+            "9": "chín",
+        }
+
+        self.tens_trans_dict = {
+            "1": "mười",
+            "2": "hai mươi",
+            "3": "ba mươi",
+            "4": "bốn mươi",
+            "5": "năm mươi",
+            "6": "sáu mươi",
+            "7": "bảy mươi",
+            "8": "tám mươi",
+            "9": "chín mươi",
+        }
+
+        self.special_trans_dict = {
+            11: "mười một",
+            12: "mười hai",
+            13: "mười ba",
+            14: "mười bốn",
+            15: "mười lăm",
+            16: "mười sáu",
+            17: "mười bảy",
+            18: "mười tám",
+            19: "mười chín"
+        }
+
+        self.roman = RomanVietnamese()
+
+    def _give_chunk(self, num_str: str, size: int = 3) -> str:
+        while num_str:
+            yield num_str[-size:]
+            num_str = num_str[:-size]
+
+    def convert(self, token: str) -> str:
+        token = self.dot_filter_regex.sub("", token)
+
+        suffix = ""
+        if self.roman.check_if_roman(token):
+            token, suffix = self.roman.convert(token)
+
+        token = self.filter_regex.sub("", token)
+
+        prefix = ""
+        while len(token) > 0 and token[0] == "-":
+            token = token[1:]
+            prefix = "âm" if prefix == "" else ""
+
+        token = self.filter_strict_regex.sub("", token)
+
+        if token == len(token) * "0":
+            return "không"
+
+        chunks = list(self._give_chunk(token))
+        text_list = []
+
+        for depth, chunk in enumerate(chunks):
+            chunk_text = self._convert_chunk(chunk, depth == len(chunks) - 1)
+            if chunk_text:
+                if depth > 0:
+                    chunk_text.append(self.scale_suffixes[depth - 1])
+                text_list = chunk_text + text_list
+
+        result = " ".join(text_list)
+
+        if prefix:
+            result = f"{prefix} {result}"
+        if suffix:
+            result = f"{result}{suffix}"
+
+        return result
+
+    def _convert_chunk(self, chunk: str, is_last_chunk: bool) -> List[str]:
+        chunk_text = []
+        length = len(chunk)
+
+        # Xử lý hàng trăm
+        if length == 3:
+            if chunk[0] != '0':
+                chunk_text.append(self.small_trans_dict[chunk[0]])
+                chunk_text.append("trăm")
+            elif not is_last_chunk and (chunk[1] != '0' or chunk[2] != '0'):
+                chunk_text.append("không trăm")
+
+        # Xử lý hàng chục và đơn vị
+        if length >= 2:
+            if chunk[-2:] in self.special_trans_dict:
+                chunk_text.append(self.special_trans_dict[chunk[-2:]])
+            else:
+                if chunk[-2] != '0':
+                    chunk_text.append(self.tens_trans_dict[chunk[-2]])
+                    if chunk[-1] != '0':
+                        if chunk[-1] == '1' and chunk[-2] != '1':
+                            chunk_text.append("mốt")
+                        else:
+                            chunk_text.append(self.small_trans_dict[chunk[-1]])
+                elif chunk[-1] != '0':
+                    if len(chunk_text) > 0 or not is_last_chunk:
+                        chunk_text.append("lẻ")
+                    chunk_text.append(self.small_trans_dict[chunk[-1]])
+        elif length == 1 and chunk != '0':
+            chunk_text.append(self.small_trans_dict[chunk])
+
+        return chunk_text
+
+if __name__ == "__main__":
+    cardinal_converter = CardinalVietnamese()
+
+    # Ví dụ 1
+    example1 = "20211231"
+    result1 = cardinal_converter.convert(example1)
+    print(f"Số: {example1}")
+    print(f"Chuyển đổi: {result1}")
+    print()
+
+    # Ví dụ 2
+    example2 = "-5678213"
+    result2 = cardinal_converter.convert(example2)
+    print(f"Số: {example2}")
+    print(f"Chuyển đổi: {result2}")
+    print()
+
+    # Ví dụ 3
+    example3 = "1000000"
+    result3 = cardinal_converter.convert(example3)
+    print(f"Số: {example3}")
+    print(f"Chuyển đổi: {result3}")

converters/Date.py

@@ -0,0 +1,107 @@
+import re
+from singleton_decorator import singleton
+import re
+from .Cardinal import CardinalVietnamese
+import re
+
+@singleton
+class DateVietnamese:
+    """
+    Chuyển đổi ngày tháng từ dạng số sang dạng chữ tiếng Việt.
+    Hỗ trợ các định dạng: "DD/MM/YYYY", "DD-MM-YYYY", "DD.MM.YYYY".
+    Ví dụ: "25/12/2023", "01-01-2024", "10.05.2023"
+    """
+
+    def __init__(self):
+        self.day_trans_dict = {
+            "1": "một",
+            "2": "hai",
+            "3": "ba",
+            "4": "bốn",
+            "5": "năm",
+            "6": "sáu",
+            "7": "bảy",
+            "8": "tám",
+            "9": "chín",
+            "10": "mười",
+            "11": "mười một",
+            "12": "mười hai",
+            "13": "mười ba",
+            "14": "mười bốn",
+            "15": "mười lăm",
+            "16": "mười sáu",
+            "17": "mười bảy",
+            "18": "mười tám",
+            "19": "mười chín",
+            "20": "hai mươi",
+            "21": "hai mươi mốt",
+            "22": "hai mươi hai",
+            "23": "hai mươi ba",
+            "24": "hai mươi bốn",
+            "25": "hai mươi lăm",
+            "26": "hai mươi sáu",
+            "27": "hai mươi bảy",
+            "28": "hai mươi tám",
+            "29": "hai mươi chín",
+            "30": "ba mươi",
+            "31": "ba mươi mốt"
+        }
+
+        self.month_trans_dict = {
+            "1": "một",
+            "2": "hai",
+            "3": "ba",
+            "4": "tư",
+            "5": "năm",
+            "6": "sáu",
+            "7": "bảy",
+            "8": "tám",
+            "9": "chín",
+            "10": "mười",
+            "11": "mười một",
+            "12": "mười hai"
+        }
+
+    def convert_year(self, year: str) -> str:
+        cardinal_converter = CardinalVietnamese()
+        return cardinal_converter.convert(year)
+
+    def convert_date(self, date: str) -> str:
+        # Tìm và tách ngày, tháng, năm dựa trên dấu phân cách
+        date_parts = re.split(r"[\/\-\.\s]", date)
+        if len(date_parts) ==3 :
+            day, month, year = date_parts[0], date_parts[1], date_parts[2]
+
+            day_text = f"ngày {self.day_trans_dict[day.lstrip('0')]}"
+            month_text = f"tháng {self.month_trans_dict[month.lstrip('0')]}"
+            year_text = f"năm {self.convert_year(year)}"
+
+            return f"{day_text} {month_text} {year_text}"
+        else:
+            month, year = date_parts[0], date_parts[1],
+            month_text = f"tháng {self.month_trans_dict[month.lstrip('0')]}"
+            year_text = f"năm {self.convert_year(year)}"
+            return f"{month_text} {year_text}"
+if __name__ == "__main__":
+    date_converter = DateVietnamese()
+
+    # Ví dụ 1
+    example1 = "25/12/1990"
+    result1 = date_converter.convert_date(example1)
+    print(f"Ngày tháng: {example1}")
+    print(f"Chuyển đổi: {result1}")
+    print()
+
+    # Ví dụ 2
+    example2 = "01-01-1991"
+    result2 = date_converter.convert_date(example2)
+    print(f"Ngày tháng: {example2}")
+    print(f"Chuyển đổi: {result2}")
+    print()
+
+    # Ví dụ 3
+    example3 = "10.05.2023"
+    result3 = date_converter.convert_date(example3)
+    print(f"Ngày tháng: {example3}")
+    print(f"Chuyển đổi: {result3}")
+

converters/Decimal.py

@@ -0,0 +1,86 @@
+from .Digit import DigitVietnamese
+from .Cardinal import CardinalVietnamese
+import re
+from singleton_decorator import singleton
+@singleton
+class Decimal:
+    def __init__(self):
+        super().__init__()
+        self.decimal_regex = re.compile(r"(-?\d*)\.(\d+)(.*)")
+        self.number_regex = re.compile(r"(-?\d+)(.*)")
+        self.filter_regex = re.compile(r"[,]")
+        self.cardinal = CardinalVietnamese()
+        self.digit = DigitVietnamese()
+        self.suffixes = [
+            "nghìn",
+            "triệu",
+            "tỷ",
+            "nghìn tỷ",
+            "triệu tỷ",
+            "tỷ tỷ"
+        ]
+        self.suffix_regex = re.compile(f" *({'|'.join(self.suffixes)})")
+        self.e_suffix_regex = re.compile(r" *E(-?\d+)")
+
+    def convert(self, token: str) -> str:
+        token = self.filter_regex.sub("", token)
+
+        number = ""
+        decimal = ""
+
+        match = self.decimal_regex.match(token)
+        if match:
+            number = match.group(1)
+            decimal = match.group(2)
+            token = match.group(3)
+        else:
+            match = self.number_regex.match(token)
+            if match:
+                number = match.group(1)
+                token = match.group(2)
+
+        match = self.suffix_regex.match(token)
+        suffix = ""
+        if match:
+            suffix = match.group(1)
+        else:
+            match = self.e_suffix_regex.match(token)
+            if match:
+                suffix = f"nhân mười mũ {self.cardinal.convert(match.group(1))}"
+
+        result_list = []
+        if len(decimal) > 0:
+            result_list.append("phẩy")
+            result_list.append(self.digit.convert(decimal))
+
+        if number:
+            result_list.insert(0, self.cardinal.convert(number))
+
+        if suffix:
+            result_list.append(suffix)
+
+        result = " ".join(result_list)
+
+        return result
+
+if __name__ == "__main__":
+    decimal = Decimal()
+
+    test_cases = [
+        "123,456.789",
+        "0.5",
+        "1000000",
+        "3.14",
+        "2.718E3",
+        "1.23E-5",
+        "9.99999",
+        "1234.5678 tỷ",
+        "0.000001",
+        "1000000.000001",
+    ]
+
+    for case in test_cases:
+        result = decimal.convert(case)
+        print(f"Số: {case}")
+        print(f"Chuyển đổi: {result}")
+        print()

converters/Digit.py

@@ -0,0 +1,62 @@
+from singleton_decorator import singleton
+import re
+
+@singleton
+class DigitVietnamese:
+    """
+    Các bước:
+    - 1 Lọc bỏ tất cả các ký tự không phải số
+    - 2 Kiểm tra trường hợp đặc biệt
+    - 3 Chuyển đổi mỗi chữ số thành văn bản tiếng Việt
+    - 4 Thêm khoảng trắng giữa các từ
+    Trường hợp đặc biệt:
+    007 -> không không bảy
+    trong khi 003 -> không không ba
+    """
+    def __init__(self):
+        super().__init__()
+        # Regex để lọc bỏ các ký tự không phải số
+        self.filter_regex = re.compile("[^0-9]")
+        # Từ điển chuyển đổi chữ số sang chữ tiếng Việt
+        self.trans_dict = {
+            "0": "không",
+            "1": "một",
+            "2": "hai",
+            "3": "ba",
+            "4": "bốn",
+            "5": "năm",
+            "6": "sáu",
+            "7": "bảy",
+            "8": "tám",
+            "9": "chín"
+        }
+
+    def convert(self, token: str) -> str:
+        # 1 Lọc bỏ tất cả các ký tự không phải số
+        token = self.filter_regex.sub("", token)
+        # 2 Kiểm tra trường hợp đặc biệt
+        if token == "007":
+            return "không không bảy"
+        # 3 & 4 Chuyển đổi mỗi chữ số thành văn bản và thêm khoảng trắng
+        token = " ".join([self.trans_dict[c] for c in token])
+        return token
+if __name__ == "__main__":
+    # Tạo một thể hiện của lớp DigitVietnamese
+    digit_converter = DigitVietnamese()
+
+    # Ví dụ 1: Số điện thoại
+    phone_number = "0912345678"
+    print(f"Số điện thoại: {phone_number}")
+    print(f"Chuyển đổi: {digit_converter.convert(phone_number)}")
+    print()
+
+    # Ví dụ 2: Mã số sinh viên
+    student_id = "SV20210001"
+    print(f"Mã số sinh viên: {student_id}")
+    print(f"Chuyển đổi: {digit_converter.convert(student_id)}")
+    print()
+
+    # Ví dụ 3: Trường hợp đặc biệt
+    special_case = "007"
+    print(f"Số đặc biệt: {special_case}")
+    print(f"Chuyển đổi: {digit_converter.convert(special_case)}")

converters/Fraction.py

@@ -0,0 +1,110 @@
+from .Cardinal import CardinalVietnamese
+import re
+from singleton_decorator import  singleton
+
+@singleton
+class Fraction:
+    def __init__(self):
+        super().__init__()
+        self.filter_regex = re.compile(",")
+        self.space_filter_regex = re.compile(" ")
+        self.trans_dict = {
+            "½": {"prepended": "một", "single": "một", "text": "phần hai"},
+            "⅓": {"prepended": "một", "single": "một", "text": "phần ba"},
+            "⅔": {"prepended": "hai", "single": "hai", "text": "phần ba"},
+            "¼": {"prepended": "một", "single": "một", "text": "phần tư"},
+            "¾": {"prepended": "ba", "single": "ba", "text": "phần tư"},
+            "⅕": {"prepended": "một", "single": "một", "text": "phần năm"},
+            "⅖": {"prepended": "hai", "single": "hai", "text": "phần năm"},
+            "⅗": {"prepended": "ba", "single": "ba", "text": "phần năm"},
+            "⅘": {"prepended": "bốn", "single": "bốn", "text": "phần năm"},
+            "⅙": {"prepended": "một", "single": "một", "text": "phần sáu"},
+            "⅚": {"prepended": "năm", "single": "năm", "text": "phần sáu"},
+            "⅐": {"prepended": "một", "single": "một", "text": "phần bảy"},
+            "⅛": {"prepended": "một", "single": "một", "text": "phần tám"},
+            "⅜": {"prepended": "ba", "single": "ba", "text": "phần tám"},
+            "⅝": {"prepended": "năm", "single": "năm", "text": "phần tám"},
+            "⅞": {"prepended": "bảy", "single": "bảy", "text": "phần tám"},
+            "⅑": {"prepended": "một", "single": "một", "text": "phần chín"},
+            "⅒": {"prepended": "một", "single": "một", "text": "phần mười"}
+        }
+        self.special_regex = re.compile(f"({'|'.join(self.trans_dict.keys())})")
+        self.cardinal = CardinalVietnamese()
+        self.slash_regex = re.compile(r"(-?\d{1,3}( \d{3})+|-?\d+) *\/ *(-?\d{1,3}( \d{3})+|-?\d+)")
+
+        # Không cần chuyển đổi từ Cardinal sang Ordinal trong tiếng Việt
+        self.trans_denominator = {}
+
+        self.edge_dict = {
+            "1": {"singular": "trên một", "plural": "trên một"},
+            "2": {"singular": "phần hai", "plural": "phần hai"},
+            "4": {"singular": "phần tư", "plural": "phần tư"}
+        }
+
+    def convert(self, token: str) -> str:
+        token = self.filter_regex.sub("", token)
+        match = self.special_regex.search(token)
+        if match:
+            frac = match.group(1)
+            frac_dict = self.trans_dict[frac]
+
+            remainder = self.special_regex.sub("", token)
+            if remainder:
+                prefix = self.cardinal.convert(remainder)
+                result = f"{prefix} và {frac_dict['prepended']} {frac_dict['text']}"
+            else:
+                result = f"{frac_dict['single']} {frac_dict['text']}"
+
+        else:
+            match = self.slash_regex.search(token)
+            if match:
+                numerator = match.group(1)
+                denominator = match.group(3)
+
+                numerator = self.space_filter_regex.sub("", numerator)
+                denominator = self.space_filter_regex.sub("", denominator)
+
+                numerator_text = self.cardinal.convert(numerator)
+
+                if denominator in self.edge_dict:
+                    result = f"{numerator_text} {self.edge_dict[denominator]['singular']}"
+
+                else:
+                    denominator_text = self.cardinal.convert(denominator)
+                    result = f"{numerator_text} phần {denominator_text}"
+
+                remainder = self.slash_regex.sub("", token)
+                if remainder:
+                    remainder_text = self.cardinal.convert(remainder)
+                    result = f"{remainder_text} và {result}"
+
+            else:
+                result = token
+
+        return result
+
+if __name__ == "__main__":
+    fraction = Fraction()
+
+    test_cases = [
+        "½",
+        "1½",
+        "2¼",
+        "3⅔",
+        "1/4",
+        "3/4",
+        "5/8",
+        "10/3",
+        "100/25",
+        "1000/999",
+        "2 1/2",
+        "3 3/4",
+        "5 2/3",
+        "100 1/100",
+    ]
+
+    for case in test_cases:
+        result = fraction.convert(case)
+        print(f"Phân số: {case}")
+        print(f"Chuyển đổi: {result}")
+        print()

converters/Meansure.py

@@ -0,0 +1,473 @@
+from singleton_decorator import singleton
+
+import re
+
+from .Decimal import Decimal
+from .Fraction import Fraction
+
+
+@singleton
+class Measure:
+    def __init__(self):
+        super().__init__()
+        # Regex để phát hiện phân số
+        self.fraction_regex = re.compile(
+            r"(((?:-?\d* )?-?\d+ *\/ *-? *\d+)|(-?\d* *(?:½|⅓|⅔|¼|¾|⅕|⅖|⅗|⅘|⅙|⅚|⅐|⅛|⅜|⅝|⅞|⅑|⅒)))")
+        # Regex để phát hiện xem có nên sử dụng "của một" hay không
+        self.of_a_regex = re.compile(r"(-?\d+ -?\d+ *\/ *-? *\d+)|(-?\d+ *(?:½|⅓|⅔|¼|¾|⅕|⅖|⅗|⅘|⅙|⅚|⅐|⅛|⅜|⅝|⅞|⅑|⅒))")
+        # Regex để phát hiện đầu vào để chuyển đổi số, bao gồm cả hậu tố triệu/tỷ tiềm năng
+        self.value_regex = re.compile(r"(-?(?: |\d)*\.?\d+ *(?:nghìn|triệu|tỷ|nghìn tỷ|triệu tỷ|tỷ tỷ)?)")
+        # Regex để lọc bỏ dấu phẩy
+        self.filter_regex = re.compile(r"[,]")
+        # Regex để lọc bỏ khoảng trắng
+        self.filter_space_regex = re.compile(r"[ ]")
+        # Regex để lọc bỏ chữ cái
+        self.letter_filter_regex = re.compile(r"[^0-9\-\.]")
+
+        # Từ điển tiền tố cho 10^i với i > 0
+        self.prefix_dict = {
+            "Y": "yotta",
+            "Z": "zetta",
+            "E": "exa",
+            "P": "peta",
+            "T": "tera",
+            "G": "giga",
+            "M": "mega",
+            "k": "kilo",
+            "h": "hecto",
+            "da": "deca",
+            "d": "deci",
+            "c": "centi",
+            "m": "milli",
+            "μ": "micro",
+            "µ": "micro",
+            "n": "nano",
+            "p": "pico",
+            "f": "femto",
+            "a": "atto",
+            "z": "zepto",
+            "y": "yocto"
+        }
+
+        # Từ điển dịch cho các loại đơn vị có thể thêm tiền tố
+        self.prefixable_trans_dict = {
+            "m": {
+                "singular": "mét",
+                "plural": "mét"
+            },
+            "b": {
+                "singular": "bit",
+                "plural": "bit"
+            },
+            "B": {
+                "singular": "byte",
+                "plural": "byte"
+            },
+            "bps": {
+                "singular": "bit trên giây",
+                "plural": "bit trên giây"
+            },
+            "Bps": {
+                "singular": "byte trên giây",
+                "plural": "byte trên giây"
+            },
+            "g": {
+                "singular": "gram",
+                "plural": "gram"
+            },
+            "gf": {
+                "singular": "gram lực",
+                "plural": "gram lực"
+            },
+            "W": {
+                "singular": "oát",
+                "plural": "oát"
+            },
+            "Wh": {
+                "singular": "oát giờ",
+                "plural": "oát giờ"
+            },
+            "Hz": {
+                "singular": "héc",
+                "plural": "héc"
+            },
+            "J": {
+                "singular": "jun",
+                "plural": "jun"
+            },
+            "L": {
+                "singular": "lít",
+                "plural": "lít"
+            },
+            "V": {
+                "singular": "vôn",
+                "plural": "vôn"
+            },
+            "f": {
+                "singular": "fara",
+                "plural": "fara"
+            },
+            "s": {
+                "singular": "giây",
+                "plural": "giây"
+            },
+            "A": {
+                "singular": "ampe",
+                "plural": "ampe"
+            },
+            "Ah": {
+                "singular": "ampe giờ",
+                "plural": "ampe giờ"
+            },
+            "Pa": {
+                "singular": "pascal",
+                "plural": "pascal"
+            },
+            "C": {
+                "singular": "culông",
+                "plural": "culông"
+            },
+            "Bq": {
+                "singular": "becquerel",
+                "plural": "becquerel"
+            },
+            "N": {
+                "singular": "niutơn",
+                "plural": "niutơn"
+            },
+            "bar": {
+                "singular": "bar",
+                "plural": "bar"
+            },
+            "lm": {
+                "singular": "lumen",
+                "plural": "lumen"
+            },
+            "cal": {
+                "singular": "calo",
+                "plural": "calo"
+            },
+        }
+
+        # Từ điển đã được biến đổi sử dụng self.prefixable_trans_dict và từ điển tiền tố
+        self.prefixed_dict = {
+            prefix + prefixed: {"singular": self.prefix_dict[prefix] + self.prefixable_trans_dict[prefixed]["singular"],
+                                "plural": self.prefix_dict[prefix] + self.prefixable_trans_dict[prefixed]["plural"]} for
+            prefixed in self.prefixable_trans_dict for prefix in self.prefix_dict}
+        self.prefixed_dict = {**self.prefixed_dict, **self.prefixable_trans_dict}
+
+        # Từ điển dịch cho các loại đơn vị không có tiền tố
+        self.custom_dict = {
+            "%": {
+                "singular": "phần trăm",
+                "plural": "phần trăm"
+            },
+            "pc": {
+                "singular": "phần trăm",
+                "plural": "phần trăm"
+            },
+            "ft": {
+                "singular": "foot",
+                "plural": "foot"
+            },
+            "mi": {
+                "singular": "dặm",
+                "plural": "dặm"
+            },
+            "mb": {
+                "singular": "megabyte",
+                "plural": "megabyte"
+            },
+            "ha": {
+                "singular": "hecta",
+                "plural": "hecta"
+            },
+            "\"": {
+                "singular": "inch",
+                "plural": "inch"
+            },
+            "in": {
+                "singular": "inch",
+                "plural": "inch"
+            },
+            "\'": {
+                "singular": "foot",
+                "plural": "foot"
+            },
+            "rpm": {
+                "singular": "vòng trên phút",
+                "plural": "vòng trên phút"
+            },
+            "hp": {
+                "singular": "mã lực",
+                "plural": "mã lực"
+            },
+            "cc": {
+                "singular": "xăng-ti-mét khối",
+                "plural": "xăng-ti-mét khối"
+            },
+            "oz": {
+                "singular": "aoxơ",
+                "plural": "aoxơ",
+            },
+            "mph": {
+                "singular": "dặm trên giờ",
+                "plural": "dặm trên giờ"
+            },
+            "lb": {
+                "singular": "pao",
+                "plural": "pao"
+            },
+            "lbs": {
+                "singular": "pao",
+                "plural": "pao"
+            },
+            "kt": {
+                "singular": "nút",
+                "plural": "nút"
+            },
+            "dB": {
+                "singular": "đề-xi-ben",
+                "plural": "đề-xi-ben"
+            },
+            "AU": {
+                "singular": "đơn vị thiên văn",
+                "plural": "đơn vị thiên văn"
+            },
+            "st": {
+                "singular": "stone",
+                "plural": "stone"
+            },
+            "yd": {
+                "singular": "yard",
+                "plural": "yard"
+            },
+            "yr": {
+                "singular": "năm",
+                "plural": "năm"
+            },
+            "yrs": {
+                "singular": "năm",
+                "plural": "năm"
+            },
+            "eV": {
+                "singular": "electron vôn",
+                "plural": "electron vôn"
+            },
+            "/": {
+                "singular": "trên",
+                "plural": "trên"
+            },
+            "sq": {
+                "singular": "vuông",
+                "plural": "vuông"
+            },
+            "2": {
+                "singular": "vuông",
+                "plural": "vuông"
+            },
+            "²": {
+                "singular": "vuông",
+                "plural": "vuông"
+            },
+            "3": {
+                "singular": "khối",
+                "plural": "khối"
+            },
+            "³": {
+                "singular": "khối",
+                "plural": "khối"
+            },
+            "h": {
+                "singular": "giờ",
+                "plural": "giờ"
+            },
+            "hr": {
+                "singular": "giờ",
+                "plural": "giờ"
+            },
+            "hrs": {
+                "singular": "giờ",
+                "plural": "giờ"
+            },
+            "ch": {
+                "singular": "chain",
+                "plural": "chain"
+            },
+            "KiB": {
+                "singular": "kibibyte",
+                "plural": "kibibyte"
+            },
+            "MiB": {
+                "singular": "mebibyte",
+                "plural": "mebibyte"
+            },
+            "GiB": {
+                "singular": "gibibyte",
+                "plural": "gibibyte"
+            },
+            "pH": {
+                "singular": "pH",
+                "plural": "pH"
+            },
+            "kph": {
+                "singular": "kilômét trên giờ",
+                "plural": "kilômét trên giờ"
+            },
+            "Da": {
+                "singular": "đalton",
+                "plural": "đalton"
+            },
+            "cwt": {
+                "singular": "hundredweight",
+                "plural": "hundredweight"
+            },
+            "Sv": {
+                "singular": "sievert",
+                "plural": "sievert",
+            },
+            "C": {
+                "singular": "độ xen-xi-út",
+                "plural": "độ xen-xi-út"
+            },
+            "degrees": {
+                "singular": "độ",
+                "plural": "độ"
+            },
+            "degree": {
+                "singular": "độ",
+                "plural": "độ"
+            },
+            "atm": {
+                "singular": "át-mốt-phê",
+                "plural": "át-mốt-phê"
+            },
+            "min": {
+                "singular": "phút",
+                "plural": "phút"
+            },
+            "cd": {
+                "singular": "can-đê-la",
+                "plural": "can-đê-la"
+            },
+            "ly": {
+                "singular": "năm ánh sáng",
+                "plural": "năm ánh sáng"
+            },
+            "kts": {
+                "singular": "nút",
+                "plural": "nút"
+            },
+            "mol": {
+                "singular": "mol",
+                "plural": "mol"
+            },
+            "Nm": {
+                "singular": "niutơn mét",
+                "plural": "niutơn mét"
+            },
+            "Ω": {
+                "singular": "ôm",
+                "plural": "ôm"
+            },
+            "bbl": {
+                "singular": "thùng",
+                "plural": "thùng"
+            },
+            "gal": {
+                "singular": "gallon",
+                "plural": "gallon"
+            },
+            "cal": {
+                "singular": "cỡ nòng",
+                "plural": "cỡ nòng"
+            }
+        }
+
+        # Ghi đè và thêm giá trị từ custom_dict vào prefixed_dict
+        self.prefixed_dict = {**self.prefixed_dict, **self.custom_dict}
+
+        # Phiên bản viết thường của self.prefixed_dict
+        self.lower_prefixed_dict = {key.lower(): self.prefixed_dict[key] for key in self.prefixed_dict}
+
+        # Hậu tố đặc biệt mà tổng hậu tố nên được tách ra
+        self.special_suffixes = re.compile(r"(\/|trên(?!trăm)|vuông|2|²|3|³)")
+
+        # Chuyển đổi Decimal và Fraction
+        self.decimal = Decimal()
+        self.fraction = Fraction()
+
+
+    def convert(self, token: str) -> str:
+        # 1 Lọc bỏ dấu phẩy
+        token = self.filter_regex.sub("", token)
+
+        result_list = []
+
+        # Số nhiều mặc định là false, vì "/s" nên là "trên giây"
+        plural = False
+
+        # 2 Thử khớp với một phân số
+        match = self.fraction_regex.match(token)
+        if match:
+            # 2.1 Nếu tồn tại, chuyển đổi thành văn bản sử dụng bộ chuyển đổi Fraction
+            result_list.append(self.fraction.convert(match.group(0)))
+            # Chuyển token thành phần còn lại. Vì sử dụng match thay vì search,
+            # phần đầu của dòng tiếp theo có thể không cần thiết
+            token = token[:match.span()[0]] + token[match.span()[1]:]
+
+            # Lọc bỏ khoảng trắng
+            token = self.filter_space_regex.sub("", token)
+
+            # Nếu có một số trước phân số, ví dụ "8 1/2" hoặc "8 ½", thì chúng ta thêm "của một", và giữ nguyên số ít
+            # Ngược lại, chúng ta chuyển sang số nhiều
+            if self.of_a_regex.match(match.group(0)):
+                plural = True
+            else:
+                result_list.append("của một")
+
+        else:
+            # 3 Thử khớp với "x,y" hoặc "x"
+            match = self.value_regex.match(token)
+            if match:
+                # 3.1 Chuyển không có khoảng trắng cho bộ chuyển đổi decimal
+                result_list.append(self.decimal.convert(self.filter_space_regex.sub("", match.group(1))))
+                token = token[:match.span()[0]] + token[match.span()[1]:]
+                # Số nhiều là False khi giá trị tuyệt đối của số thập phân là 1, và giá trị thập phân không có dạng "1,x"
+                # Ngược lại là True
+                if abs(float(self.letter_filter_regex.sub("", match.group(1)))) != 1 or "," in match.group(1):
+                    plural = True
+
+        # Biến chỉ ra liệu từ "trên" vừa được sử dụng
+        # Điều này được sử dụng để phát hiện số nhiều
+        per = False
+        # 4 Lặp qua phần còn lại của token
+        for split_token in token.split(" "):
+            for i, token in enumerate(self.split_token(split_token)):
+                # Thêm tên thích hợp của hậu tố nếu tồn tại
+                # Thử không phân biệt chữ hoa chữ thường nếu lần trước thất bại
+                if token in self.prefixed_dict:
+                    result_list.append(self.prefixed_dict[token]["plural" if plural and not per else "singular"])
+                elif token.lower() in self.lower_prefixed_dict:
+                    result_list.append(
+                        self.lower_prefixed_dict[token.lower()]["plural" if plural and not per else "singular"])
+                else:
+                    result_list.append(token)
+
+                # Nếu kết quả trước đó là "trên", đặt per thành True để sử dụng "singular" cho từ tiếp theo.
+                # Nhưng chỉ khi "trên" không phải là hậu tố đầu tiên. Ví dụ: "5/km2" là "năm trên kilômét vuông"
+                if result_list[-1] == "trên" and i != 0:
+                    per = True
+
+                # Nếu từ cuối cùng không phải là "trên", và không phải "vuông" hoặc "khối", đặt lại per thành False.
+                # Nếu "trên" được sử dụng, tiếp theo là "vuông" hoặc "khối", chúng ta muốn giữ "singular" cho
+                # từ sắp tới
+                elif result_list[-1] not in ("vuông", "khối"):
+                    per = False
+
+        result = " ".join(result_list)
+
+        # 5 Xử lý trường hợp đặc biệt: xentimét khối -> xăng-ti-mét khối
+        result = re.sub(r"xentimét khối", "xăng-ti-mét khối", result)
+
+        return result

converters/Money.py

@@ -0,0 +1,155 @@
+from singleton_decorator import singleton
+import re, os
+from .Cardinal import CardinalVietnamese
+from .Digit import DigitVietnamese
+
+
+@singleton
+class Money:
+    def __init__(self):
+        super().__init__()
+        self.decimal_regex = re.compile(r"(.*?)(-?\d*)\.(\d+)(.*)")
+        self.number_regex = re.compile(r"(.*?)(-?\d+)(.*)")
+        self.filter_regex = re.compile(r"[, ]")
+
+        self.currencies = {
+            "đ": {
+                "number": {
+                    "singular": "đồng",
+                    "plural": "đồng"
+                },
+                "decimal": {
+                    "singular": "xu",
+                    "plural": "xu"
+                }
+            },
+            "vnd": {
+                "number": {
+                    "singular": "đồng Việt Nam",
+                    "plural": "đồng Việt Nam"
+                },
+                "decimal": {
+                    "singular": "xu",
+                    "plural": "xu"
+                }
+            }
+        }
+
+        self.suffixes = [
+            "nghìn",
+            "triệu",
+            "tỷ",
+            "nghìn tỷ",
+            "triệu tỷ",
+            "tỷ tỷ"
+        ]
+
+        self.abbr_suffixes = {
+            "k": "nghìn",
+            "tr": "triệu",
+            "t": "tỷ"
+        }
+
+        self.suffix_regex = re.compile(
+            f"({'|'.join(sorted(self.suffixes + list(self.abbr_suffixes.keys()), key=len, reverse=True))})(.*)",
+            flags=re.I)
+
+        self.currency_regex = re.compile(r"(.*?)(đồng|vnd|đ)(.*?)", flags=re.I)
+
+        self.cardinal = CardinalVietnamese()  # Giả sử đã có lớp Cardinal cho tiếng Việt
+        self.digit = DigitVietnamese()  # Giả sử đã có lớp Digit cho tiếng Việt
+
+    def convert(self, token: str) -> str:
+        token = self.filter_regex.sub("", token)
+
+        before = ""
+        after = ""
+        currency = None
+        number = ""
+        decimal = ""
+        scale = ""
+
+        match = self.decimal_regex.search(token[::-1])
+        if match:
+            before = match.group(4)[::-1]
+            number = match.group(3)[::-1]
+            decimal = match.group(2)[::-1]
+            after = match.group(1)[::-1]
+        else:
+            match = self.number_regex.search(token)
+            if match:
+                before = match.group(1)
+                number = match.group(2)
+                after = match.group(3)
+
+        if before:
+            before = before.lower()
+            if before in self.currencies:
+                currency = self.currencies[before]
+            elif before[-1] in self.currencies:
+                currency = self.currencies[before[-1]]
+
+        if after:
+            match = self.suffix_regex.match(after)
+            if match:
+                scale = match.group(1).lower()
+                scale = self.abbr_suffixes[scale] if scale in self.abbr_suffixes else scale
+                after = match.group(2)
+
+            if after.lower() in self.currencies:
+                currency = self.currencies[after.lower()]
+                after = ""
+
+        decimal_support = currency and "number" in currency
+
+        result_list = []
+        if decimal_support and not scale:
+            if number and (number != "0" or not decimal):
+                result_list.append(self.cardinal.convert(number))
+                result_list.append(currency["number"]["singular"])
+                if decimal and decimal != "0" * len(decimal):
+                    result_list.append("và")
+            if decimal and decimal != "0" * len(decimal):
+                decimal = f"{decimal:0<2}"
+                result_list.append(self.cardinal.convert(decimal))
+                result_list.append(currency["decimal"]["singular"])
+        else:
+            if number:
+                result_list.append(self.cardinal.convert(number))
+            if decimal and decimal != "0" * len(decimal):
+                result_list.append("phẩy")
+                result_list.append(self.digit.convert(decimal))
+            if scale:
+                result_list.append(scale)
+            if currency:
+                if decimal_support:
+                    currency = currency["number"]
+                result_list.append(currency["singular"])
+
+        if after:
+            result_list.append(after.lower())
+
+        result = " ".join(result_list)
+        return result
+
+
+if __name__ == "__main__":
+    money = Money()
+
+    # Ví dụ 1: Số tiền đơn giản
+    print(money.convert("15000đ"))  # Kết quả mong đợi: mười lăm nghìn đồng
+
+    # Ví dụ 2: Số tiền có phần thập phân
+    print(money.convert("1500.50đ"))  # Kết quả mong đợi: một nghìn năm trăm đồng và năm mươi xu
+
+    # Ví dụ 3: Số tiền lớn
+    print(money.convert("1000000000đ"))  # Kết quả mong đợi: một tỷ đồng
+
+    # Ví dụ 4: Sử dụng VND
+    print(money.convert("5000000VND"))  # Kết quả mong đợi: năm triệu đồng Việt Nam
+
+    # Ví dụ 5: Sử dụng hậu tố
+    print(money.convert("2tr đồng"))  # Kết quả mong đợi: hai triệu đồng
+
+    # Ví dụ 6: Số tiền rất lớn
+    print(money.convert("1000000000000đ"))  # Kết quả mong đợi: một nghìn tỷ đồng

converters/Ordinal.py

@@ -0,0 +1,74 @@
+from singleton_decorator import singleton
+import re
+from Roman import RomanVietnamese
+from Cardinal import CardinalVietnamese
+
+
+@singleton
+class OrdinalVietnamese:
+    """
+    Các bước:
+    - 1 Lọc bỏ dấu phẩy và khoảng trắng
+    - 2 Kiểm tra số La Mã và chuyển đổi thành chuỗi số nguyên nếu có
+    - 3 Nếu là số La Mã, đặt tiền tố là "thứ"
+    - 4 Nếu không, kiểm tra xem có phải là số thứ tự tiếng Việt không (ví dụ: "thứ nhất", "thứ 2", "thứ ba")
+    - 5 Chuyển đổi chuỗi số còn lại thành Cardinal, và thêm "thứ" vào trước
+    - 6 Áp dụng các quy tắc đặc biệt cho số thứ tự tiếng Việt
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.filter_regex = re.compile(r"[, ]")
+        self.vietnamese_ordinal_regex = re.compile(r"(?i)(thứ\s*)?(\d+|nhất|nhì|hai|ba|tư|năm|sáu|bảy|tám|chín|mười)")
+        self.roman = RomanVietnamese()
+        self.cardinal = CardinalVietnamese()
+
+        self.special_cases = {
+            "nhất": "thứ nhất",
+            "nhì": "thứ nhì",
+            "hai": "thứ hai",
+            "ba": "thứ ba",
+            "tư": "thứ tư",
+            "năm": "thứ năm",
+            "sáu": "thứ sáu",
+            "bảy": "thứ bảy",
+            "tám": "thứ tám",
+            "chín": "thứ chín",
+            "mười": "thứ mười"
+        }
+
+    def convert(self, token: str) -> str:
+        token = self.filter_regex.sub("", token)
+
+        if self.roman.check_if_roman(token):
+            number, _ = self.roman.convert(token)
+
+            return f"thứ {number}"
+
+        match = self.vietnamese_ordinal_regex.fullmatch(token)
+        if match:
+            prefix = match.group(1) or ""
+            number = match.group(2)
+
+            if number.lower() in self.special_cases:
+                return self.special_cases[number.lower()]
+
+            if number.isdigit():
+                cardinal = self.cardinal.convert(number)
+                return f"thứ {cardinal}"
+
+            return f"{prefix}{number}"
+
+        return f"thứ {self.cardinal.convert(token)}"
+
+
+if __name__ == "__main__":
+    ordinal_converter = OrdinalVietnamese()
+
+    examples = ["nhất", "thứ nhì", "thứ 3", "thứ tư", "thứ năm", "thứ 10", "21", "100", "1000", "II", "IV"]
+
+    for example in examples:
+        result = ordinal_converter.convert(example)
+        print(f"Số thứ tự: {example}")
+        print(f"Chuyển đổi: {result}")
+        print()

converters/Range.py

@@ -0,0 +1,36 @@
+from singleton_decorator import singleton
+import re
+from .Cardinal import CardinalVietnamese
+
+
+@singleton
+class Range:
+    """
+    Steps:
+    - Check for - splitting numbers
+
+    Note:
+    Punctuation always stays the same
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.cardinal = CardinalVietnamese()
+
+    def convert(self, token: str) -> str:
+        numbers = re.split('-', token)
+        if len(numbers) == 1:
+            token = self.cardinal.convert(numbers[0])
+        elif len(numbers) == 2:
+
+            token = self.cardinal.convert(numbers[0])
+            token += ' đến '
+            token += self.cardinal.convert(numbers[1])
+
+        else:
+            token = ''
+            for number in numbers:
+                token += self.cardinal.convert(number)
+                token += ' '
+
+        return token

converters/Roman.py

@@ -0,0 +1,88 @@
+from singleton_decorator import singleton
+import re
+
+
+@singleton
+class RomanVietnamese:
+    """
+    Các bước:
+    - 1 Lấy phần lớn nhất
+    - 2 Kiểm tra hậu tố 's'
+    - 3 Áp dụng lọc nghiêm ngặt
+    - 4 Tính tổng giá trị của chữ số La Mã bằng số nguyên
+    - 5 Trả về biểu diễn chuỗi của tổng, cùng với hậu tố
+    Trường hợp đặc biệt:
+    II I -> hai
+    IIs  -> hai's
+    II.  -> hai
+    """
+
+    def __init__(self):
+        super().__init__()
+        # Regex để lọc bỏ các ký tự không phải chữ số La Mã
+        self.roman_filter_strict_regex = re.compile("[^IVXLCDM]")
+        # Regex để phát hiện chữ số La Mã
+        self.roman_filter_regex = re.compile(r"[.IVXLCDM]+(th|nd|st|rd|'s|s)?")
+
+        # Từ điển giá trị chữ số La Mã
+        self.roman_numerals = {
+            "I": 1,
+            "V": 5,
+            "X": 10,
+            "L": 50,
+            "C": 100,
+            "D": 500,
+            "M": 1000
+        }
+
+
+
+    def convert(self, token: str) -> (str, str):
+        # 1 Tách token thành các phần và làm việc với phần lớn nhất, trong trường hợp đầu vào là "I II"
+        token = max(token.split(" "), key=len)
+        # 2 Kiểm tra xem có cần sử dụng hậu tố "'s" không
+        suffix = ""
+        if token[-1:] == "s":
+            suffix = "'s"
+
+        # 3 Áp dụng lọc nghiêm ngặt để loại bỏ ".", "'" và "s"
+        token = self.roman_filter_strict_regex.sub("", token)
+        # 4 Chúng ta lặp qua token theo chiều ngược lại, liên tục cộng hoặc trừ giá trị được biểu diễn
+        # bởi ký tự, dựa trên các token trước đó.
+        total = 0
+        prev = 0
+        for c in reversed(token):
+            cur = self.roman_numerals[c]
+            total += cur if cur >= prev else -cur
+            prev = cur
+
+        return (str(total), suffix)
+
+
+    def check_if_roman(self, token: str) -> bool:
+        # Kiểm tra xem phần lớn nhất của token có được coi là chữ số La Mã hay không
+        return self.roman_filter_regex.fullmatch(max(token.split(" "), key=len)) != None
+
+
+if __name__ == "__main__":
+    roman_converter = RomanVietnamese()
+
+    # Ví dụ 1
+    example1 = "XIV"
+    result1, suffix1 = roman_converter.convert(example1)
+    print(f"Chữ số La Mã: {example1}")
+    print(f"Chuyển đổi: {result1}{suffix1}")
+    print()
+
+    # Ví dụ 2
+    example2 = "MCMLIV"
+    result2, suffix2 = roman_converter.convert(example2)
+    print(f"Chữ số La Mã: {example2}")
+    print(f"Chuyển đổi: {result2}{suffix2}")
+    print()
+
+    # Ví dụ 3
+    example3 = "IIs"
+    result3, suffix3 = roman_converter.convert(example3)
+    print(f"Chữ số La Mã: {example3}")
+    print(f"Chuyển đổi: {result3}{suffix3}")

converters/Telephone.py

@@ -0,0 +1,90 @@
+from singleton_decorator import singleton
+import re
+
+
+@singleton
+class TelephoneVietnamese:
+    """
+    Các bước:
+    - 1 Chuyển đổi thành chữ thường và thay thế dấu ngoặc đơn bằng dấu gạch ngang
+    - 2 Chuyển đổi từng ký tự trong token
+    - 3 Loại bỏ nhiều "ngat" liên tiếp. Đồng thời loại bỏ "ngat" ở đầu.
+    - 4 Thay thế các "khong" liên tiếp bằng "tram" hoặc "nghin" khi thích hợp
+    Lưu ý:
+    Số điện thoại chứa 0-9, "-", a-z, A-Z, " ", "(", ")"
+    """
+
+    def __init__(self):
+        super().__init__()
+        # Từ điển dịch
+        self.tu_dien_dich = {
+            " ": "ngat",
+            "-": "ngat",
+            "x": "may_nhanh",
+            "0": "không",
+            "1": "môt",
+            "2": "hai",
+            "3": "ba",
+            "4": "bốn",
+            "5": "năm",
+            "6": "sáu",
+            "7": "bảy",
+            "8": "tám",
+            "9": "chín",
+        }
+        # Regex để lọc dấu ngoặc đơn
+        self.regex_loc = re.compile(r"[()]")
+
+    def convert(self, token: str) -> str:
+        # 1 Chuyển đổi thành chữ thường và thay thế dấu ngoặc đơn bằng dấu gạch ngang
+        token = self.regex_loc.sub("-", token.lower())
+
+        # 2 Chuyển đổi danh sách các ký tự
+        danh_sach_ket_qua = [self.tu_dien_dich[c] if c in self.tu_dien_dich else c for c in token]
+
+        # 3 Loại bỏ nhiều "ngat" liên tiếp. Đồng thời loại bỏ "ngat" ở đầu.
+        danh_sach_ket_qua = [phan for i, phan in enumerate(danh_sach_ket_qua) if
+                             phan != "ngat" or (i - 1 >= 0 and danh_sach_ket_qua[i - 1] != "ngat")]
+
+        # 4 Lặp qua danh_sach_ket_qua và thay thế nhiều "khong" liên tiếp bằng "tram" hoặc "nghin",
+        # nhưng chỉ khi đứng trước là thứ khác ngoài "khong" hoặc "ngat", và đứng sau là "ngat" hoặc kết thúc danh sách.
+        i = 0
+        while i < len(danh_sach_ket_qua):
+            do_lech = 0
+            while i + do_lech < len(danh_sach_ket_qua) and danh_sach_ket_qua[i + do_lech] == "khong":
+                do_lech += 1
+            if (i + do_lech >= len(danh_sach_ket_qua) or danh_sach_ket_qua[i + do_lech] == "ngat") and (
+                    i - 1 < 0 or danh_sach_ket_qua[i - 1] not in ("khong", "ngat")) and do_lech in (2, 3):
+                danh_sach_ket_qua[i: do_lech + i] = ["tram"] if do_lech == 2 else ["nghin"]
+            i += 1
+
+        return " ".join(danh_sach_ket_qua)
+
+
+def main():
+    so_dien_thoai = TelephoneVietnamese()
+
+    # Ví dụ sử dụng
+    cac_vi_du = [
+        "0123-456-789",
+        "(098) 765-4321",
+        "0909 333 222",
+        "1800 1560",
+        "19001560",
+        "0336444027",
+        "+84-912345678",
+    ]
+
+    print("Ví dụ chuyển đổi số điện thoại:")
+    for vi_du in cac_vi_du:
+        ket_qua = so_dien_thoai.convert(vi_du)
+        print(f"Gốc: {vi_du}")
+        print(f"Kết quả: {ket_qua}")
+        print()
+
+
+if __name__ == "__main__":
+    # main()
+    x ="027321"
+    if x.startswith(("19", "18", "0")):
+        print(1)

converters/Time.py

@@ -0,0 +1,100 @@
+from singleton_decorator import singleton
+import re
+from .Cardinal import CardinalVietnamese
+
+
+@singleton
+class Time:
+    def __init__(self):
+        super().__init__()
+
+        self.filter_regex = re.compile(r"[. ]")
+        self.time_regex = re.compile(r"^(?P<hour>\d{1,2}) *((?::|.) *(?P<minute>\d{1,2}))? *(?P<suffix>[a-zA-Z\. ]*)$",
+                                     flags=re.I)
+        self.full_time_regex = re.compile(
+            r"^(?:(?P<hour>\d{1,2}) *:)? *(?P<minute>\d{1,2})(?: *: *(?P<seconds>\d{1,2})(?: *. *(?P<milliseconds>\d{1,3}))?)? *(?P<suffix>[a-zA-Z\. ]*)$",
+            flags=re.I)
+        self.ampm_time_regex = re.compile(r"^(?P<suffix>[a-zA-Z\. ]*)(?P<hour>\d{1,2})", flags=re.I)
+
+        self.cardinal = CardinalVietnamese()
+
+    def convert(self, token: str) -> str:
+        token = token.strip()
+        result_list = []
+
+        match = self.time_regex.match(token)
+        if match:
+            hour, minute, suffix = match.group("hour"), match.group("minute"), match.group("suffix")
+
+            result_list.append(self.cardinal.convert(hour))
+            result_list.append("giờ")
+
+            if minute and minute != "00":
+                result_list.append(self.cardinal.convert(minute))
+                result_list.append("phút")
+
+            if suffix:
+                suffix = self.filter_regex.sub("", suffix).lower()
+                if suffix == "sa":
+                    result_list.append("sáng")
+                elif suffix == "ch":
+                    result_list.append("chiều")
+
+            return " ".join(result_list)
+
+        match = self.full_time_regex.match(token)
+        if match:
+            hour, minute, seconds, milliseconds, suffix = match.group("hour"), match.group("minute"), match.group(
+                "seconds"), match.group("milliseconds"), match.group("suffix")
+
+            if hour:
+                result_list.append(self.cardinal.convert(hour))
+                result_list.append("giờ")
+            if minute:
+                result_list.append(self.cardinal.convert(minute))
+                result_list.append("phút")
+            if seconds:
+                result_list.append(self.cardinal.convert(seconds))
+                result_list.append("giây")
+            if milliseconds:
+                result_list.append(self.cardinal.convert(milliseconds))
+                result_list.append("phần nghìn giây")
+
+            if suffix:
+                suffix = self.filter_regex.sub("", suffix).lower()
+                if suffix == "sa":
+                    result_list.append("sáng")
+                elif suffix == "ch":
+                    result_list.append("chiều")
+
+            return " ".join(result_list)
+
+        match = self.ampm_time_regex.match(token)
+        if match:
+            hour, suffix = match.group("hour"), match.group("suffix")
+
+            result_list.append(self.cardinal.convert(hour))
+            result_list.append("giờ")
+
+            suffix = self.filter_regex.sub("", suffix).lower()
+            if suffix == "sa":
+                result_list.append("sáng")
+            elif suffix == "ch":
+                result_list.append("chiều")
+
+            return " ".join(result_list)
+
+        return token
+
+
+if __name__ == "__main__":
+    time = Time()
+
+    print(time.convert("7:30"))  # Kết quả mong đợi: bảy giờ ba mươi phút
+    print(time.convert("8:00 SA"))  # Kết quả mong đợi: tám giờ sáng
+    print(time.convert("3:00 CH"))  # Kết quả mong đợi: ba giờ chiều
+    print(time.convert(
+        "11:59:59.999"))  # Kết quả mong đợi: mười một giờ năm mươi chín phút năm mươi chín giây chín trăm chín mươi chín phần nghìn giây
+    print(time.convert("SA7"))  # Kết quả mong đợi: bảy giờ sáng
+    print(time.convert("CH5"))  # Kết quả mong đợi: năm giờ chiều
+    print(time.convert("9:30:21"))  # Kết quả mong đợi: năm giờ chiều

download.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+if [ ! -f uvr5_weights/2_HP-UVR.pth ]; then
+  echo "Download the model weights"
+  wget -q -O uvr5_weights/2_HP-UVR.pth 2_HP-UVR.pth https://huggingface.co/fastrolling/uvr/resolve/main/Main_Models/2_HP-UVR.pth 
+fi
+
+echo "The model weights have been downloaded"

val_list.txt

@@ -0,0 +1,68 @@
+dataset/Xanh24h/speaker_0/3000.wav|tʃˈuə2ŋ tʃˈaː6j tʃˌɔ ɣˈaː2 kˈi2 lˈən bˈaːw ɣˈo2m kˌaːɜc xˈu vˈy6c sˈaw . |0
+dataset/Xanh24h/speaker_0/3001.wav|ɗˈo2ŋ tˈəː2j , tʃˈuɜŋ kˈu5ŋ lˌaː2 tˈy6c fˈə4m xˌoŋ bˌi6 lˈə5n kˌaːɜc t0ˈaː6p tʃˈəɜt0 ɲˌy kˈim lwˈaː6j , twˈi4 t0ˈiɲ , kˌaːɜc vˈə6t0 kˈyɜŋ xˈaːɜc . |0
+dataset/Xanh24h/speaker_0/3002.wav|ɗˈo2ŋ tˈəː2j , mˈuə sˈaɜm tʃˈy6c t0wˈiɛɜn kˌɔ2n lwˈaː6j bˈɔ4 ɲˈu kˈə2w zˈi tʃwˈiɛ4n ɗˌeɜn kˈyə4 hˈaː2ŋ vˈə6t0 lˈiɜ , zˈuɜp t0ˈiɛɜt0 kˈiɛ6m tˈəː2j zˈaːn vˌaː2 t0ˈiɛ2n bˈaː6c . |0
+dataset/Xanh24h/speaker_0/3003.wav|kˈɔɜ hˈaːj mˈo hˈi2ɲ vˈyə2n ˈyəm ɗˌyə6c ɲˈiɛ2w ŋˈyə2j lˈyə6 tʃˈɔ6n xˌi xˈəː4j ŋˈiɛ6p lˌaː2 vˈyə2n ˈyəm kˈoɜ ɗˈi6ɲ vˌaː2 vˈyə2n ˈyəm t0ˈaː6m tˈəː2j . |0
+dataset/Xanh24h/speaker_0/3004.wav|hˈɔ6k vˈiɛn kˈɔɜ tˈe4 hˈɔ6k mˌɔ6j lˌuɜc mˌɔ6j nˈəːj , xˌoŋ kˈə2n fˌaː4j ɗˌeɜn lˈəːɜp hˈɔ6k tʃˈy6c t0ˈiɛɜp . |0
+dataset/Xanh24h/speaker_0/3005.wav|xˌi lˈyə6 tʃˈɔ6n mˈa6t0 hˈaː2ŋ kwˈaː4 bˈiɛɜw t0ˈeɜt0 , kˈə2n lˈiw ˈiɜ mˈo6t0 sˈoɜ vˈəɜn ɗˈe2 sˈaw . |0
+dataset/Xanh24h/speaker_0/3006.wav|vˈəɪ6 nˌen , ɲˌy5ŋ ŋˈyə2j kˈɔɜ tˈu ɲˈə6p ˈəː4 mˈyɜc tʃˈuŋ bˈi2ɲ xˈaːɜ kˈu5ŋ sˈa5n sˈaː2ŋ bˈɔ4 zˈaː mˈo6t0 xwˈaː4n t0ˈiɛ2n ɗˌe4 tʃˈi tʃˈaː4 tʃˌɔ kˌaːɜc lwˈaː6j tˈy6c fˈə4m tʃˈyɜc nˈaŋ hˈo5 tʃˈəː6 sˈyɜc xwˈɛ4 tʃˌɔ kˈəː tˈe4 . |0
+dataset/Xanh24h/speaker_0/3007.wav|tʃˈɔŋ tʃˈyə2ŋ hˈəː6p tʃˈɔ6n bˈe-ɜɲ zˈaːɜn mˈa6n , hˈa5j ɗˈaː4m bˈaː4w tʃwˈə4n bˌi6 nˈyəɜc tʃˈəɜm ŋˈɔn mˈiɛ6ŋ . |0
+dataset/Xanh24h/speaker_0/3008.wav|mˈa6c zˌu2 t0ˈen ɣˈɔ6j kˌuə4 nˈɔɜ lˌaː2 bˈe-ɜɲ ɲˈaː5n , ɲˌyŋ tˈy6c t0ˈeɜ xˌoŋ sˈy4 zˈu6ŋ ɲˈaː5n t0ˈyəj lˈaː2m ŋwˈiɛn lˈiɛ6w tʃˈiɜɲ . |0
+dataset/Xanh24h/speaker_0/3009.wav|zˈyəɜj zˈoɜŋ kˈə2n kˈɔɜ tˈən hˈi2ɲ kˈən ɗˈoɜj , lˈo2ŋ mˈyə6t0 , mˈaɜt0 sˈaːɜŋ , mˈu5j sˈe-6c , xˌoŋ bˌi6 tˈyəŋ t0ˈiɜc . |0
+dataset/Xanh24h/speaker_0/3010.wav|bˈe-ɜɲ ŋˈɔ6t0 sˈyɜc xwˈɛ4 vˌaː2 tʃˈeɜ bˈiɛɜn lˈe-2ɲ mˈe-6ɲ . |0
+dataset/Xanh24h/speaker_0/3011.wav|kˈiɲ zwˈe-ɲ kwˈə2n ˈaːɜw sˈɛkənd hˈand ɗˌaːŋ lˌaː2 mˈo6t0 sˈu hˈyəɜŋ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j lˈyə6 tʃˈɔ6n bˌəː4j vˈoɜn ɗˈə2w t0ˈy bˈaːn ɗˈə2w xˌoŋ kwˈaːɜ lˈəːɜn , mˈa6t0 hˈaː2ŋ ɗˈaː zˈaː6ŋ vˌaː2 kˈɔɜ ɲˈiɛ2w t0ˈiɛ2m nˈaŋ fˈaːɜt0 tʃˈiɛ4n . |0
+dataset/Xanh24h/speaker_0/3012.wav|ˈəː4 nˈyəɜc t0ˈaː tˌi2 kˈɔɜ zˈəɜt0 ɲˈiɛ2w zˈoɜŋ ɣˈaː2 ɲˌyŋ ɗˌe4 tʃˈan nˈuəj ɣˈaː2 tˈaː4 vˈyə2n tˈɛw hˈyəɜŋ ˈaːn t0wˈaː2n sˈiɲ hˈɔ6k bˈa2ŋ vˈiɛ6c nˈuəj ɣˈaː2 tˈaː4w zˈyə6c tˌi2 tʃˈuɜŋ t0ˈaː lˈyə6 tʃˈɔ6n zˈoɜŋ ɣˈaː2 zˈi . |0
+dataset/Xanh24h/speaker_0/3013.wav|ŋwˈaː2j tʃˈi fˈiɜ twˈe mˈa6t0 bˈa2ŋ vˌaː2 ɲˈə6p hˈaː2ŋ , bˈaː6n kˈu5ŋ kˈə2n ɗˈə2w t0ˈy vˈaː2w kˌaːɜc tˈiɛɜt0 bˌi6 kˈə2n tˈiɛɜt0 , ɗˌe4 kˈiɲ zwˈe-ɲ kwˈə2n ˈaːɜw tʃˈɛ4 ˈɛm . |0
+dataset/Xanh24h/speaker_0/3014.wav|ˈoŋ ɗwˈaː2n tˈe-ɲ t0ˈu2ŋ , ˈəɜp mˈyə2j t0ˈaːɜm , sˈaː5 fˈɔŋ tˈe-6ɲ ˈaː , tˈi6 sˈaː5 zˈaːɜ zˈaːj tʃˈiə sˈɛ4 , vˈaː2w xwˌaː4ŋ nˈam hˈaːj ŋˈi2n mˈyə2j bˈaː ɗˌeɜn nˈam hˈaːj ŋˈi2n mˈyə2j lˈam , tʃˈyə2ŋ ɗˈaː6j hˈɔ6k kˈə2n tˈəː kˈɔɜ hˈo5 tʃˈəː6 tˈy6c hˈiɛ6n zˈy6 ˈaːɜn mˈo hˈi2ɲ lˈuəɜ t0ˈom tʃˈɔŋ ˈo ɗˈe2 bˈaː2w xˈɛɜp kˈiɜn ˈəː4 tˈi6 sˈaː5 zˈaːɜ zˈaːj . |0
+dataset/Xanh24h/speaker_0/3015.wav|ɗˌe4 tˈy6c hˈiɛ6n ɗˈiɛ2w nˈa2j , tʃˈu4 kˈyə4 hˈaː2ŋ nˌen ɗˈə2w t0ˈy vˈaː2w vˈiɛ6c t0ˈaː6w zˈaː mˈo6t0 tʃˈaːŋ wˈɛb tʃˌɔ kˈyə4 hˈaː2ŋ , tˈiɛɜt0 lˈə6p zˈaːn hˈaː2ŋ tʃˈen kˌaːɜc nˈe2n t0ˈaː4ŋ tˈyəŋ mˈaː6j ɗˈiɛ6n t0ˈy4 ɲˌy ʃˈəʊpiː , lazˈɑːdə , tˈɪk tˈɒk hwˌa6c sˈy4 zˈu6ŋ kˌaːɜc mˈaː6ŋ sˈaː5 hˈo6j ɲˌy fˈeɪsbʊk , ˈɪnstɐɡɹˌam , zˈɑːləʊ . |0
+dataset/Xanh24h/speaker_0/3016.wav|kˈɔɜ tˈe4 bˈaː6n kˈə2n bˈaɜt0 tʃˈa6j lˈen ɲˈaː2 kˈiɜɲ zˈuɜp ŋˈan kˈɔ4 zˈaː6j tʃˌɔ kˈəɪ tʃˈo2ŋ tʃˈɔŋ ɲˈaː2 kˈiɜɲ hwˌa6c ɲˈaː2 zˈyə lˈyəɜj kˌuə4 bˈaː6n . |0
+dataset/Xanh24h/speaker_0/3018.wav|nˈam hˈaːj ŋˈi2n mˈyə2j bˈoɜn , ˈe-ɲ kwˈiɛɜt0 t0ˈəm tˈɛw ɗˈuə4j nˈiɛ2m ɗˈaːm mˈe kˈiɲ zwˈe-ɲ tˈe4 tˈaːw . |0
+dataset/Xanh24h/speaker_0/3019.wav|vˈəɪ6 kˌaːɜc bˈaː6n kˈɔɜ tˈaɜc mˈaɜc , tˈy6c sˈy6 ɲˈaː2 lˈe-5ɲ ɗˈaː6w hˈɔ6 kˈim zˈa2w kˈɔɜ t0ˌəːɜj mˈyɜc nˈaː2w ? |0
+dataset/Xanh24h/speaker_0/3020.wav|tʃwˈiɛn zˈaː tʃˈuɜŋ t0ˈoj sˌɛ5 lˈiɛn hˈe6 vˌaː2 zˈaː4j ɗˈaːɜp tˈaɜc mˈaɜc . |0
+dataset/Xanh24h/speaker_0/3022.wav|ŋwˈaː2j fˈaːɜt0 tʃˈiɛ4n kˈiɲ t0ˈeɜ , zˈaː ɗˈi2ɲ ˈoŋ fˈu2ŋ swˈən hwˈaː6t0 lˈuən ɣˈə2n mˈə5w tʃˈɔŋ vˈiɛ6c tˈy6c hˈiɛ6n tʃˈu4 tʃˈyəŋ kˌuə4 ɗˈaː4ŋ , tʃˈiɜɲ sˈe-ɜc , fˈaːɜp lwˈə6t0 kˌuə4 ɲˈaː2 nˈyəɜc vˌaː2 kˌaːɜc kwˈi ɗˈi6ɲ kˌuə4 ɗˈiə6 fˈyəŋ . |0
+dataset/Xanh24h/speaker_0/3023.wav|t0wˈi ɲˈiɛn , tʃˈɔŋ tˈi6 tʃˈyə2ŋ kˈe-6ɲ tʃˈe-ɲ , ɗˌe4 tˈe-2ɲ kˈoŋ bˈaː6n kˈə2n fˌaː4j kˈɔɜ bˈiɜ kwˈiɛɜt0 kˈiɲ zwˈe-ɲ zˈiɛŋ kˌuə4 mˈi2ɲ . |0
+dataset/Xanh24h/speaker_0/3024.wav|kˈo6ŋ vˌəːɜj t0ˈy zwˈi tʃˈiɛɜn lˈyə6c vˌaː2 sˈy6 tʃˈaː4j ŋˈiɛ6m , ˈe-ɲ ɗˌaː5 tˈe-2ɲ kˈoŋ vˌaː2 ɗˌyə6c ɲˈiɛ2w xˈe-ɜc hˈaː2ŋ ɗˈɔɜn ɲˈə6n , vˌaː2 kˈɔɜ ɗˌyə6c tˈe-2ɲ kˈoŋ sˈyɜŋ ɗˈaːɜŋ . |0
+dataset/Xanh24h/speaker_0/3025.wav|tˈyɜ hˈaːj , ɲˈu kˈə2w t0ˈiɛw tˈu6 sˈiɛn kwˈɛ nˈyəɜŋ zˈəɜt0 lˈəːɜn , ɗˈa6c bˈiɛ6t0 lˌaː2 tʃˈɔŋ kˌaːɜc xˈu vˈy6c ɗˈoŋ zˈən kˈy ɣˈə2n tʃˈyə2ŋ hˈɔ6k , xˈu kˈoŋ ŋˈiɛ6p . |0
+dataset/Xanh24h/speaker_0/3026.wav|bˈaː6n kˈɔɜ tˈe4 bˈaːɜn hwˈaː xˈo tʃˈy6c t0ˈiɛɜp tʃˌɔ xˈe-ɜc hˈaː2ŋ hwˌa6c bˈaːɜn bˈuən tʃˌɔ kˌaːɜc ɲˈaː2 bˈaːɜn lˈɛ4 . |0
+dataset/Xanh24h/speaker_0/3027.wav|kˈɔɜ ɲˌy vˈəɪ6 tˌi2 tʃˈɛw tʃˈɛw mˈəːɜj hˈaː6n tʃˈeɜ ɗˌyə6c bˈe6ɲ t0ˈə6t0 vˌaː2 sˈiɲ tʃˈyə4ŋ xwˈɛ4 mˈe-6ɲ . |0
+dataset/Xanh24h/speaker_0/3028.wav|nˌeɜw lˌaː2 zˈɔ2ŋ kˈaːɜ ɲˈə6p xˈə4w tˌi2 zˈaːɜ tˈe-2ɲ zˈəɜt0 ɗˈaɜt0 ɗˈɔ4 , xˌoŋ fˌaː4j ˈaːj kˈu5ŋ kˈɔɜ ɗˈiɛ2w kˈiɛ6n mˈuə . |0
+dataset/Xanh24h/speaker_0/3029.wav|lˈaɜp ɗˈa6t0 hˈe6 tˈoɜŋ ɗˈiɛ6n , nˈyəɜc , tˈoɜŋ zˈɔɜ , twˈaːɜt0 nˈyəɜc . |0
+dataset/Xanh24h/speaker_0/3032.wav|bˈaː6n kˈɔɜ tˈe4 kˈiɲ zwˈe-ɲ kˌaːɜc sˈaː4n fˈə4m mˈəːɜj zˈaː mˈaɜt0 , sˈaː4n fˈə4m lˈiɛn kwˈaːn ɗˌeɜn kˌaːɜc zˈy6 kˈiɛ6n nˈo4j bˈə6t0 . |0
+dataset/Xanh24h/speaker_0/3033.wav|vˌəːɜj lˈyə6ŋ ŋˈyə2j zˈu2ŋ ɗˈoŋ ɗˈaː4w vˌaː2 ɗˈaː zˈaː6ŋ , tˈɪk tˈɒk lˌaː2 mˈo6t0 kˈeɲ t0ˈiɛɜp tˈi6 hˈiɛ6w kwˈaː4 ɗˌe4 t0ˈiɛɜp kˈə6n vˌəːɜj ɗˈoŋ ɗˈaː4w xˈe-ɜc hˈaː2ŋ t0ˈiɛ2m nˈaŋ . |0
+dataset/Xanh24h/speaker_0/3035.wav|ɗˈaː2w tˈeɜ kˈɔɜ tˈe4 kˈɔɜ zˈaːɜŋ tʃˈy6c , zˈaːɜŋ hwˈe-2ɲ , zˈaːɜŋ t0ˈaːm ɗˈaː , zˈaːɜŋ hˈaː6c mˈaːj . |0
+dataset/Xanh24h/speaker_0/3036.wav|tˈɛw t0ˈəː2 ʒˈɔŋˈaːn ˈɪnbəʊ kˌuə4 hˈaː2n kˈuəɜc tʃˌɔ bˈiɛɜt0 , tʃˈɔŋ sˈoɜ kˌaːɜc mˈa6t0 hˈaː2ŋ sˈaː sˈi4 mˌaː2 tʃˈiɛ2w t0ˈiɛn mˈuə , tˈiɛɜt0 bˌi6 ɗˈiɛ6n t0ˈy4 ɗˈyɜŋ ɗˈə2w vˌaː2 tʃˈiɛɜm t0ˌəːɜj bˈoɜn mˈyəj tʃˈiɜn fˈə2n tʃˈam lˈyə6ŋ t0ˈiɛw tˈu6 hˈaː2ŋ sˈaː sˈi4 kˌuə4 kˈim ʒˈɔŋˈun . |0
+dataset/Xanh24h/speaker_0/3037.wav|tˈəː2j zˈaːn sˈaw ɗˈɔɜ , ˈe-ɲ lˈaː2m tˈem ɲˈiɛ2w ŋˈe2 xˈaːɜc ɲˈaw ɲˌy fˈu6c vˈu6 , lˈe5 t0ˈən , bˈoɜk vˈaːɜc ɗˌe4 lˈəɪɜ vˈoɜn mˈuə tˈem hˈaː2ŋ . |0
+dataset/Xanh24h/speaker_0/3038.wav|tˈəː2j ɗˈiɛ4m tˈu hwˈe-6c lˌaː2 xˌi tʃˈaː6c tˈyɜ hˈaːj vˈyə2 ɲˈuɜ lˈen . |0
+dataset/Xanh24h/speaker_0/3039.wav|bˈaː6n kˈɔɜ tˈe4 bˈaːɜn ɗˈo2 tʃˈaːŋ tʃˈiɜ t0ˈeɜt0 ŋwˈiɛn ɗˈaːɜn hˈandmeɪd tʃˈy6c t0ˈiɛɜp tʃˌɔ ŋˈyə2j t0ˈiɛw zˈu2ŋ hwˌa6c tˈoŋ kwˈaː kˌaːɜc ɲˈaː2 bˈaːɜn lˈɛ4 . |0
+dataset/Xanh24h/speaker_0/3041.wav|tʃˈɔŋ t0ˈi2ɲ hˈi2ɲ tˈi6 tʃˈyə2ŋ hˈiɛ6n nˈaj , tˈy6c fˈə4m vˌə5n lˌaː2 ŋˈe-2ɲ hˈaː2ŋ ɗˈyɜŋ ɗˈə2w vˈe2 lˈəː6j ɲwˈə6n tʃˌɔ ɲˌy5ŋ ɲˈaː2 ɗˈə2w t0ˈy tˈoŋ tˈaːɜj . |0
+dataset/Xanh24h/speaker_0/3042.wav|tˈyɜc ˈan kˌuə4 tʃˈuɜŋ bˈaːw ɣˈo2m tˈɔɜk vˌaː2 kˌaːɜc lwˈaː6j zˈaw . |0
+dataset/Xanh24h/speaker_0/3043.wav|lwˈaː2j tʃˈɛw tʃˈɛw kˈɔɜ kˈiɜc tˈyəɜc xˈaːɜ xˈiɛm t0ˈoɜn , vˌəːɜj tʃˈiɛ2w zˈaː2j tˈən ɗˌeɜn ɗˈə2w lˌaː2 bˈoɜn mˈyəj hˈaːj ɗˌeɜn bˈoɜn mˈyəj t0ˈaːɜm sˈaŋt0ˈimˈɛɜt0 , tʃˈɔŋ xˌi tʃˈɔ6ŋ lˈyə6ŋ kˌuə4 tʃˈuɜŋ tʃˈi4 t0ˌy2 xˌoŋ fˈəɪ4 bˈa4j ɗˌeɜn hˈaːj kˈilˈoɣˈaːm , lˈoŋ tʃˈen tˈən kˈɔɜ mˈa2w nˈə1w vˌaː2 zˈyəɜj bˈu6ŋ kˈɔɜ mˈa2w tʃˈaɜŋ hwˌa6c vˈaː2ŋ ɲˈaː6t0 . |0
+dataset/Xanh24h/speaker_0/3044.wav|kˌaːɜc bˈyəɜc tˈy6c hˈiɛ6n mˈo6t0 . ŋˈiɛn kˈiɜw tˈi6 tʃˈyə2ŋ . |0
+dataset/Xanh24h/speaker_0/3046.wav|ɗˈiɛ2w kwˈaːn tʃˈɔ6ŋ lˌaː2 fˌaː4j tʃˈɔ6n kˈaːɜ kˈɔɜ tˈi6t0 sˈan tʃˈaɜc . |0
+dataset/Xanh24h/speaker_0/3047.wav|kˌaːɜc mˈa6t0 hˈaː2ŋ ˈəː4 ɗˈəɪ ɗˌyə6c tʃˈɔ6n lˈɔ6k bˌəː4j ɲˌy5ŋ ŋˈyə2j kˈiɲ zwˈe-ɲ kˈɔɜ kˈiɲ ŋˈiɛ6m , ɗˈaː4m bˈaː4w tʃˈəɜt0 lˈyə6ŋ vˌaː2 ɗˈaː zˈaː6ŋ vˈe2 mˈə5w mˈaː5 . |0
+dataset/Xanh24h/speaker_0/3048.wav|t0ˈiɛɜp tˈi6 kwˈaː ˈiːmeɪl lˌaː2 mˈo6t0 kˈe-ɜc hˈiɛ6w kwˈaː4 ɗˌe4 t0ˈiɛɜp kˈə6n xˈe-ɜc hˈaː2ŋ ɗˌaː5 ɗˈaŋ kˈiɜ ɲˈə6n tˈoŋ t0ˈin t0ˌy2 bˈaː6n . |0
+dataset/Xanh24h/speaker_0/3049.wav|zˈaː ɗˈi2ɲ ˈe-ɲ ɗˌaː5 tˈiɛɜt0 lˈə6p mˈo6t0 tʃˈaːŋ tʃˈaː6j nˈuəj tˈɔ4 tˈyəŋ fˈə4m . |0
+dataset/Xanh24h/speaker_0/3050.wav|vˈe2 sˈaw , mˈɔɜn ˈan ɗˌyə6c mˌɔ6j ŋˈyə2j xˈɛn ŋˈɔn , ɲˈiɛ2w ŋˈyə2j ɲˈə6n sˈɛɜt0 fˈu2 hˈəː6p vˌəːɜj sˈu hˈyəɜŋ tˈy6c fˈə4m zˈyə5 mˈuə2 zˈi6c . |0
+dataset/Xanh24h/speaker_0/3051.wav|tˈiɛɜt0 kˈeɜ vˌaː2 tʃˈaːŋ tʃˈiɜ nˈo6j tˈəɜt0 tʃˌɔ kˈyə4 hˈaː2ŋ . |0
+dataset/Xanh24h/speaker_0/3052.wav|hˈɔ6 ˈyə tʃˈuə6ŋ ɲˌy5ŋ lwˈaː6j hˈaː4j sˈaː4n nˈaː2w vˌaː2 mˈyɜc zˈaːɜ mˌaː2 hˈɔ6 sˈa5n lˈɔ2ŋ tʃˈi tʃˈaː4 lˌaː2 bˈaːw ɲˈiɛw . |0
+dataset/Xanh24h/speaker_0/3053.wav|tˈi6t0 ɣˈaː2 kˈi2 lˈən kˈɔɜ zˈaːɜ tʃˈi6 kˈaːw , ɗˌyə6c ɲˈiɛ2w ŋˈyə2j ˈyə tʃˈuə6ŋ . |0
+dataset/Xanh24h/speaker_0/3054.wav|vˌaː2 vˈu6 tˈu t0ˌy2 tˈaːɜŋ bˈa4j ɗˌeɜn tˈaːɜŋ tʃˈiɜn . |0
+dataset/Xanh24h/speaker_0/3055.wav|ɗˈəɪ kˈu5ŋ lˌaː2 t0ˈiɛ2n ɗˈe2 tˈuɜc ɗˈəɪ4 ɲˈiɛ2w ŋˈyə2j tʃˈɔ6n , ɲˌy lˌaː2 mˈo6t0 kˈoŋ vˈiɛ6c bˈaːɜn hˈaː2ŋ ŋˈaɜn hˈaː6n ɗˌe4 kˈiɛɜm tˈem tˈu ɲˈə6p . |0
+dataset/Xanh24h/speaker_0/3056.wav|bˈaː6n nˌen lˈyə6 tʃˈɔ6n ŋwˈiɛn lˈiɛ6w tʃˈəɜt0 lˈyə6ŋ , ɗˈaː zˈaː6ŋ , ɗˈaː4m bˈaː4w vˈe6 sˈiɲ ˈaːn t0wˈaː2n tˈy6c fˈə4m ɗˌe4 t0ˈaː6w zˈaː ɲˌy5ŋ sˈaː4n fˈə4m tˈəːm ŋˈɔn , hˈəɜp zˈə5n . |0
+dataset/Xanh24h/speaker_0/3057.wav|bˈen kˈe-6ɲ ɗˈɔɜ , kˌɔ2n t0ˈi2m hˈiɛ4w tˈem ɲˌy5ŋ kˈiɛɜn tˈyɜc vˌaː2 kˈi5 twˈə6t0 tʃˈan nˈuəj tʃˈen sˈe-ɜc bˈaːɜw tˌevˈe . |0
+dataset/Xanh24h/speaker_0/3058.wav|ɗˌeɜn vˌəːɜj vˈɪdɪəʊ nˈa2j , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˈin ɣˈy4j ɗˌeɜn kˌaːɜc bˈaː6n kˈə1w tʃwˈiɛ6n vˈe2 tʃˈaː2ŋ tʃˈaːj bˈɔ4 ŋˈe2 kˈi5 sˈy kˈiɛɜm t0ˈiɛ2n t0ˈi4 mˌo5j nˈam ɲˈəː2 ŋˈe2 nˈuəj kˈaːɜ kˈe-4ɲ ˈiɜt0 vˈoɜn . |0
+dataset/Xanh24h/speaker_0/3059.wav|ɲˈiɛ2w xˌi sˈyɜc xwˈɛ4 kˈiɛ6t0 kwˈe6 t0ˌəːɜj mˈyɜc ˈe-ɲ fˌaː4j ɲˈə6p vˈiɛ6n , ɗˈiɛ2w tʃˈi6 zˈɔ swˈi ɲˈyə6c , lˈaːw lˈy6c ɗˌeɜn ɗˈo6 tˈo4 hwˈiɛɜt0 . |0
+dataset/Xanh24h/speaker_0/3060.wav|kˈiɲ zwˈe-ɲ ɗˈo2ŋ hˈo2 kˈu5 lˌaː2 mˈo hˈi2ɲ kˈiɲ zwˈe-ɲ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j kwˈaːn t0ˈəm , ɗˈa6c bˈiɛ6t0 lˌaː2 ɲˌy5ŋ ŋˈyə2j ˈiɛw tˈiɜc sˈiw t0ˈə2m ɗˈo2ŋ hˈo2 . |0
+dataset/Xanh24h/speaker_0/3061.wav|lˈyə6ŋ t0ˈom nˈuəj tʃˈɔŋ zˈuə6ŋ lˈuəɜ kˈə2n ɗˌyə6c kˈiɛ4m swˈaːɜt0 tʃˈa6t0 tʃˈɛ5 ɗˌe4 tʃˈe-ɜɲ t0ˈi2ɲ tʃˈaː6ŋ t0ˈom ˈan lˈuəɜ . |0
+dataset/Xanh24h/speaker_0/3062.wav|zˈɔ ɗˈɔɜ , lˈəː6j ɲwˈə6n t0ˌy2 kˈiɲ zwˈe-ɲ kˈə1w ɗˈoɜj , tʃˈe-ɲ ˈe-4ɲ t0ˈeɜt0 tˈyə2ŋ zˈəɜt0 kˈaːw . |0
+dataset/Xanh24h/speaker_0/3063.wav|zˈi6c vˈu6 nˈa2j ɗˈaːɜp ˈyɜŋ ɲˈu kˈə2w kˌuə4 kˌaːɜc zwˈe-ɲ ŋˈiɛ6p , hˈo6 kˈiɲ zwˈe-ɲ mˈuəɜn bˈa2j mˈəm kˈuɜŋ tˈə2n t0ˈaː2j tʃˈuɜ ɗˈaːɜw , tʃwˈə4n , fˈɔŋ t0ˈu6c mˌaː2 xˌoŋ kˈə2n t0ˈoɜn tˈəː2j zˈaːn , kˈoŋ sˈyɜc . |0
+dataset/Xanh24h/speaker_0/3064.wav|ŋˈiɛn kˈiɜw tˈi6 tʃˈyə2ŋ ɗˌe4 t0ˈi2m hˈiɛ4w sˈu hˈyəɜŋ vˌaː2 ɲˈu kˈə2w kˌuə4 fˈu6 hwˈiɲ hˈiɛ6n nˈaj . |0
+dataset/Xanh24h/speaker_0/3065.wav|vˌaː2 mˈo6t0 sˈoɜ xˌoŋ ŋˈaː6j tʃˈi t0ˈiɛ2n ɗˌe4 kˈɔɜ ɗˌyə6c ɗˈa6c kwˈiɛ2n nˈa2j . |0
+dataset/Xanh24h/speaker_0/3066.wav|mˈo hˈi2ɲ nˈuəj ɣˈaː2 tˈaː4w zˈyə6c ɗˈaɜt0 ɣˈəɜp bˈaː ɣˈaː2 tˈyə2ŋ vˌə5n tʃˈaɜj hˈaː2ŋ . |0
+dataset/Xanh24h/speaker_0/3067.wav|ɗˈoɜj vˌəːɜj ɲˌy5ŋ ŋˈyə2j tʃˈɔ6n mˈuə fˈu6 kˈiɛ6n tʃˌɔ tʃˈiɛɜc ɗˈiɛ6n twˈaː6j ˈiɛw kwˈiɜ kˌuə4 mˈi2ɲ , hˈɔ6 tˈyə2ŋ kˈɔɜ xˈaː4 nˈaŋ , lˈyə6 tʃˈɔ6n sˈaː4n fˈə4m tˈɛw kˌaːɜc t0ˈiɛw tʃˈiɜ nˈa2j . |0
+dataset/Xanh24h/speaker_0/3068.wav|ɗˈiɛ2w nˈa2j sˌɛ5 t0ˈaː6w zˈaː mˈo6t0 ŋˈuə2n tˈu ɲˈə6p ˈo4n ɗˈi6ɲ vˌaː2 ɗˈaː zˈaː6ŋ tʃˌɔ kˈyə4 hˈaː2ŋ . |0
+dataset/Xanh24h/speaker_0/3069.wav|nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam mˈyə2j t0ˈaːɜm , ˈe-ɲ kwˈiɛɜt0 ɗˈi6ɲ vˈaj vˈoɜn ŋˈən hˈaː2ŋ ɗˌe4 ɗˈə2w t0ˈy sˈəɪ zˈy6ŋ hˈe6 tˈoɜŋ bˈe4 nˈuəj t0ˈom hˈu2m bˈoŋ . |0
+dataset/Xanh24h/speaker_0/3070.wav|xˌi tˈyəŋ hˈiɛ6w ɗˌaː5 kˈɔɜ tʃˈo5 ɗˈyɜŋ tʃˈen tˈi6 tʃˈyə2ŋ , tʃˈu4 ʃˈɒp kˈɔɜ tˈe4 bˈaɜt0 ɗˈə2w fˈaːɜt0 tʃˈiɛ4n tˈem ɗˈaː zˈaː6ŋ sˈaː4n fˈə4m . |0
+dataset/Xanh24h/speaker_0/3071.wav|xˌi t0ˈyəɜj bˈa2ŋ t0ˈaj , hˈa5j t0ˈyəɜj vˈaː2w vˈu2ŋ zˈe5 ɗˌe4 nˈyəɜc t0ˌy2 t0ˌy2 ŋˈə2m sˈuəɜŋ ɗˈəɜt0 . |0
+dataset/Xanh24h/speaker_0/3072.wav|kˈɔɜ tˈe4 nˈɔɜj , kˈiɲ zwˈe-ɲ zˈi6c vˈu6 vˈə6n t0ˈaː4j tʃˈɛ4 ˈɛm kˈɔɜ tˈi6 tʃˈyə2ŋ zˈo6ŋ ɲˌyŋ kˈu5ŋ kˈɔɜ zˈəɜt0 ɲˈiɛ2w kˈe-6ɲ tʃˈe-ɲ . |0
+dataset/Xanh24h/speaker_0/3074.wav|tˈəː2j zˈaːn t0ˌy2 xˌoŋ ɗˌeɜn bˈaː mˈyəj lˈam ŋˈa2j . |0
+dataset/Xanh24h/speaker_0/3075.wav|tʃˈuɜŋ zˈuɜp tʃˈɛ4 fˈaːɜt0 tʃˈiɛ4n vˈe2 mˈa6t0 tˈe4 tʃˈəɜt0 , tʃˈiɜ t0wˈe6 , kˈaː4m sˈuɜc vˌaː2 kˈi5 nˈaŋ sˈaː5 hˈo6j , zˈɔ ɗˈɔɜ ɗˈo2 tʃˈəːj tʃˈəː4 tˈe-2ɲ mˈo6t0 mˈa6t0 hˈaː2ŋ tˈiɛɜt0 ˈiɛɜw xˌoŋ tˈe4 tˈiɛɜw tʃˈɔŋ kˈuə6c sˈoɜŋ kˌuə4 tʃˈɛ4 ˈɛm . |0

whisperx/SubtitlesProcessor.py

@@ -0,0 +1,227 @@
+import math
+from conjunctions import get_conjunctions, get_comma
+from typing import TextIO
+
+def normal_round(n):
+    if n - math.floor(n) < 0.5:
+        return math.floor(n)
+    return math.ceil(n)
+
+
+def format_timestamp(seconds: float, is_vtt: bool = False):
+
+    assert seconds >= 0, "non-negative timestamp expected"
+    milliseconds = round(seconds * 1000.0)
+
+    hours = milliseconds // 3_600_000
+    milliseconds -= hours * 3_600_000
+
+    minutes = milliseconds // 60_000
+    milliseconds -= minutes * 60_000
+
+    seconds = milliseconds // 1_000
+    milliseconds -= seconds * 1_000
+
+    separator = '.' if is_vtt else ','
+    
+    hours_marker = f"{hours:02d}:"
+    return (
+        f"{hours_marker}{minutes:02d}:{seconds:02d}{separator}{milliseconds:03d}"
+    )
+
+
+
+class SubtitlesProcessor:
+    def __init__(self, segments, lang, max_line_length = 45, min_char_length_splitter = 30, is_vtt = False):
+        self.comma = get_comma(lang)
+        self.conjunctions = set(get_conjunctions(lang))
+        self.segments = segments
+        self.lang = lang
+        self.max_line_length = max_line_length
+        self.min_char_length_splitter = min_char_length_splitter
+        self.is_vtt = is_vtt
+        complex_script_languages = ['th', 'lo', 'my', 'km', 'am', 'ko', 'ja', 'zh', 'ti', 'ta', 'te', 'kn', 'ml', 'hi', 'ne', 'mr', 'ar', 'fa', 'ur', 'ka']
+        if self.lang in complex_script_languages:
+            self.max_line_length = 30
+            self.min_char_length_splitter = 20
+
+    def estimate_timestamp_for_word(self, words, i, next_segment_start_time=None):
+        k = 0.25
+        has_prev_end = i > 0 and 'end' in words[i - 1]
+        has_next_start = i < len(words) - 1 and 'start' in words[i + 1]
+
+        if has_prev_end:
+            words[i]['start'] = words[i - 1]['end']
+            if has_next_start:
+                words[i]['end'] = words[i + 1]['start']
+            else:
+                if next_segment_start_time:
+                    words[i]['end'] = next_segment_start_time if next_segment_start_time - words[i - 1]['end'] <= 1 else next_segment_start_time - 0.5
+                else:
+                    words[i]['end'] = words[i]['start'] + len(words[i]['word']) * k
+
+        elif has_next_start:
+            words[i]['start'] = words[i + 1]['start'] - len(words[i]['word']) * k
+            words[i]['end'] = words[i + 1]['start']
+
+        else:
+            if next_segment_start_time:
+                words[i]['start'] = next_segment_start_time - 1
+                words[i]['end'] = next_segment_start_time - 0.5
+            else:
+                words[i]['start'] = 0
+                words[i]['end'] = 0
+
+
+
+    def process_segments(self, advanced_splitting=True):
+        subtitles = []
+        for i, segment in enumerate(self.segments):
+            next_segment_start_time = self.segments[i + 1]['start'] if i + 1 < len(self.segments) else None
+            
+            if advanced_splitting:
+
+                split_points = self.determine_advanced_split_points(segment, next_segment_start_time)
+                subtitles.extend(self.generate_subtitles_from_split_points(segment, split_points, next_segment_start_time))
+            else:
+                words = segment['words']
+                for i, word in enumerate(words):
+                    if 'start' not in word or 'end' not in word:
+                        self.estimate_timestamp_for_word(words, i, next_segment_start_time)
+
+                subtitles.append({
+                'start': segment['start'],
+                'end': segment['end'],
+                'text': segment['text']
+            })
+
+        return subtitles
+
+    def determine_advanced_split_points(self, segment, next_segment_start_time=None):
+        split_points = []
+        last_split_point = 0
+        char_count = 0
+
+        words = segment.get('words', segment['text'].split())
+        add_space = 0 if self.lang in ['zh', 'ja'] else 1
+
+        total_char_count = sum(len(word['word']) if isinstance(word, dict) else len(word) + add_space for word in words)
+        char_count_after = total_char_count
+
+        for i, word in enumerate(words):
+            word_text = word['word'] if isinstance(word, dict) else word
+            word_length = len(word_text) + add_space
+            char_count += word_length
+            char_count_after -= word_length
+
+            char_count_before = char_count - word_length
+
+            if isinstance(word, dict) and ('start' not in word or 'end' not in word):
+                self.estimate_timestamp_for_word(words, i, next_segment_start_time)
+
+            if char_count >= self.max_line_length:
+                midpoint = normal_round((last_split_point + i) / 2)
+                if char_count_before >= self.min_char_length_splitter:
+                    split_points.append(midpoint)
+                    last_split_point = midpoint + 1
+                    char_count = sum(len(words[j]['word']) if isinstance(words[j], dict) else len(words[j]) + add_space for j in range(last_split_point, i + 1))
+
+            elif word_text.endswith(self.comma) and char_count_before >= self.min_char_length_splitter and char_count_after >= self.min_char_length_splitter:
+                split_points.append(i)
+                last_split_point = i + 1
+                char_count = 0
+
+            elif word_text.lower() in self.conjunctions and char_count_before >= self.min_char_length_splitter and char_count_after >= self.min_char_length_splitter:
+                split_points.append(i - 1)
+                last_split_point = i
+                char_count = word_length
+
+        return split_points
+
+    
+    def generate_subtitles_from_split_points(self, segment, split_points, next_start_time=None):
+        subtitles = []
+        
+        words = segment.get('words', segment['text'].split())
+        total_word_count = len(words)
+        total_time = segment['end'] - segment['start']
+        elapsed_time = segment['start']
+        prefix = ' ' if self.lang not in ['zh', 'ja'] else ''
+        start_idx = 0
+        for split_point in split_points:
+
+            fragment_words = words[start_idx:split_point + 1]
+            current_word_count = len(fragment_words)
+            
+
+            if isinstance(fragment_words[0], dict):
+                start_time = fragment_words[0]['start']
+                end_time = fragment_words[-1]['end']
+                next_start_time_for_word = words[split_point + 1]['start'] if split_point + 1 < len(words) else None
+                if next_start_time_for_word and (next_start_time_for_word - end_time) <= 0.8:
+                    end_time = next_start_time_for_word
+            else:
+                fragment = prefix.join(fragment_words).strip()
+                current_duration = (current_word_count / total_word_count) * total_time
+                start_time = elapsed_time
+                end_time = elapsed_time + current_duration
+                elapsed_time += current_duration
+
+
+            subtitles.append({
+                'start': start_time,
+                'end': end_time,
+                'text': fragment if not isinstance(fragment_words[0], dict) else prefix.join(word['word'] for word in fragment_words)
+            })
+            
+            start_idx = split_point + 1
+
+        # Handle the last fragment
+        if start_idx < len(words):
+            fragment_words = words[start_idx:]
+            current_word_count = len(fragment_words)
+            
+            if isinstance(fragment_words[0], dict):
+                start_time = fragment_words[0]['start']
+                end_time = fragment_words[-1]['end']
+            else:
+                fragment = prefix.join(fragment_words).strip()
+                current_duration = (current_word_count / total_word_count) * total_time
+                start_time = elapsed_time
+                end_time = elapsed_time + current_duration
+
+            if next_start_time and (next_start_time - end_time) <= 0.8:
+                end_time = next_start_time
+
+            subtitles.append({
+                'start': start_time,
+                'end': end_time if end_time is not None else segment['end'],
+                'text': fragment if not isinstance(fragment_words[0], dict) else prefix.join(word['word'] for word in fragment_words)
+            })
+            
+        return subtitles
+    
+
+
+    def save(self, filename="subtitles.srt", advanced_splitting=True):
+        
+        subtitles = self.process_segments(advanced_splitting)
+
+        def write_subtitle(file, idx, start_time, end_time, text):
+
+            file.write(f"{idx}\n")
+            file.write(f"{start_time} --> {end_time}\n")
+            file.write(text + "\n\n")
+
+        with open(filename, 'w', encoding='utf-8') as file:
+            if self.is_vtt:
+                file.write("WEBVTT\n\n")
+            
+            if advanced_splitting:
+                for idx, subtitle in enumerate(subtitles, 1):
+                    start_time = format_timestamp(subtitle['start'], self.is_vtt)
+                    end_time = format_timestamp(subtitle['end'], self.is_vtt)
+                    text = subtitle['text'].strip()
+                    write_subtitle(file, idx, start_time, end_time, text)
+
+        return len(subtitles)

whisperx/__init__.py

@@ -0,0 +1,4 @@
+from .transcribe import load_model
+from .alignment import load_align_model, align
+from .audio import load_audio
+from .diarize import assign_word_speakers, DiarizationPipeline

whisperx/__main__.py

@@ -0,0 +1,4 @@
+from .transcribe import cli
+
+
+cli()