WeTextProcessing 1.0.6.dev19__tar.gz → 1.3.0__tar.gz

wetextprocessing-1.3.0/.github/workflows/android.yml

@@ -0,0 +1,91 @@
+name: Android Build
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      # Android project itself, plus the shared C++ runtime it compiles from source.
+      - "runtime/android/**"
+      - "runtime/bindings/android/**"
+      - "runtime/CMakeLists.txt"
+      - "runtime/CMakePresets.json"
+      - "runtime/processor/**"
+      - "runtime/utils/**"
+      - "runtime/cmake/**"
+      - ".github/workflows/android.yml"
+
+jobs:
+  build-android:
+    name: build (android)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '21'
+
+      # Caches downloaded Gradle distribution and dependencies across runs.
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          build-root-directory: runtime/android
+
+      # Puts sdkmanager on PATH, accepts licenses, installs platform + build-tools.
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+        with:
+          packages: 'platforms;android-36 build-tools;36.0.0'
+
+      # sdkmanager has no bare "ndk" package — must install "ndk;X.Y.Z". Pick the
+      # newest side-by-side NDK from the package list.
+      - name: Install NDK (latest)
+        run: |
+          NDK_PKG=$(sdkmanager --list 2>/dev/null \
+            | grep -oE 'ndk;[0-9]+\.[0-9]+\.[0-9]+' \
+            | sort -t';' -k2 -V \
+            | tail -1)
+          if [ -z "$NDK_PKG" ]; then
+            echo "ERROR: no ndk;* package found in sdkmanager --list" >&2
+            sdkmanager --list 2>/dev/null | grep -i ndk | head -20 >&2 || true
+            exit 1
+          fi
+          echo "Installing $NDK_PKG"
+          sdkmanager --install "$NDK_PKG"
+          NDK_VER="${NDK_PKG#ndk;}"
+          echo "Using NDK $NDK_VER"
+          echo "ANDROID_NDK_HOME=$ANDROID_HOME/ndk/$NDK_VER" >> "$GITHUB_ENV"
+
+      # Build the native lib with CMake presets and install it into jniLibs/<abi>/.
+      # Gradle does NOT drive CMake; it only packages the prebuilt .so.
+      - name: Build native lib
+        working-directory: runtime
+        run: |
+          cmake --preset android-arm64-v8a
+          cmake --build --preset android-arm64-v8a
+          cmake --install build/aarch64-linux-android --component jni
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      # Generate the four FST models straight into assets/ so the APK ships with
+      # them (the app loads zh_tn_* and zh_itn_* at runtime).
+      - name: Generate model assets
+        run: |
+          pip install pynini importlib_resources
+          assets=runtime/android/app/src/main/assets
+          python -m tn  --language zh --overwrite_cache --cache_dir "$assets"
+          python -m itn --language zh --overwrite_cache --cache_dir "$assets"
+
+      - name: Build release APK
+        working-directory: runtime/android
+        run: ./gradlew :app:assembleRelease -PabiFilters=arm64-v8a --no-daemon
+
+      - name: Upload release APK
+        uses: actions/upload-artifact@v4
+        with:
+          name: app-release-arm64-v8a
+          path: runtime/android/app/build/outputs/apk/release/app-release.apk
+          if-no-files-found: error

wetextprocessing-1.3.0/.github/workflows/runtime.yml

@@ -0,0 +1,69 @@
+name: Runtime Build
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - "runtime/**"
+      # Android has its own workflow; don't rebuild the desktop runtime for
+      # Android-only changes (shared processor/utils/cmake still match above).
+      - "!runtime/android/**"
+      - "!runtime/bindings/android/**"
+      - ".github/workflows/runtime.yml"
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build runtime
+        run: |
+          cmake -B build -G Ninja -S runtime -DBUILD_TESTING=ON
+          cmake --build build --parallel
+      - uses: actions/setup-python@v5
+        if: matrix.os == 'ubuntu-latest'
+        with:
+          python-version: '3.x'
+      - name: Install dependencies & Generate TN models
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          pip install pynini importlib_resources
+          python -m tn --language zh --overwrite_cache
+      - name: Run tests
+        if: matrix.os == 'ubuntu-latest'
+        run: ctest --test-dir build/test --output-on-failure
+
+  build-windows:
+    name: build (windows-latest)
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          update: false
+          cache: true
+          install: >-
+            mingw-w64-x86_64-cmake
+            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-ninja
+
+      - name: Build runtime
+        run: |
+          cmake --version
+          gcc --version
+
+          # Tests are skipped on Windows: processor_test needs zh_tn_*.fst, which
+          # are generated via pynini, and pynini has no Windows build.
+          cmake -S runtime -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_TESTING=OFF
+          cmake --build build --parallel

wetextprocessing-1.3.0/.github/workflows/unittest.yml

@@ -0,0 +1,86 @@
+name: UnitTest
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - '**.py'
+      - '**.tsv'
+      - '**.toml'
+      - '**.yml'
+      - '**.yaml'
+      - '.flake8'
+      - '.style.yapf'
+
+jobs:
+  unit-test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ${{ github.event_name == 'pull_request' && fromJSON('["ubuntu-latest"]') || fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]') }}
+        python-version: ['3.9']
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Set up Python ${{ matrix.python-version }} (non-Windows)
+        if: runner.os != 'Windows'
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Cache Homebrew (macOS)
+        if: runner.os == 'macOS'
+        uses: actions/cache@v4
+        with:
+          path: |
+            /opt/homebrew/Cellar/openfst
+            /opt/homebrew/include/fst
+            /opt/homebrew/lib/libfst*
+          key: brew-openfst-${{ runner.os }}
+      - name: Install openfst (macOS)
+        if: runner.os == 'macOS'
+        run: |
+          brew install openfst || true
+          echo "CPLUS_INCLUDE_PATH=/opt/homebrew/include:$CPLUS_INCLUDE_PATH" >> $GITHUB_ENV
+          echo "LIBRARY_PATH=/opt/homebrew/lib:$LIBRARY_PATH" >> $GITHUB_ENV
+      - name: Cache pip (non-Windows)
+        if: runner.os != 'Windows'
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: pip-${{ runner.os }}-${{ hashFiles('pyproject.toml') }}
+      - name: Install dependencies (non-Windows)
+        if: runner.os != 'Windows'
+        run: |
+          python -m pip install --upgrade pip
+          pip install .[test]
+      - name: Set up Conda (Windows)
+        if: runner.os == 'Windows'
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+          activate-environment: test
+          use-only-tar-bz2: true
+      - name: Cache Conda (Windows)
+        if: runner.os == 'Windows'
+        uses: actions/cache@v4
+        with:
+          path: C:\Miniconda\envs\test
+          key: conda-${{ runner.os }}-${{ hashFiles('pyproject.toml') }}
+      - name: Install dependencies (Windows)
+        if: runner.os == 'Windows'
+        shell: bash -el {0}
+        run: |
+          conda install -c conda-forge pynini
+          python -m pip install --upgrade pip
+          pip install .[test] --no-deps
+          pip install flake8 pytest importlib_resources
+      - name: Lint with flake8
+        shell: bash -el {0}
+        run: |
+          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+      - name: Test with pytest
+        shell: bash -el {0}
+        run: pytest

wetextprocessing-1.3.0/.github/workflows/wheels.yml

@@ -0,0 +1,74 @@
+name: Build Wheels
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Release version (optional, will be determined by setuptools_scm if not provided)'
+        required: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.9]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .[test]
+          pip install build twine
+
+      - name: Build Graph
+        run: |
+          python -m tn --text "2.5平方电线" --overwrite_cache --language "zh"
+          python -m tn --text "2010-03-21" --overwrite_cache --language "en"
+          python -m itn --text "二点五平方电线" --overwrite_cache
+          python -m itn --text "one two three" --overwrite_cache --language "en"
+
+      - name: Prepare Graph
+        run: |
+          mkdir graph
+          cp tn/*.fst graph
+          cp itn/*.fst graph
+          cp tn/*_cache.json graph
+          cp itn/*_cache.json graph
+
+      - name: Get version from setuptools_scm
+        id: scm_version
+        run: |
+          # Check if version is provided as input
+          if [ -n "${{ github.event.inputs.version }}" ]; then
+            echo "VERSION=${{ github.event.inputs.version }}" >> $GITHUB_OUTPUT
+          else
+            # Get version from setuptools_scm
+            pip install setuptools_scm
+            VERSION=$(python -m setuptools_scm | tail -1)
+            echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Upload Graph
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-graph-v${{ steps.scm_version.outputs.VERSION }}
+          path: graph
+
+      - name: Build package
+        run: |
+          python -m build
+
+      - name: Publish on pypi.org
+        if: github.ref == 'refs/heads/master' && github.repository == 'wenet-e2e/WeTextProcessing'
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          python -m twine upload dist/*

wetextprocessing-1.3.0/.gitignore

@@ -0,0 +1,48 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Visual Studio Code files
+.vscode
+.vs
+
+# PyCharm files
+.idea
+
+# Eclipse Project settings
+*.*project
+.settings
+
+# Sublime Text settings
+*.sublime-workspace
+*.sublime-project
+
+# Editor temporaries
+*.swn
+*.swo
+*.swp
+*.swm
+*~
+
+# IPython notebook checkpoints
+.ipynb_checkpoints
+
+# macOS dir files
+.DS_Store
+
+# Clangd files
+.cache
+.venv/
+compile_commands.json
+
+
+# Setup files
+WeTextProcessing.egg-info/
+build/
+dist/
+tn/*.far
+itn/*.far
+
+# Version file(setuptools_scm generated)
+tn/_version.py

wetextprocessing-1.3.0/.pre-commit-config.yaml

@@ -0,0 +1,23 @@
+exclude: '.*\.(txt|tsv)$'
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+    - id: trailing-whitespace
+  - repo: https://github.com/google/yapf
+    rev: 'v0.43.0'
+    hooks:
+    - id: yapf
+  - repo: https://github.com/pycqa/flake8
+    rev: '7.3.0'
+    hooks:
+    - id: flake8
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: 'v17.0.6'
+    hooks:
+    - id: clang-format
+      exclude: '.*\.(json|java|js|m|mm|proto)'
+  - repo: https://github.com/cpplint/cpplint
+    rev: '1.6.1'
+    hooks:
+    - id: cpplint

wetextprocessing-1.3.0/.style.yapf

@@ -0,0 +1,3 @@
+[style]
+based_on_style = pep8
+column_limit = 127

wetextprocessing-1.3.0/PKG-INFO

@@ -0,0 +1,290 @@
+Metadata-Version: 2.4
+Name: WeTextProcessing
+Version: 1.3.0
+Summary: WeTextProcessing, including TN & ITN
+Author-email: Zhendong Peng <pzd17@tsinghua.org.cn>, Xingchen Song <sxc19@tsinghua.org.cn>
+Project-URL: Homepage, https://github.com/wenet-e2e/WeTextProcessing
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pynini>=2.1.6
+Requires-Dist: importlib_resources
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: flake8; extra == "test"
+Provides-Extra: dev
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pre-commit==3.5.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+
+# WeTextProcessing
+
+**Rule-based text normalization and inverse text normalization for speech applications.**
+
+[Quick start](#quick-start) · [Languages](#supported-languages) · [Python API](#python-api) · [Rule architecture](docs/python-rule-architecture.md) · [C++ runtime](runtime/README.md)
+
+[![Unit tests](https://github.com/wenet-e2e/WeTextProcessing/actions/workflows/unittest.yml/badge.svg)](https://github.com/wenet-e2e/WeTextProcessing/actions/workflows/unittest.yml)
+
+</div>
+
+WeTextProcessing converts between written and spoken text using weighted finite-state transducers (WFSTs), built with [Pynini](https://www.openfst.org/twiki/bin/view/GRM/Pynini) and [OpenFst](https://www.openfst.org/twiki/bin/view/FST/WebHome).
+
+- **TN and ITN** — normalize numbers, dates, times, currencies, units, and other structured expressions.
+- **Multilingual rules** — language-specific grammars for every language in [Supported languages](#supported-languages).
+- **Explainable output** — inspect raw tagged fields, trace input/output spans, and request unique n-best results.
+- **Reusable graphs** — automatic, configuration-aware FST caching and a separate C++ deployment runtime.
+
+For background and motivation, read [WeTextProcessing: Production First & Production Ready Text Processing Toolkit](https://mp.weixin.qq.com/s/q_11lck78qcjylHCi6wVsQ) (Chinese).
+
+## What are TN and ITN?
+
+### Text normalization
+
+TN converts written expressions into their spoken forms, for example `12` → `十二`. It is commonly used before speech synthesis.
+
+<div align=center><img src="https://user-images.githubusercontent.com/13466943/193439861-acfba531-13d1-4fca-b2f2-6e47fc10f195.png" alt="Cover" width="50%"/></div>
+
+### Inverse text normalization
+
+ITN converts spoken expressions into written forms, for example `十二` → `12`. It is commonly used after speech recognition.
+
+<div align=center><img src="https://user-images.githubusercontent.com/13466943/193439870-634c44a3-bd62-4311-bcf2-1427758d5f62.png" alt="Cover" width="50%"/></div>
+
+## Supported languages
+
+| Language | CLI code | TN | ITN | Python package |
+| --- | --- | --- | --- | --- |
+| Arabic | `ar` | Yes | Yes | `arabic` |
+| Armenian | `hy` | Yes | Yes | `armenian` |
+| Chinese | `zh` | Yes | Yes | `chinese` |
+| English | `en` | Yes | Yes | `english` |
+| French | `fr` | Yes | Yes | `french` |
+| German | `de` | Yes | Yes | `german` |
+| Hebrew | `he` | Yes | Yes | `hebrew` |
+| Hindi | `hi` | Yes | Yes | `hindi` |
+| Hindi–English (code-mixed) | `hi_en` | No | Yes | `hindi_english` |
+| Hungarian | `hu` | Yes | Yes | `hungarian` |
+| Italian | `it` | Yes | Yes | `italian` |
+| Japanese | `ja` | Yes | Yes | `japanese` |
+| Kinyarwanda | `rw` | Yes | Yes | `kinyarwanda` |
+| Korean | `ko` | Yes | Yes | `korean` |
+| Marathi | `mr` | Yes | Yes | `marathi` |
+| Portuguese | `pt` | Yes | Yes | `portuguese` |
+| Russian | `ru` | Yes | Yes | `russian` |
+| Spanish | `es` | Yes | Yes | `spanish` |
+| Spanish–English (code-mixed) | `es_en` | No | Yes | `spanish_english` |
+| Swedish | `sv` | Yes | Yes | `swedish` |
+| Vietnamese | `vi` | Yes | Yes | `vietnamese` |
+
+Chinese is the CLI default. Rule coverage and configurable options vary by language and direction.
+
+The published package includes Chinese, English, and Japanese. The other languages are included in this source checkout; install from source to use them before the next package release.
+
+## Quick start
+
+### Install
+
+Install the published package:
+
+```bash
+pip install WeTextProcessing
+```
+
+For the latest rules, including every language beyond Chinese, English, and Japanese, install from source:
+
+```bash
+git clone https://github.com/wenet-e2e/WeTextProcessing.git
+cd WeTextProcessing
+pip install -e .
+```
+
+Pynini/OpenFst must be available in your Python environment. If a compatible wheel is unavailable, follow the [Pynini installation instructions](https://www.openfst.org/twiki/bin/view/GRM/Pynini). On Windows, the project's CI uses `conda install -c conda-forge pynini` before installing WeTextProcessing.
+
+### Run the CLI
+
+```bash
+wetn --text "2.5平方电线"
+weitn --text "二点五平方电线"
+
+wetn --language en --text "13 dollars"
+weitn --language en --text "thirteen dollars"
+
+wetn --language de --text "23"
+weitn --language de --text "dreiundzwanzig"
+
+wetn --language ja --text "１２時"
+weitn --language ja --text "十二時"
+
+wetn --language ko --text "오후 3시 30분"
+weitn --language ko --text "오천원"
+```
+
+Each input produces two lines: the **tagged representation**, then the **verbalized result**. The tagger preserves raw field values; the verbalizer performs the conversion.
+
+The same interfaces are available as `python -m tn` and `python -m itn`. Both accept `--text`, `--file PATH`, or UTF-8 text from standard input when neither option is supplied:
+
+```bash
+python -m tn --language en --file input.txt
+python -m itn --language ko < input.txt
+```
+
+Only input line endings are removed before processing. Other spaces are passed to the selected language's rules.
+
+### Language-specific options
+
+Inspect the options for the selected language and direction:
+
+```bash
+wetn --language zh --help
+weitn --language ko --help
+```
+
+For example:
+
+```bash
+wetn --language zh --no-remove-erhua --text "这儿"
+weitn --language zh --enable-0-to-9 --text "一二三"
+```
+
+Boolean options accept `--option` / `--no-option` and the legacy `--option True|False` form. Options from another language or direction are not accepted.
+
+## Python API
+
+Import the normalizer for the language you need and reuse the instance:
+
+```python
+from tn.chinese.normalizer import Normalizer
+from itn.chinese.inverse_normalizer import InverseNormalizer
+
+normalizer = Normalizer()
+inverse_normalizer = InverseNormalizer()
+
+print(normalizer.normalize("今天中午12点"))
+print(inverse_normalizer.normalize("二点五平方电线"))
+```
+
+Other languages use the same class names under their packages. For example, Korean:
+
+```python
+from tn.korean.normalizer import Normalizer
+from itn.korean.inverse_normalizer import InverseNormalizer
+
+normalizer = Normalizer()
+inverse_normalizer = InverseNormalizer()
+
+print(normalizer.normalize("오후 3시 30분"))
+print(inverse_normalizer.normalize("오천원"))
+```
+
+### Inspect tags
+
+Tagging and verbalization are independently accessible:
+
+```python
+tagged = normalizer.tag("오후 3시 30분")
+print(tagged)
+print(normalizer.verbalize(tagged))
+```
+
+The hours and minutes remain written values in the tags, rather than being replaced with their Korean readings.
+
+### Input/output span mapping
+
+`normalize_with_mapping()` returns normalized text and the spans matched by grammar rules:
+
+```python
+from tn.chinese.normalizer import Normalizer
+
+normalizer = Normalizer()
+result = normalizer.normalize_with_mapping("今天中午12点")
+
+print(result.output_text)
+for mapping in result.mappings:
+    print(mapping.token_type, mapping.input_text, "=>", mapping.output_text)
+```
+
+Output:
+
+```text
+今天中午十二点
+math 12 => 十二
+```
+
+Offsets are half-open Unicode character offsets, not UTF-8 byte offsets. Use `include_identity=True` to include unchanged tokens, or `result.as_dict()` to obtain a serializable representation. Mappings are traced through the WFSTs, not inferred from a text diff.
+
+### N-best results
+
+```python
+outputs = normalizer.normalize("3/4", nbest=3)
+results = normalizer.normalize_with_mapping("3/4", nbest=3)
+```
+
+`nbest=1` returns a string or a single `NormalizationResult`; `nbest>1` returns a list of up to that many unique outputs. The mapping API follows the same output ranking.
+
+## FST caching
+
+Graphs are cached automatically outside the source tree. Cache bundles record the pipeline's configuration and grammar-source fingerprint; changing either causes a new bundle to be built.
+
+| Setting | Behavior |
+| --- | --- |
+| `cache_dir=None` | Use the platform's default user cache |
+| `cache_dir="/path/to/cache"` | Choose an explicit cache root |
+| `cache_dir=False` | Build in memory without persistent caching |
+| `overwrite_cache=True` | Force rebuilding the selected bundle |
+
+```python
+from tn.chinese.normalizer import Normalizer
+
+normalizer = Normalizer(cache_dir="/path/to/wetext-cache")
+uncached = Normalizer(cache_dir=False)
+```
+
+The CLI exposes `--cache-dir PATH` and `--overwrite-cache`. Normal use does not require forced rebuilds.
+
+## Development and deployment
+
+Install development dependencies and run the tests:
+
+```bash
+pip install -e '.[dev]'
+pre-commit install
+pytest -q
+```
+
+Before adding or changing a language rule, read the [Python rule architecture guide](docs/python-rule-architecture.md). Rules preserve raw fields in the tagger, apply semantic conversion in the verbalizer, and use pipeline-owned rule inventories and field-order schemas.
+
+| Guide | Scope |
+| --- | --- |
+| [TN rules](tn/README.md) | Text normalization rules and examples |
+| [ITN rules](itn/README.md) | Inverse text normalization rules and examples |
+| [Python rule architecture](docs/python-rule-architecture.md) | Tagging, verbalization, registration, and span mapping contracts |
+| [C++ runtime](runtime/README.md) | Native build and deployment instructions |
+
+Python cache bundles are **not** C++ runtime exports. Follow the runtime's model and build instructions for native deployment.
+
+## Community
+
+Use [GitHub Issues](https://github.com/wenet-e2e/WeTextProcessing/issues) for questions, bug reports, and feature requests.
+
+For Chinese users, follow the WeNet official account using the QR code on the left. Scan the personal QR code on the right to contact the person who can invite you to the WeChat discussion group.
+
+| <img src="https://github.com/robin1001/qr/blob/master/wenet.jpeg" width="250px"> | <img src="https://user-images.githubusercontent.com/13466943/203046432-f637180e-4c87-40cc-be05-ce48c65dd1ef.jpg" width="250px"> |
+| ---- | ---- |
+
+## Acknowledgments
+
+- [OpenFst](https://www.openfst.org/twiki/bin/view/FST/WebHome) and [Pynini](https://www.openfst.org/twiki/bin/view/GRM/Pynini) for the finite-state toolkit.
+- The [NeMo Text Processing](https://github.com/NVIDIA/NeMo-text-processing) team and community for text-processing grammars and resources, including the [Chinese TN reference](https://github.com/NVIDIA/NeMo-text-processing/tree/main/nemo_text_processing/text_normalization/zh).
+- [Zhenxiang Ma](https://github.com/mzxcpp), [Jiayu Du](https://github.com/dophist), and [SpeechColab](https://github.com/SpeechColab) for their contributions.
+- [Pynini](https://github.com/kylebgorman/pynini) for reference implementations of FAR loading and shortest-path decoding in the C++ runtime.
+- [chinese_text_normalization](https://github.com/speechio/chinese_text_normalization/tree/master/thrax/src/cn) for Chinese ITN grammar resources.
+
+## License
+
+[Apache License 2.0](LICENSE).