Upload 32 files

my_jiwer/.github/workflows/pythonpackage.yml

@@ -0,0 +1,63 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Python package
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  style:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.7]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Setup dependencies
+      run: |
+        poetry update
+        poetry install
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        poetry run flake8 jiwer --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        poetry run flake8 jiwer --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics
+    - name: Check formatting with black
+      run: |
+        poetry run black . --check
+     
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Install dependencies
+      run: |
+        poetry run python -m pip install --upgrade pip
+        poetry update
+        poetry install
+    - name: Test with pytest
+      run: |
+        poetry run python --version
+        poetry run pytest

my_jiwer/.github/workflows/pythonpublish.yml

@@ -0,0 +1,33 @@
+# This workflows will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Install dependencies
+      run: |
+        poetry run python -m pip install --upgrade pip
+        poetry update
+        poetry install
+    - name: Build and publish
+      env:
+        POETRY_HTTP_BASIC_PYPI_USERNAME: ${{ secrets.PYPI_USERNAME }}
+        POETRY_PYPI_TOKEN_PYPI:  ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        poetry publish --build

my_jiwer/.gitignore

@@ -0,0 +1,28 @@
+# Compiled python modules.
+*.pyc
+
+# Setuptools distribution folder.
+/dist/
+
+# Python egg metadata, regenerated from source files by setuptools.
+/*.egg-info
+
+# playground directory for running local debug code
+playground
+
+# poetry .lock file
+poetry.lock
+
+# idea specific folders
+.idea
+.vscode
+
+# virtual environments
+venv
+.venv
+
+# cache folders
+.pytest_cache
+.benchmarks
+/docs/site/
+/site/

my_jiwer/.mailmap

@@ -0,0 +1,6 @@
+# mail map file
+# for cleaner output of e.g. `git shortlog -nes`
+
+Nik Vaessen <nikvaes@gmail.com>
+Nik Vaessen <nikvaes@gmail.com> <nikvaessen@users.noreply.github.com>
+Bart van Andel <bavanandel@gmail.com>

my_jiwer/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 8x8, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

my_jiwer/README.md

@@ -0,0 +1,55 @@
+# JiWER
+
+JiWER is a simple and fast python package to evaluate an automatic speech recognition system.
+It supports the following measures:
+
+1. word error rate (WER)
+2. match error rate (MER)
+3. word information lost (WIL) 
+4. word information preserved (WIP) 
+5. character error rate (CER)
+
+These measures are computed with the use of the minimum-edit distance between one or more reference and hypothesis sentences.
+The minimum-edit distance is calculated using [RapidFuzz](https://github.com/maxbachmann/RapidFuzz), which uses C++ under the hood, and is therefore faster than a pure python implementation.
+
+## Documentation
+
+For further info, see the documentation at [jitsi.github.io/jiwer](https://jitsi.github.io/jiwer).
+
+## Installation
+
+You should be able to install this package using [poetry](https://python-poetry.org/docs/): 
+
+```
+$ poetry add jiwer
+```
+
+Or, if you prefer old-fashioned pip and you're using Python >= `3.7`:
+
+```bash
+$ pip install jiwer
+```
+
+## Usage
+
+The most simple use-case is computing the word error rate between two strings:
+
+```python
+from jiwer import wer
+
+reference = "hello world"
+hypothesis = "hello duck"
+
+error = wer(reference, hypothesis)
+```
+
+## Licence
+
+The jiwer package is released under the `Apache License, Version 2.0` licence by [8x8](https://www.8x8.com/).
+
+For further information, see [`LICENCE`](./LICENSE).
+
+## Reference
+
+_For a comparison between WER, MER and WIL, see: \
+Morris, Andrew & Maier, Viktoria & Green, Phil. (2004). [From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.](https://www.researchgate.net/publication/221478089_From_WER_and_RIL_to_MER_and_WIL_improved_evaluation_measures_for_connected_speech_recognition)_

my_jiwer/docs/cli.md

@@ -0,0 +1,29 @@
+
+JiWER provides a simple CLI, which should be available after installation. 
+
+For details, see `jiwer --help`.
+
+```text
+$ jiwer --help
+Usage: jiwer [OPTIONS]
+
+  JiWER is a python tool for computing the word-error-rate of ASR systems. To
+  use this CLI, store the reference and hypothesis sentences in a text file,
+  where each sentence is delimited by a new-line character. The text files are
+  expected to have an equal number of lines, unless the `-g` flag is used. The
+  `-g` flag joins computation of the WER by doing a global minimal alignment.
+
+Options:
+  -r, --reference PATH   Path to new-line delimited text file of reference
+                         sentences.  [required]
+  -h, --hypothesis PATH  Path to new-line delimited text file of hypothesis
+                         sentences.  [required]
+  -c, --cer              Compute CER instead of WER.
+  -a, --align            Print alignment of each sentence.
+  -g, --global           Apply a global minimal alignment between reference
+                         and hypothesis sentences before computing the WER.
+  --help                 Show this message and exit.
+```
+
+Note that the CLI does not support a custom pre-processing (as described below). Any pre-processing
+should be done on the text files manually before calling JiWER when using the CLI. 

my_jiwer/docs/gen_ref_pages.py

@@ -0,0 +1,28 @@
+"""Generate the code reference pages and navigation."""
+
+from pathlib import Path
+import mkdocs_gen_files
+
+nav = mkdocs_gen_files.Nav()
+
+for path in sorted(Path("jiwer").rglob("*.py")):
+    doc_path = path.relative_to("jiwer").with_suffix(".md")
+    full_doc_path = Path("reference", doc_path)
+
+    module_path = path.relative_to("jiwer").with_suffix("")
+    parts = list(module_path.parts)
+
+    if parts[-1] == "__init__" or parts[-1] == "cli":
+        continue
+
+    nav[parts] = doc_path.as_posix()
+
+    with mkdocs_gen_files.open(full_doc_path, "w") as fd:
+        identifier = ".".join(parts)
+        print("::: " + identifier, file=fd)
+
+    mkdocs_gen_files.set_edit_path(full_doc_path, path)
+
+
+with mkdocs_gen_files.open("reference/SUMMARY.md", "w") as nav_file:
+    nav_file.writelines(nav.build_literate_nav())

my_jiwer/docs/index.md

@@ -0,0 +1,31 @@
+# JiWER
+
+JiWER is a simple and fast python package to evaluate an automatic speech recognition system.
+It supports the following measures:
+
+1. word error rate (WER)
+2. match error rate (MER)
+3. word information lost (WIL) 
+4. word information preserved (WIP) 
+5. character error rate (CER)
+
+These measures are computed with the use of the minimum-edit distance between one or more reference and hypothesis sentences.
+The minimum-edit distance is calculated using [RapidFuzz](https://github.com/maxbachmann/RapidFuzz), which uses C++ under the hood, and is therefore faster than a pure python implementation.
+
+# Installation
+
+You should be able to install this package using [poetry](https://python-poetry.org/docs/): 
+
+```
+$ poetry add jiwer
+```
+
+Or, if you prefer old-fashioned pip and you're using Python >= `3.7`:
+
+```bash
+$ pip install jiwer
+```
+
+
+
+

my_jiwer/docs/requirements.txt

@@ -0,0 +1,5 @@
+mkdocs==1.4.2
+mkdocstrings[python]==0.20.0
+mkdocs-gen-files==0.4.0
+mkdocs-literate-nav==0.6.0
+mkdocs-material==9.1.3

my_jiwer/docs/usage.md

@@ -0,0 +1,111 @@
+# Usage
+
+The most simple use-case is computing the word error rate between two strings:
+
+```python
+from jiwer import wer
+
+reference = "hello world"
+hypothesis = "hello duck"
+
+error = wer(reference, hypothesis)
+```
+
+Similarly, to get other measures:
+
+```python
+import jiwer
+
+reference = "hello world"
+hypothesis = "hello duck"
+
+wer = jiwer.wer(reference, hypothesis)
+mer = jiwer.mer(reference, hypothesis)
+wil = jiwer.wil(reference, hypothesis)
+
+# faster, because `compute_measures` only needs to perform the heavy lifting once:
+output = jiwer.process_words(reference, hypothesis)
+wer = output.wer
+mer = output.mer
+wil = output.wil
+```
+
+You can also compute the WER over multiple sentences:
+
+```python
+from jiwer import wer
+
+reference = ["hello world", "i like monthy python"]
+hypothesis = ["hello duck", "i like python"]
+
+error = wer(reference, hypothesis)
+```
+
+We also provide the character error rate:
+
+```python
+import jiwer
+
+reference = ["i can spell", "i hope"]
+hypothesis = ["i kan cpell", "i hop"]
+
+error = jiwer.cer(reference, hypothesis)
+
+# if you also want the alignment
+output = jiwer.process_characters(reference, hypothesis)
+error = output.cer
+```
+
+# Alignment
+
+With `jiwer.process_words`, you also get the alignment between the reference and hypothesis.
+
+We provide the alignment as a list of `(op, ref_start_idx, ref_idx_end, hyp_idx_start, hyp_idx_end)`, where `op` is one of
+    `equal`, `replace`, `delete`, or `insert`.
+
+This looks like the following:
+
+```python3
+import jiwer
+
+out = jiwer.process_words("short one here", "shoe order one")
+print(out.alignments)
+# [[[AlignmentChunk(type='insert', ref_start_idx=0, ref_end_idx=0, hyp_start_idx=0, hyp_end_idx=1), ...]]
+```
+
+To visualize the alignment, you can use `jiwer.visualize_alignment()`
+
+For example:
+
+```python3
+import jiwer
+
+out = jiwer.process_words(
+    ["short one here", "quite a bit of longer sentence"],
+    ["shoe order one", "quite bit of an even longest sentence here"],
+)
+
+print(jiwer.visualize_alignment(out))
+```
+Gives the following output
+```text
+sentence 1
+REF: **** short one here
+HYP: shoe order one ****
+        I     S        D
+
+sentence 2
+REF: quite a bit of ** ****  longer sentence ****
+HYP: quite * bit of an even longest sentence here
+           D         I    I       S             I
+
+number of sentences: 2
+substitutions=2 deletions=2 insertions=4 hits=5
+
+mer=61.54%
+wil=74.75%
+wip=25.25%
+wer=88.89%
+```
+
+Note that it also possible to visualize the character-level alignment, simply use the output of `jiwer.process_characters()` instead. 

my_jiwer/mkdocs.yml

@@ -0,0 +1,47 @@
+site_name: "jiwer"
+site_description: "Documentation for jiwer."
+site_url: "https://jitsi.github.io/jiwer/"
+repo_url: "https://github.com/jitsi/jiwer"
+edit_uri: "blob/master/docs/"
+repo_name: "jitsi/jiwer"
+site_dir: "site"
+
+theme:
+  name: "material"
+  features:
+    - content.code.annotate
+    - navigation.tabs
+    - navigation.tabs.sticky
+    - navigation.top
+
+plugins:
+- mkdocstrings:
+    handlers:
+      python:
+        paths: [jiwer]
+        options:
+          separate_signature: true
+          show_root_heading: true
+          show_root_members_full_path: false
+- search
+- gen-files:
+    scripts:
+    - docs/gen_ref_pages.py
+- literate-nav:
+    nav_file: SUMMARY.md
+- autorefs
+
+nav:
+  - jiwer: index.md
+  - Usage: usage.md
+  - Command-line interface: cli.md
+  - API reference: reference/
+
+markdown_extensions:
+  - toc:
+      permalink: "#"
+  - pymdownx.superfences
+
+watch:
+- docs
+- jiwer

my_jiwer/my_jiwer/__init__.py

@@ -0,0 +1,7 @@
+from .measures import *
+from .transforms import *
+from .transformations import *
+from .alignment import *
+from .process import *
+
+name = "jiwer"

my_jiwer/my_jiwer/alignment.py

@@ -0,0 +1,185 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Utility method to visualize the alignment between one or more reference and hypothesis
+pairs.
+"""
+
+from typing import Dict, List, Tuple, Union
+
+
+from jiwer.process import CharacterOutput, WordOutput, AlignmentChunk
+
+__all__ = ["visualize_alignment"]
+
+
+def visualize_alignment(
+    output: Union[WordOutput, CharacterOutput],
+    show_measures: bool = True,
+    skip_correct: bool = True,
+) -> str:
+    """
+    Visualize the output of [jiwer.process_words][process.process_words] and
+    [jiwer.process_characters][process.process_characters]. The visualization
+    shows the alignment between each processed reference and hypothesis pair.
+    If `show_measures=True`, the output string will also contain all measures in the
+    output.
+
+    Args:
+        output: The processed output of reference and hypothesis pair(s).
+        show_measures: If enabled, the visualization will include measures like the WER
+                       or CER
+        skip_correct: If enabled, the visualization will exclude correct reference and hypothesis pairs
+
+    Returns:
+        (str): The visualization as a string
+
+    Example:
+        This code snippet
+        ```python
+        import jiwer
+
+        out = jiwer.process_words(
+            ["short one here", "quite a bit of longer sentence"],
+            ["shoe order one", "quite bit of an even longest sentence here"],
+        )
+
+        print(jiwer.visualize_alignment(out))
+        ```
+        will produce this visualization:
+        ```txt
+        sentence 1
+        REF:    # short one here
+        HYP: shoe order one    *
+                I     S        D
+
+        sentence 2
+        REF: quite a bit of  #    #  longer sentence    #
+        HYP: quite * bit of an even longest sentence here
+                   D         I    I       S             I
+
+        number of sentences: 2
+        substitutions=2 deletions=2 insertions=4 hits=5
+
+        mer=61.54%
+        wil=74.75%
+        wip=25.25%
+        wer=88.89%
+        ```
+
+        When `show_measures=False`, only the alignment will be printed:
+
+        ```txt
+        sentence 1
+        REF:    # short one here
+        HYP: shoe order one    *
+                I     S        D
+
+        sentence 2
+        REF: quite a bit of  #    #  longer sentence    #
+        HYP: quite * bit of an even longest sentence here
+                   D         I    I       S             I
+        ```
+    """
+    references = output.references
+    hypothesis = output.hypotheses
+    alignment = output.alignments
+    is_cer = isinstance(output, CharacterOutput)
+
+    final_str = ""
+    for idx, (gt, hp, chunks) in enumerate(zip(references, hypothesis, alignment)):
+        if skip_correct and len(chunks) == 1 and chunks[0].type == "equal":
+            continue
+
+        final_str += f"sentence {idx+1}\n"
+        final_str += _construct_comparison_string(
+            gt, hp, chunks, include_space_seperator=not is_cer
+        )
+        final_str += "\n"
+
+    if show_measures:
+        final_str += f"number of sentences: {len(alignment)}\n"
+        final_str += f"substitutions={output.substitutions} "
+        final_str += f"deletions={output.deletions} "
+        final_str += f"insertions={output.insertions} "
+        final_str += f"hits={output.hits}\n"
+
+        if is_cer:
+            final_str += f"\ncer={output.cer*100:.2f}%\n"
+        else:
+            final_str += f"\nmer={output.mer*100:.2f}%"
+            final_str += f"\nwil={output.wil*100:.2f}%"
+            final_str += f"\nwip={output.wip*100:.2f}%"
+            final_str += f"\nwer={output.wer*100:.2f}%\n"
+    else:
+        # remove last newline
+        final_str = final_str[:-1]
+
+    return final_str
+
+
+def _construct_comparison_string(
+    reference: List[str],
+    hypothesis: List[str],
+    ops: List[AlignmentChunk],
+    include_space_seperator: bool = False,
+) -> str:
+    ref_str = "REF: "
+    hyp_str = "HYP: "
+    op_str = "     "
+
+    for op in ops:
+        if op.type == "equal" or op.type == "substitute":
+            ref = reference[op.ref_start_idx : op.ref_end_idx]
+            hyp = hypothesis[op.hyp_start_idx : op.hyp_end_idx]
+            op_char = " " if op.type == "equal" else "s"
+        elif op.type == "delete":
+            ref = reference[op.ref_start_idx : op.ref_end_idx]
+            hyp = ["*" for _ in range(len(ref))]
+            op_char = "d"
+        elif op.type == "insert":
+            hyp = hypothesis[op.hyp_start_idx : op.hyp_end_idx]
+            ref = ["*" for _ in range(len(hyp))]
+            op_char = "i"
+        else:
+            raise ValueError(f"unparseable op name={op.type}")
+
+        op_chars = [op_char for _ in range(len(ref))]
+        for rf, hp, c in zip(ref, hyp, op_chars):
+            str_len = max(len(rf), len(hp), len(c))
+
+            if rf == "*":
+                rf = "".join(["*"] * str_len)
+            elif hp == "*":
+                hp = "".join(["*"] * str_len)
+
+            ref_str += f"{rf:>{str_len}}"
+            hyp_str += f"{hp:>{str_len}}"
+            op_str += f"{c.upper():>{str_len}}"
+
+            if include_space_seperator:
+                ref_str += " "
+                hyp_str += " "
+                op_str += " "
+
+    if include_space_seperator:
+        # remove last space
+        return f"{ref_str[:-1]}\n{hyp_str[:-1]}\n{op_str[:-1]}\n"
+    else:
+        return f"{ref_str}\n{hyp_str}\n{op_str}\n"

my_jiwer/my_jiwer/cli.py

@@ -0,0 +1,133 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Provide a simple CLI wrapper for JiWER. The CLI does not support custom transforms.
+"""
+
+import click
+import pathlib
+
+import jiwer
+
+
+@click.command()
+@click.option(
+    "-r",
+    "--reference",
+    "reference_file",
+    type=pathlib.Path,
+    required=True,
+    help="Path to new-line delimited text file of reference sentences.",
+)
+@click.option(
+    "-h",
+    "--hypothesis",
+    "hypothesis_file",
+    type=pathlib.Path,
+    required=True,
+    help="Path to new-line delimited text file of hypothesis sentences.",
+)
+@click.option(
+    "--cer",
+    "-c",
+    "compute_cer",
+    is_flag=True,
+    default=False,
+    help="Compute CER instead of WER.",
+)
+@click.option(
+    "--align",
+    "-a",
+    "show_alignment",
+    is_flag=True,
+    default=False,
+    help="Print alignment of each sentence.",
+)
+@click.option(
+    "--global",
+    "-g",
+    "global_alignment",
+    is_flag=True,
+    default=False,
+    help="Apply a global minimal alignment between reference and hypothesis sentences "
+    "before computing the WER.",
+)
+def cli(
+    reference_file: pathlib.Path,
+    hypothesis_file: pathlib.Path,
+    compute_cer: bool,
+    show_alignment: bool,
+    global_alignment: bool,
+):
+    """
+    JiWER is a python tool for computing the word-error-rate of ASR systems. To use
+    this CLI, store the reference and hypothesis sentences in a text file, where
+    each sentence is delimited by a new-line character.
+    The text files are expected to have an equal number of lines, unless the `-g` flag
+    is used. The `-g` flag joins computation of the WER by doing a global minimal
+    alignment.
+
+    """
+    with reference_file.open("r") as f:
+        reference_sentences = [
+            ln.strip() for ln in f.readlines() if len(ln.strip()) > 1
+        ]
+
+    with hypothesis_file.open("r") as f:
+        hypothesis_sentences = [
+            ln.strip() for ln in f.readlines() if len(ln.strip()) > 1
+        ]
+
+    if not global_alignment and len(reference_sentences) != len(hypothesis_sentences):
+        raise ValueError(
+            f"Number of sentences does not match. "
+            f"{reference_file} contains {len(reference_sentences)} lines."
+            f"{hypothesis_file} contains {len(hypothesis_sentences)} lines."
+        )
+
+    if global_alignment and compute_cer:
+        raise ValueError("--global and --cer are mutually exclusive.")
+
+    if compute_cer:
+        out = jiwer.process_characters(
+            reference_sentences,
+            hypothesis_sentences,
+        )
+    else:
+        if global_alignment:
+            out = jiwer.process_words(
+                reference_sentences,
+                hypothesis_sentences,
+                reference_transform=jiwer.wer_contiguous,
+                hypothesis_transform=jiwer.wer_contiguous,
+            )
+        else:
+            out = jiwer.process_words(reference_sentences, hypothesis_sentences)
+
+    if show_alignment:
+        print(jiwer.visualize_alignment(out, show_measures=True))
+    else:
+        if compute_cer:
+            print(out.cer)
+        else:
+            print(out.wer)
+
+
+if __name__ == "__main__":
+    cli()

my_jiwer/my_jiwer/measures.py

@@ -0,0 +1,488 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Convenience methods for calculating a number of similarity error
+measures between a reference and hypothesis sentence.
+These measures are
+commonly used to measure the performance for an automatic speech recognition
+(ASR) system.
+
+The following measures are implemented:
+
+- Word Error Rate (WER), which is where this library got its name from. This
+  has long been (and arguably still is) the de facto standard for computing
+  ASR performance.
+- Match Error Rate (MER)
+- Word Information Lost (WIL)
+- Word Information Preserved (WIP)
+- Character Error Rate (CER)
+
+Note that these functions merely call
+[jiwer.process_words][process.process_words] and
+[jiwer.process_characters][process.process_characters].
+It is more efficient to call `process_words` or `process_characters` and access the
+results from the
+[jiwer.WordOutput][process.WordOutput] and
+[jiwer.CharacterOutput][process.CharacterOutput]
+classes.
+"""
+import warnings
+
+from typing import List, Union, Dict, Any
+
+from jiwer import transforms as tr
+from jiwer.transformations import wer_default, cer_default
+from jiwer.process import process_words, process_words_embdiff, process_characters
+
+__all__ = [
+    "wer",
+    "wer_embdiff",
+    "mer",
+    "wil",
+    "wip",
+    "cer",
+    "compute_measures",
+]
+
+########################################################################################
+# Implementation of the WER method and co, exposed publicly
+
+
+def wer(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word error rate (WER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word error rate of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+    return output.wer
+
+def wer_embdiff(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word error rate (WER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word error rate of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output, edit_ops = process_words_embdiff(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+    return output, edit_ops
+
+
+def mer(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the match error rate (MER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The match error rate of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return output.mer
+
+
+def wip(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word information preserved (WIP) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word information preserved of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return output.wip
+
+
+def wil(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word information lost (WIL) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+        `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word information lost of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return output.wil
+
+
+########################################################################################
+# deprecated method 'compute_measures'
+
+
+def compute_measures(
+    truth: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+) -> Dict[str, Any]:
+    """
+    Efficiently computes all measures using only one function call.
+
+    Deprecated:
+        Deprecated method. Superseded by [jiwer.process_words][process.process_words].
+        This method will be removed on next release.
+
+    Args:
+        truth: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        truth_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (dict): A dictionary containing key-value pairs for all measures.
+
+    """
+    warnings.warn(
+        DeprecationWarning(
+            "jiwer.compute_measures() is deprecated. Please use jiwer.process_words()."
+        )
+    )
+
+    output = process_words(
+        reference=truth,
+        hypothesis=hypothesis,
+        reference_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    return {
+        "wer": output.wer,
+        "mer": output.mer,
+        "wil": output.wil,
+        "wip": output.wip,
+        "hits": output.hits,
+        "substitutions": output.substitutions,
+        "deletions": output.deletions,
+        "insertions": output.insertions,
+        "ops": output.alignments,
+        "truth": output.references,
+        "hypothesis": output.hypotheses,
+    }
+
+
+########################################################################################
+# Implementation of character-error-rate, exposed publicly
+
+
+def cer(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+    return_dict: bool = False,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> Union[float, Dict[str, Any]]:
+    """
+    Calculate the character error rate (CER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        return_dict: Deprecated option to return the more results in a dict instead of
+                     returning only the cer as a single float value
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Argument `return_dict` will be deprecated. Please use
+        [jiwer.process_characters][process.process_characters] instead.
+
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The character error rate of the given reference and hypothesis
+                 sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_characters(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    if return_dict:
+        warnings.warn(
+            DeprecationWarning(
+                "`return_dict` is deprecated, "
+                "please use jiwer.process_characters() instead."
+            )
+        )
+        return {
+            "cer": output.cer,
+            "hits": output.hits,
+            "substitutions": output.substitutions,
+            "deletions": output.deletions,
+            "insertions": output.insertions,
+        }
+    else:
+        return output.cer
+
+
+def _deprecate_truth(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    truth: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform],
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform],
+    truth_transform: Union[tr.Compose, tr.AbstractTransform],
+):
+    if truth is not None:
+        warnings.warn(
+            DeprecationWarning(
+                "keyword argument `truth` is deprecated, please use `reference`."
+            )
+        )
+        if reference is not None:
+            raise ValueError("cannot give `reference` and `truth`")
+        reference = truth
+    if truth_transform is not None:
+        warnings.warn(
+            DeprecationWarning(
+                "keyword argument `truth_transform` is deprecated, "
+                "please use `reference_transform`."
+            )
+        )
+        reference_transform = truth_transform
+
+    if reference is None or hypothesis is None:
+        raise ValueError(
+            "detected default values for reference or hypothesis arguments, "
+            "please provide actual string or list of strings"
+        )
+
+    return reference, hypothesis, reference_transform, hypothesis_transform

my_jiwer/my_jiwer/process.py

@@ -0,0 +1,525 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+The core algorithm(s) for processing a one or more reference and hypothesis sentences
+so that measures can be computed and an alignment can be visualized.
+"""
+
+from dataclasses import dataclass
+
+from typing import Any, List, Union
+from itertools import chain
+
+import rapidfuzz
+
+from rapidfuzz.distance import Opcodes
+
+from jiwer import transforms as tr
+from jiwer.transformations import wer_default, cer_default
+
+
+__all__ = [
+    "AlignmentChunk",
+    "WordOutput",
+    "CharacterOutput",
+    "process_words",
+    "process_words_embdiff",
+    "process_characters",
+]
+
+
+@dataclass
+class AlignmentChunk:
+    """
+    Define an alignment between two subsequence of the reference and hypothesis.
+
+    Attributes:
+        type: one of `equal`, `substitute`, `insert`, or `delete`
+        ref_start_idx: the start index of the reference subsequence
+        ref_end_idx: the end index of the reference subsequence
+        hyp_start_idx: the start index of the hypothesis subsequence
+        hyp_end_idx: the end index of the hypothesis subsequence
+    """
+
+    type: str
+
+    ref_start_idx: int
+    ref_end_idx: int
+
+    hyp_start_idx: int
+    hyp_end_idx: int
+
+    def __post_init__(self):
+        if self.type not in ["replace", "insert", "delete", "equal", "substitute"]:
+            raise ValueError("")
+
+        # rapidfuzz uses replace instead of substitute... For consistency, we change it
+        if self.type == "replace":
+            self.type = "substitute"
+
+        if self.ref_start_idx > self.ref_end_idx:
+            raise ValueError(
+                f"ref_start_idx={self.ref_start_idx} "
+                f"is larger "
+                f"than ref_end_idx={self.ref_end_idx}"
+            )
+        if self.hyp_start_idx > self.hyp_end_idx:
+            raise ValueError(
+                f"hyp_start_idx={self.hyp_start_idx} "
+                f"is larger "
+                f"than hyp_end_idx={self.hyp_end_idx}"
+            )
+
+
+@dataclass
+class WordOutput:
+    """
+    The output of calculating the word-level levenshtein distance between one or more
+    reference and hypothesis sentence(s).
+
+    Attributes:
+        references: The reference sentences
+        hypotheses: The hypothesis sentences
+        alignments: The alignment between reference and hypothesis sentences
+        wer: The word error rate
+        mer: The match error rate
+        wil: The word information lost measure
+        wip: The word information preserved measure
+        hits: The number of correct words between reference and hypothesis sentences
+        substitutions: The number of substitutions required to transform hypothesis
+                       sentences to reference sentences
+        insertions: The number of insertions required to transform hypothesis
+                       sentences to reference sentences
+        deletions: The number of deletions required to transform hypothesis
+                       sentences to reference sentences
+
+    """
+
+    # processed input data
+    references: List[List[str]]
+    hypotheses: List[List[str]]
+
+    # alignment
+    alignments: List[List[AlignmentChunk]]
+
+    # measures
+    wer: float
+    mer: float
+    wil: float
+    wip: float
+
+    # stats
+    hits: int
+    substitutions: int
+    insertions: int
+    deletions: int
+
+
+def process_words(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+) -> WordOutput:
+    """
+    Compute the word-level levenshtein distance and alignment between one or more
+    reference and hypothesis sentences. Based on the result, multiple measures
+    can be computed, such as the word error rate.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (WordOutput): The processed reference and hypothesis sentences
+    """
+    # validate input type
+    if isinstance(reference, str):
+        reference = [reference]
+    if isinstance(hypothesis, str):
+        hypothesis = [hypothesis]
+    if any(len(t) == 0 for t in reference):
+        raise ValueError("one or more references are empty strings")
+
+    # pre-process reference and hypothesis by applying transforms
+    ref_transformed = _apply_transform(
+        reference, reference_transform, is_reference=True
+    )
+    hyp_transformed = _apply_transform(
+        hypothesis, hypothesis_transform, is_reference=False
+    )
+
+    if len(ref_transformed) != len(hyp_transformed):
+        raise ValueError(
+            "After applying the transforms on the reference and hypothesis sentences, "
+            f"their lengths must match. "
+            f"Instead got {len(ref_transformed)} reference and "
+            f"{len(hyp_transformed)} hypothesis sentences."
+        )
+
+    # Change each word into a unique character in order to compute
+    # word-level levenshtein distance
+    ref_as_chars, hyp_as_chars = _word2char(ref_transformed, hyp_transformed)
+
+    # keep track of total hits, substitutions, deletions and insertions
+    # across all input sentences
+    num_hits, num_substitutions, num_deletions, num_insertions = 0, 0, 0, 0
+
+    # also keep track of the total number of words in the reference and hypothesis
+    num_rf_words, num_hp_words = 0, 0
+
+    # anf finally, keep track of the alignment between each reference and hypothesis
+    alignments = []
+
+    for reference_sentence, hypothesis_sentence in zip(ref_as_chars, hyp_as_chars):
+        # Get the required edit operations to transform reference into hypothesis
+        edit_ops = rapidfuzz.distance.Levenshtein.editops(
+            reference_sentence, hypothesis_sentence
+        )
+
+        # count the number of edits of each type
+        substitutions = sum(1 if op.tag == "replace" else 0 for op in edit_ops)
+        deletions = sum(1 if op.tag == "delete" else 0 for op in edit_ops)
+        insertions = sum(1 if op.tag == "insert" else 0 for op in edit_ops)
+        hits = len(reference_sentence) - (substitutions + deletions)
+
+        # update state
+        num_hits += hits
+        num_substitutions += substitutions
+        num_deletions += deletions
+        num_insertions += insertions
+        num_rf_words += len(reference_sentence)
+        num_hp_words += len(hypothesis_sentence)
+        alignments.append(
+            [
+                AlignmentChunk(
+                    type=op.tag,
+                    ref_start_idx=op.src_start,
+                    ref_end_idx=op.src_end,
+                    hyp_start_idx=op.dest_start,
+                    hyp_end_idx=op.dest_end,
+                )
+                for op in Opcodes.from_editops(edit_ops)
+            ]
+        )
+
+    # Compute all measures
+    S, D, I, H = num_substitutions, num_deletions, num_insertions, num_hits
+
+    wer = float(S + D + I) / float(H + S + D)
+    mer = float(S + D + I) / float(H + S + D + I)
+    wip = (
+        (float(H) / num_rf_words) * (float(H) / num_hp_words)
+        if num_hp_words >= 1
+        else 0
+    )
+    wil = 1 - wip
+
+    # return all output
+    return WordOutput(
+        references=ref_transformed,
+        hypotheses=hyp_transformed,
+        alignments=alignments,
+        wer=wer,
+        mer=mer,
+        wil=wil,
+        wip=wip,
+        hits=num_hits,
+        substitutions=num_substitutions,
+        insertions=num_insertions,
+        deletions=num_deletions,
+    )
+
+def process_words_embdiff(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+) -> WordOutput:
+    """
+    Compute the word-level levenshtein distance and alignment between one or more
+    reference and hypothesis sentences. Based on the result, multiple measures
+    can be computed, such as the word error rate.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (WordOutput): The processed reference and hypothesis sentences
+    """
+    # validate input type
+    if isinstance(reference, str):
+        reference = [reference]
+    if isinstance(hypothesis, str):
+        hypothesis = [hypothesis]
+    if any(len(t) == 0 for t in reference):
+        raise ValueError("one or more references are empty strings")
+
+    # pre-process reference and hypothesis by applying transforms
+    ref_transformed = _apply_transform(
+        reference, reference_transform, is_reference=True
+    )
+    hyp_transformed = _apply_transform(
+        hypothesis, hypothesis_transform, is_reference=False
+    )
+
+    if len(ref_transformed) != len(hyp_transformed):
+        raise ValueError(
+            "After applying the transforms on the reference and hypothesis sentences, "
+            f"their lengths must match. "
+            f"Instead got {len(ref_transformed)} reference and "
+            f"{len(hyp_transformed)} hypothesis sentences."
+        )
+
+    # Change each word into a unique character in order to compute
+    # word-level levenshtein distance
+    ref_as_chars, hyp_as_chars = _word2char(ref_transformed, hyp_transformed)
+
+    # keep track of total hits, substitutions, deletions and insertions
+    # across all input sentences
+    num_hits, num_substitutions, num_deletions, num_insertions = 0, 0, 0, 0
+
+    # also keep track of the total number of words in the reference and hypothesis
+    num_rf_words, num_hp_words = 0, 0
+
+    # anf finally, keep track of the alignment between each reference and hypothesis
+    alignments = []
+
+    for reference_sentence, hypothesis_sentence in zip(ref_as_chars, hyp_as_chars):
+        # Get the required edit operations to transform reference into hypothesis
+        edit_ops = rapidfuzz.distance.Levenshtein.editops(
+            reference_sentence, hypothesis_sentence
+        )
+
+        # count the number of edits of each type
+        substitutions = sum(1 if op.tag == "replace" else 0 for op in edit_ops)
+        deletions = sum(1 if op.tag == "delete" else 0 for op in edit_ops)
+        insertions = sum(1 if op.tag == "insert" else 0 for op in edit_ops)
+        hits = len(reference_sentence) - (substitutions + deletions)
+
+        # update state
+        num_hits += hits
+        num_substitutions += substitutions
+        num_deletions += deletions
+        num_insertions += insertions
+        num_rf_words += len(reference_sentence)
+        num_hp_words += len(hypothesis_sentence)
+        alignments.append(
+            [
+                AlignmentChunk(
+                    type=op.tag,
+                    ref_start_idx=op.src_start,
+                    ref_end_idx=op.src_end,
+                    hyp_start_idx=op.dest_start,
+                    hyp_end_idx=op.dest_end,
+                )
+                for op in Opcodes.from_editops(edit_ops)
+            ]
+        )
+
+    # Compute all measures
+    S, D, I, H = num_substitutions, num_deletions, num_insertions, num_hits
+
+    wer = float(S + D + I) / float(H + S + D)
+    mer = float(S + D + I) / float(H + S + D + I)
+    wip = (
+        (float(H) / num_rf_words) * (float(H) / num_hp_words)
+        if num_hp_words >= 1
+        else 0
+    )
+    wil = 1 - wip
+
+    # return all output
+    return WordOutput(
+        references=ref_transformed,
+        hypotheses=hyp_transformed,
+        alignments=alignments,
+        wer=wer,
+        mer=mer,
+        wil=wil,
+        wip=wip,
+        hits=num_hits,
+        substitutions=num_substitutions,
+        insertions=num_insertions,
+        deletions=num_deletions,
+    ), edit_ops
+
+
+########################################################################################
+# Implementation of character error rate
+
+
+@dataclass
+class CharacterOutput:
+    """
+    The output of calculating the character-level levenshtein distance between one or
+    more reference and hypothesis sentence(s).
+
+    Attributes:
+        references: The reference sentences
+        hypotheses: The hypothesis sentences
+        alignments: The alignment between reference and hypothesis sentences
+        cer: The character error rate
+        hits: The number of correct characters between reference and hypothesis
+              sentences
+        substitutions: The number of substitutions required to transform hypothesis
+                       sentences to reference sentences
+        insertions: The number of insertions required to transform hypothesis
+                       sentences to reference sentences
+        deletions: The number of deletions required to transform hypothesis
+                       sentences to reference sentences
+    """
+
+    # processed input data
+    references: List[List[str]]
+    hypotheses: List[List[str]]
+
+    # alignment
+    alignments: List[List[AlignmentChunk]]
+
+    # measures
+    cer: float
+
+    # stats
+    hits: int
+    substitutions: int
+    insertions: int
+    deletions: int
+
+
+def process_characters(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+) -> CharacterOutput:
+    """
+    Compute the character-level levenshtein distance and alignment between one or more
+    reference and hypothesis sentences. Based on the result, the character error rate
+    can be computed.
+
+    Note that the by default this method includes space (` `) as a
+    character over which the error rate is computed. If this is not desired, the
+    reference and hypothesis transform need to be modified.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (CharacterOutput): The processed reference and hypothesis sentences.
+
+    """
+    # make sure the transforms end with tr.ReduceToListOfListOfChars(),
+
+    # it's the same as word processing, just every word is of length 1
+    result = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return CharacterOutput(
+        references=result.references,
+        hypotheses=result.hypotheses,
+        alignments=result.alignments,
+        cer=result.wer,
+        hits=result.hits,
+        substitutions=result.substitutions,
+        insertions=result.insertions,
+        deletions=result.deletions,
+    )
+
+
+################################################################################
+# Implementation of helper methods
+
+
+def _apply_transform(
+    sentence: Union[str, List[str]],
+    transform: Union[tr.Compose, tr.AbstractTransform],
+    is_reference: bool,
+):
+    # Apply transforms. The transforms should collapse input to a
+    # list with lists of words
+    transformed_sentence = transform(sentence)
+
+    # Validate the output is a list containing lists of strings
+    if is_reference:
+        if not _is_list_of_list_of_strings(
+            transformed_sentence, require_non_empty_lists=True
+        ):
+            raise ValueError(
+                "After applying the transformation, each reference should be a "
+                "non-empty list of strings, with each string being a single word."
+            )
+    else:
+        if not _is_list_of_list_of_strings(
+            transformed_sentence, require_non_empty_lists=False
+        ):
+            raise ValueError(
+                "After applying the transformation, each hypothesis should be a "
+                "list of strings, with each string being a single word."
+            )
+
+    return transformed_sentence
+
+
+def _is_list_of_list_of_strings(x: Any, require_non_empty_lists: bool):
+    if not isinstance(x, list):
+        return False
+
+    for e in x:
+        if not isinstance(e, list):
+            return False
+
+        if require_non_empty_lists and len(e) == 0:
+            return False
+
+        if not all([isinstance(s, str) for s in e]):
+            return False
+
+    return True
+
+
+def _word2char(reference: List[List[str]], hypothesis: List[List[str]]):
+    # tokenize each word into an integer
+    vocabulary = set(chain(*reference, *hypothesis))
+
+    if "" in vocabulary:
+        raise ValueError(
+            "Empty strings cannot be a word. "
+            "Please ensure that the given transform removes empty strings."
+        )
+
+    word2char = dict(zip(vocabulary, range(len(vocabulary))))
+
+    reference_chars = [
+        "".join([chr(word2char[w]) for w in sentence]) for sentence in reference
+    ]
+    hypothesis_chars = [
+        "".join([chr(word2char[w]) for w in sentence]) for sentence in hypothesis
+    ]
+
+    return reference_chars, hypothesis_chars

my_jiwer/my_jiwer/transformations.py

@@ -0,0 +1,128 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This file is intended to provide the default transformation which need
+to be applied to input text in order to compute the WER (or similar measures).
+
+It also implements some alternative transformations which might be
+useful in specific use cases.
+"""
+
+import jiwer.transforms as tr
+
+__all__ = [
+    "wer_default",
+    "wer_contiguous",
+    "wer_standardize",
+    "wer_standardize_contiguous",
+    "cer_default",
+    "cer_contiguous",
+]
+
+########################################################################################
+# implement transformations for WER (and accompanying measures)
+
+wer_default = tr.Compose(
+    [
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This is the default transformation when using `proces_words`. Each input string will 
+have its leading and tailing white space removed. 
+Thereafter multiple spaces between words are also removed. 
+Then each string is transformed into a list with lists of strings, where each string
+is a single word.
+"""
+
+wer_contiguous = tr.Compose(
+    [
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToSingleSentence(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This is can be used instead of `wer_default` when the number of reference and hypothesis 
+sentences differ. 
+"""
+
+wer_standardize = tr.Compose(
+    [
+        tr.ToLowerCase(),
+        tr.ExpandCommonEnglishContractions(),
+        tr.RemoveKaldiNonWords(),
+        tr.RemoveWhiteSpace(replace_by_space=True),
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This transform attempts to standardize the strings by setting all characters to lower
+case, expanding common contractions, and removing non-words. Then the default operations
+are applied.  
+"""
+
+wer_standardize_contiguous = tr.Compose(
+    [
+        tr.ToLowerCase(),
+        tr.ExpandCommonEnglishContractions(),
+        tr.RemoveKaldiNonWords(),
+        tr.RemoveWhiteSpace(replace_by_space=True),
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToSingleSentence(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This is the same as `wer_standize`, but this version can be usd when the number of
+reference and hypothesis sentences differ. 
+"""
+
+########################################################################################
+# implement transformations for CER
+
+
+cer_default = tr.Compose(
+    [
+        tr.Strip(),
+        tr.ReduceToListOfListOfChars(),
+    ]
+)
+"""
+This is the default transformation when using `process_characters`. Each input string
+will  have its leading and tailing white space removed. Then each string is 
+transformed into a list with lists of strings, where each string is a single character. 
+"""
+
+cer_contiguous = tr.Compose(
+    [
+        tr.Strip(),
+        tr.ReduceToSingleSentence(),
+        tr.ReduceToListOfListOfChars(),
+    ]
+)
+"""
+This can used instead of `cer_default` when the number of reference and hypothesis 
+sentences differ.
+"""

my_jiwer/my_jiwer/transforms.py

@@ -0,0 +1,620 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+This file implements the building blocks for transforming a collection
+of input strings to the desired format in order to calculate the WER of CER.
+
+In principle, for word error rate calculations, every string of a sentence needs to be
+collapsed into a list of strings, where each string is a *single* word.
+This is done with [transforms.ReduceToListOfListOfWords][].
+A composition of multiple transformations must therefore *always* end with
+[transforms.ReduceToListOfListOfWords][].
+
+For the character error rate, every string of a sentence also needs to be collapsed into
+a list of strings, but here each string is a *single* character.
+This is done with [transforms.ReduceToListOfListOfChars][]. Similarly, a
+composition of multiple transformations must therefore also always end with
+[transforms.ReduceToListOfListOfChars][].
+"""
+
+import sys
+import functools
+import re
+import string
+import unicodedata
+
+from typing import Union, List, Mapping
+
+
+__all__ = [
+    "AbstractTransform",
+    "Compose",
+    "ExpandCommonEnglishContractions",
+    "RemoveEmptyStrings",
+    "ReduceToListOfListOfWords",
+    "ReduceToListOfListOfChars",
+    "ReduceToSingleSentence",
+    "RemoveKaldiNonWords",
+    "RemoveMultipleSpaces",
+    "RemovePunctuation",
+    "RemoveSpecificWords",
+    "RemoveWhiteSpace",
+    "Strip",
+    "SubstituteRegexes",
+    "SubstituteWords",
+    "ToLowerCase",
+    "ToUpperCase",
+]
+
+
+class AbstractTransform(object):
+    """
+    The base class of a Transform.
+    """
+
+    def __call__(self, sentences: Union[str, List[str]]):
+        """
+        Transforms one or more strings.
+
+        Args:
+            sentences: The strings to transform.
+
+        Returns:
+            (Union[str, List[str]]): The transformed strings.
+
+        """
+        if isinstance(sentences, str):
+            return self.process_string(sentences)
+        elif isinstance(sentences, list):
+            return self.process_list(sentences)
+        else:
+            raise ValueError(
+                "input {} was expected to be a string or list of strings".format(
+                    sentences
+                )
+            )
+
+    def process_string(self, s: str):
+        raise NotImplementedError()
+
+    def process_list(self, inp: List[str]):
+        return [self.process_string(s) for s in inp]
+
+
+class Compose(object):
+    """
+    Chain multiple transformations back-to-back to create a pipeline combining multiple
+    transformations.
+
+    Note that each transformation needs to end with either `ReduceToListOfListOfWords`
+    or `ReduceToListOfListOfChars`, depending on whether word error rate,
+    or character error rate is desired.
+
+    Example:
+        ```python3
+        import jiwer
+
+        jiwer.Compose([
+            jiwer.RemoveMultipleSpaces(),
+            jiwer.ReduceToListOfListOfWords()
+        ])
+        ```
+    """
+
+    def __init__(self, transforms: List[AbstractTransform]):
+        """
+
+        Args:
+            transforms: The list of transformations to chain.
+        """
+        self.transforms = transforms
+
+    def __call__(self, text):
+        for tr in self.transforms:
+            text = tr(text)
+
+        return text
+
+
+class BaseRemoveTransform(AbstractTransform):
+    def __init__(self, tokens_to_remove: List[str], replace_token=""):
+        self.tokens_to_remove = tokens_to_remove
+        self.replace_token = replace_token
+
+    def process_string(self, s: str):
+        for w in self.tokens_to_remove:
+            s = s.replace(w, self.replace_token)
+
+        return s
+
+    def process_list(self, inp: List[str]):
+        return [self.process_string(s) for s in inp]
+
+
+class ReduceToListOfListOfWords(AbstractTransform):
+    """
+    Transforms a single input sentence, or a list of input sentences, into
+    a list with lists of words, which is the expected format for calculating the
+    edit operations between two input sentences on a word-level.
+
+    A sentence is assumed to be a string, where words are delimited by a token
+    (such as ` `, space). Each string is expected to contain only a single sentence.
+    Empty strings (no output) are removed for the list.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["hi", "this is an example"]
+
+        print(jiwer.ReduceToListOfListOfWords()(sentences))
+        # prints: [['hi'], ['this', 'is', 'an, 'example']]
+        ```
+    """
+
+    def __init__(self, word_delimiter: str = " "):
+        """
+        Args:
+            word_delimiter: the character which delimits words. Default is ` ` (space).
+        """
+        self.word_delimiter = word_delimiter
+
+    def process_string(self, s: str):
+        return [[w for w in s.split(self.word_delimiter) if len(w) >= 1]]
+
+    def process_list(self, inp: List[str]):
+        sentence_collection = []
+
+        for sentence in inp:
+            list_of_words = self.process_string(sentence)[0]
+
+            sentence_collection.append(list_of_words)
+
+        if len(sentence_collection) == 0:
+            return [[]]
+
+        return sentence_collection
+
+
+class ReduceToListOfListOfChars(AbstractTransform):
+    """
+    Transforms a single input sentence, or a list of input sentences, into
+    a list with lists of characters, which is the expected format for calculating the
+    edit operations between two input sentences on a character-level.
+
+    A sentence is assumed to be a string. Each string is expected to contain only a
+    single sentence.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["hi", "this is an example"]
+
+        print(jiwer.ReduceToListOfListOfChars()(sentences))
+        # prints: [['h', 'i'], ['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', 'n', ' ', 'e', 'x', 'a', 'm', 'p', 'l', 'e']]
+        ```
+    """
+
+    def process_string(self, s: str):
+        return [[w for w in s]]
+
+    def process_list(self, inp: List[str]):
+        sentence_collection = []
+
+        for sentence in inp:
+            list_of_words = self.process_string(sentence)[0]
+
+            sentence_collection.append(list_of_words)
+
+        if len(sentence_collection) == 0:
+            return [[]]
+
+        return sentence_collection
+
+
+class ReduceToSingleSentence(AbstractTransform):
+    """
+    Transforms multiple sentences into a single sentence.
+    This operation can be useful when the number of reference and hypothesis sentences
+    differ, and you want to do a minimal alignment over these lists.
+    Note that this creates an invariance: `wer([a, b], [a, b])` might not be equal to
+    `wer([b, a], [b, a])`.
+
+    Example:
+        ```python3
+        import jiwer
+
+        sentences = ["hi", "this is an example"]
+
+        print(jiwer.ReduceToSingleSentence()(sentences))
+        # prints: ['hi this is an example']
+        ```
+    """
+
+    def __init__(self, word_delimiter: str = " "):
+        """
+        :param word_delimiter: the character which delimits words. Default is ` ` (space).
+        """
+        self.word_delimiter = word_delimiter
+
+    def process_string(self, s: str):
+        return s
+
+    def process_list(self, inp: List[str]):
+        filtered_inp = [i for i in inp if len(i) >= 1]
+
+        if len(filtered_inp) == 0:
+            return []
+        else:
+            return ["{}".format(self.word_delimiter).join(filtered_inp)]
+
+
+class SubstituteRegexes(AbstractTransform):
+    """
+    Transform strings by substituting substrings matching regex expressions into
+    another substring.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["is the world doomed or loved?", "edibles are allegedly cultivated"]
+
+        # note: the regex string "\b(\w+)ed\b", matches every word ending in 'ed',
+        # and "\1" stands for the first group ('\w+). It therefore removes 'ed' in every match.
+        print(jiwer.SubstituteRegexes({r"doom": r"sacr", r"\b(\w+)ed\b": r"\1"})(sentences))
+
+        # prints: ["is the world sacr or lov?", "edibles are allegedly cultivat"]
+        ```
+    """
+
+    def __init__(self, substitutions: Mapping[str, str]):
+        """
+
+        Args:
+            substitutions: a mapping of regex expressions to replacement strings.
+        """
+        self.substitutions = substitutions
+
+    def process_string(self, s: str):
+        for key, value in self.substitutions.items():
+            s = re.sub(key, value, s)
+
+        return s
+
+
+class SubstituteWords(AbstractTransform):
+    """
+    This transform can be used to replace a word into another word.
+    Note that the whole word is matched. If the word you're attempting to substitute
+    is a substring of another word it will not be affected.
+    For example, if you're substituting `foo` into `bar`, the word `foobar` will NOT
+    be substituted into `barbar`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["you're pretty", "your book", "foobar"]
+
+        print(jiwer.SubstituteWords({"pretty": "awesome", "you": "i", "'re": " am", 'foo': 'bar'})(sentences))
+
+        # prints: ["i am awesome", "your book", "foobar"]
+        ```
+
+    """
+
+    def __init__(self, substitutions: Mapping[str, str]):
+        """
+        Args:
+            substitutions: A mapping of words to replacement words.
+        """
+        self.substitutions = substitutions
+
+    def process_string(self, s: str):
+        for key, value in self.substitutions.items():
+            s = re.sub(r"\b{}\b".format(re.escape(key)), value, s)
+
+        return s
+
+
+class RemoveSpecificWords(SubstituteWords):
+    """
+    Can be used to filter out certain words.
+    As words are replaced with a ` ` character, make sure to that
+    `RemoveMultipleSpaces`, `Strip()` and `RemoveEmptyStrings` are present
+    in the composition _after_ `RemoveSpecificWords`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["yhe awesome", "the apple is not a pear", "yhe"]
+
+        print(jiwer.RemoveSpecificWords(["yhe", "the", "a"])(sentences))
+        # prints: ['  awesome', '  apple is not   pear', ' ']
+        # note the extra spaces
+        ```
+    """
+
+    def __init__(self, words_to_remove: List[str]):
+        """
+        Args:
+            words_to_remove: List of words to remove.
+        """
+        mapping = {word: " " for word in words_to_remove}
+
+        super().__init__(mapping)
+
+
+class RemoveWhiteSpace(BaseRemoveTransform):
+    """
+    This transform filters out white space characters.
+    Note that by default space (` `) is also removed, which will make it impossible to
+    split a sentence into a list of words by using `ReduceToListOfListOfWords` or
+    `ReduceToSingleSentence`.
+    This can be prevented by replacing all whitespace with the space character.
+    If so, make sure that `jiwer.RemoveMultipleSpaces`,
+    `Strip()` and `RemoveEmptyStrings` are present in the composition _after_
+    `RemoveWhiteSpace`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["this is an example", "hello world\t"]
+
+        print(jiwer.RemoveWhiteSpace()(sentences))
+        # prints: ["thisisanexample", "helloworld"]
+
+        print(jiwer.RemoveWhiteSpace(replace_by_space=True)(sentences))
+        # prints: ["this is an example", "hello world  "]
+        # note the trailing spaces
+        ```
+    """
+
+    def __init__(self, replace_by_space: bool = False):
+        """
+
+        Args:
+            replace_by_space: every white space character is replaced with a space (` `)
+        """
+        characters = [c for c in string.whitespace]
+
+        if replace_by_space:
+            replace_token = " "
+        else:
+            replace_token = ""
+
+        super().__init__(characters, replace_token=replace_token)
+
+
+@functools.lru_cache(1)
+def _get_punctuation_characters():
+    """Compute the punctuation characters only once and memoize."""
+    codepoints = range(sys.maxunicode + 1)
+    punctuation = set(
+        chr(i) for i in codepoints if unicodedata.category(chr(i)).startswith("P")
+    )
+    return punctuation
+
+
+class RemovePunctuation(BaseRemoveTransform):
+    """
+    This transform filters out punctuation. The punctuation characters are defined as
+    all unicode characters whose category name starts with `P`.
+    See [here](https://www.unicode.org/reports/tr44/#General_Category_Values) for more
+    information.
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["this is an example!", "hello. goodbye"]
+
+        print(jiwer.RemovePunctuation()(sentences))
+        # prints: ['this is an example', "hello goodbye"]
+        ```
+    """
+
+    def __init__(self):
+        punctuation_characters = _get_punctuation_characters()
+        super().__init__(punctuation_characters)
+
+
+class RemoveMultipleSpaces(AbstractTransform):
+    """
+    Filter out multiple spaces between words.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["this is   an   example ", "  hello goodbye  ", "  "]
+
+        print(jiwer.RemoveMultipleSpaces()(sentences))
+        # prints: ['this is an example ', " hello goodbye ", " "]
+        # note that there are still trailing spaces
+        ```
+
+    """
+
+    def process_string(self, s: str):
+        return re.sub(r"\s\s+", " ", s)
+
+    def process_list(self, inp: List[str]):
+        return [self.process_string(s) for s in inp]
+
+
+class Strip(AbstractTransform):
+    """
+    Removes all leading and trailing spaces.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = [" this is an example ", "  hello goodbye  ", "  "]
+
+        print(jiwer.Strip()(sentences))
+        # prints: ['this is an example', "hello goodbye", ""]
+        # note that there is an empty string left behind which might need to be cleaned up
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.strip()
+
+
+class RemoveEmptyStrings(AbstractTransform):
+    """
+    Remove empty strings from a list of strings.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["", "this is an example", " ",  "                "]
+
+        print(jiwer.RemoveEmptyStrings()(sentences))
+        # prints: ['this is an example']
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.strip()
+
+    def process_list(self, inp: List[str]):
+        return [s for s in inp if self.process_string(s) != ""]
+
+
+class ExpandCommonEnglishContractions(AbstractTransform):
+    """
+    Replace common contractions such as `let's` to `let us`.
+
+    Currently, this method will perform the following replacements. Note that `␣` is
+     used to indicate a space (` `) to get around markdown rendering constrains.
+
+    | Contraction   | transformed into |
+    | ------------- |:----------------:|
+    | `won't`       | `␣will not`      |
+    | `can't`       | `␣can not`       |
+    | `let's`       | `␣let us`        |
+    | `n't`         | `␣not`           |
+    | `'re`         | `␣are`           |
+    | `'s`          | `␣is`            |
+    | `'d`          | `␣would`         |
+    | `'ll`         | `␣will`          |
+    | `'t`          | `␣not`           |
+    | `'ve`         | `␣have`          |
+    | `'m`          | `␣am`            |
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["she'll make sure you can't make it", "let's party!"]
+
+        print(jiwer.ExpandCommonEnglishContractions()(sentences))
+        # prints: ["she will make sure you can not make it", "let us party!"]
+        ```
+
+    """
+
+    def process_string(self, s: str):
+        # definitely a non exhaustive list
+
+        # specific words
+        s = re.sub(r"won't", "will not", s)
+        s = re.sub(r"can\'t", "can not", s)
+        s = re.sub(r"let\'s", "let us", s)
+
+        # general attachments
+        s = re.sub(r"n\'t", " not", s)
+        s = re.sub(r"\'re", " are", s)
+        s = re.sub(r"\'s", " is", s)
+        s = re.sub(r"\'d", " would", s)
+        s = re.sub(r"\'ll", " will", s)
+        s = re.sub(r"\'t", " not", s)
+        s = re.sub(r"\'ve", " have", s)
+        s = re.sub(r"\'m", " am", s)
+
+        return s
+
+
+class ToLowerCase(AbstractTransform):
+    """
+    Convert every character into lowercase.
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["You're PRETTY"]
+
+        print(jiwer.ToLowerCase()(sentences))
+
+        # prints: ["you're pretty"]
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.lower()
+
+
+class ToUpperCase(AbstractTransform):
+    """
+    Convert every character to uppercase.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["You're amazing"]
+
+        print(jiwer.ToUpperCase()(sentences))
+
+        # prints: ["YOU'RE AMAZING"]
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.upper()
+
+
+class RemoveKaldiNonWords(AbstractTransform):
+    """
+    Remove any word between `[]` and `<>`. This can be useful when working
+    with hypotheses from the Kaldi project, which can output non-words such as
+    `[laugh]` and `<unk>`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["you <unk> like [laugh]"]
+
+        print(jiwer.RemoveKaldiNonWords()(sentences))
+
+        # prints: ["you  like "]
+        # note the extra spaces
+        ```
+    """
+
+    def process_string(self, s: str):
+        return re.sub(r"[<\[][^>\]]*[>\]]", "", s)

my_jiwer/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "jiwer"
+version = "3.0.2"
+description = "Evaluate your speech-to-text system with similarity measures such as word error rate (WER)"
+authors = ["Nik Vaessen <nikvaes@gmail.com>"]
+readme = "README.md"
+license = "Apache-2.0"
+repository = "https://github.com/jitsi/jiwer"
+include = ["LICENCE"]
+
+[tool.poetry.dependencies]
+python = "^3.7"
+rapidfuzz = "2.13.7"
+click = "^8.1.3"
+
+[tool.poetry.group.dev.dependencies]
+black = "^22.8.0"
+pytest = "7.1.3"
+pytest-benchmark = "^3.4.1"
+flake8 = "5.0.4"
+
+[tool.poetry.scripts]
+jiwer = "jiwer.cli:cli"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

my_jiwer/tests/test_alignment.py

@@ -0,0 +1,225 @@
+import unittest
+import jiwer
+
+
+class TestAlignmentVisualizationWords(unittest.TestCase):
+    def test_insertion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a ****\n"
+            "HYP: this is a test\n"
+            "                  I\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a", "this is a test"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+        pass
+
+    def test_deletion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a test\n"
+            "HYP: this is a ****\n"
+            "                  D\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a test", "this is a"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_substitution(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this  is a test\n"
+            "HYP: this was a test\n"
+            "            S       \n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a test", "this was a test"),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_all_three(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this  is a ***** test of skill\n"
+            "HYP: this was a messy test ** *****\n"
+            "            S       I       D     D\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a test of skill", "this was a messy test"),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_show_measures(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this test will have a high word error rate\n"
+            "HYP:   no   it will  not * **** **** ***** ****\n"
+            "        S    S         S D    D    D     D    D\n"
+            "\n"
+            "number of sentences: 1\n"
+            "substitutions=3 deletions=5 insertions=0 hits=1\n"
+            "\n"
+            "mer=88.89%\n"
+            "wil=97.22%\n"
+            "wip=2.78%\n"
+            "wer=88.89%\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words(
+                "this test will  have a high word error rate", "no it will not"
+            ),
+            show_measures=True,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_empty_hypothesis(self):
+        correct_alignment = "sentence 1\n" "REF: empty\n" "HYP: *****\n" "         D\n"
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("empty", ""), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_multiple_sentences(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: one\n"
+            "HYP:   1\n"
+            "       S\n"
+            "\n"
+            "sentence 2\n"
+            "REF: two\n"
+            "HYP:   2\n"
+            "       S\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words(["one", "two"], ["1", "2"]),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_skip_correct(self):
+        correct_alignment = (
+            "sentence 2\n"
+            "REF: one\n"
+            "HYP:   1\n"
+            "       S\n"
+            "\n"
+            "sentence 3\n"
+            "REF: two\n"
+            "HYP:   2\n"
+            "       S\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words(
+                ["perfect", "one", "two", "three"], ["perfect", "1", "2", "three"]
+            ),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+
+class TestAlignmentVisualizationCharacters(unittest.TestCase):
+    def test_insertion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a*****\n"
+            "HYP: this is a test\n"
+            "              IIIII\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("this is a", "this is a test"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+        pass
+
+    def test_deletion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a test\n"
+            "HYP: this is a*****\n"
+            "              DDDDD\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("this is a test", "this is a"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_substitution(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a test\n"
+            "HYP: this iz a test\n"
+            "           S       \n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("this is a test", "this iz a test"),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_all_three(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this *is a tes*t of skill\n"
+            "HYP: this was a messy te*st***\n"
+            "          IS    S  IS SSD SDDD\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters(
+                "this is a test of skill", "this was a messy test"
+            ),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_show_measures(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this test will  have a high word error rate\n"
+            "HYP: no** i**t will n*************o***********t*\n"
+            "     SSDD SDD       SDDDDDDDDDDDDD DDDDDDDDDDD D\n"
+            "\n"
+            "number of sentences: 1\n"
+            "substitutions=4 deletions=29 insertions=0 hits=10\n"
+            "\n"
+            "cer=76.74%\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters(
+                "this test will  have a high word error rate", "no it will not"
+            ),
+            show_measures=True,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_empty_hypothesis(self):
+        correct_alignment = "sentence 1\n" "REF: empty\n" "HYP: *****\n" "     DDDDD\n"
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("empty", ""), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_multiple_sentences(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: one\n"
+            "HYP: 1**\n"
+            "     SDD\n"
+            "\n"
+            "sentence 2\n"
+            "REF: two\n"
+            "HYP: 2**\n"
+            "     SDD\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters(["one", "two"], ["1", "2"]),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)

my_jiwer/tests/test_cer.py

@@ -0,0 +1,135 @@
+import unittest
+import pytest
+
+import jiwer
+
+from .test_measures import assert_dict_almost_equal
+
+
+class TestCERInputMethods(unittest.TestCase):
+    def test_input_ref_string_hyp_string(self):
+        cases = [
+            ("This is a test", "This is a test", 0 / 14),
+            ("This is a test", "", 14 / 14),
+            ("This is a test", "This test", 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_string_hyp_list(self):
+        cases = [
+            ("This is a test", ["This is a test"], 0 / 14),
+            ("This is a test", [""], 14 / 14),
+            ("This is a test", ["This test"], 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_string(self):
+        cases = [
+            (["This is a test"], "This is a test", 0 / 14),
+            (["This is a test"], "", 14 / 14),
+            (["This is a test"], "This test", 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_list(self):
+        cases = [
+            (["This is a test"], ["This is a test"], 0 / 14),
+            (["This is a test"], [""], 14 / 14),
+            (["This is a test"], ["This test"], 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_fail_on_different_sentence_length(self):
+        def callback():
+            jiwer.cer(["hello", "this", "sentence", "is fractured"], ["this sentence"])
+
+        self.assertRaises(ValueError, callback)
+
+    def test_fail_on_empty_reference(self):
+        def callback():
+            jiwer.cer("", "test")
+
+        self.assertRaises(ValueError, callback)
+
+    def test_known_values(self):
+        # Taken from the "From WER and RIL to MER and WIL" paper, for link see README.md
+        cases = [
+            (
+                "X",
+                "X",
+                0,
+            ),
+            (
+                "X",
+                "X X Y Y",
+                6,
+            ),
+            (
+                "X Y X",
+                "X Z",
+                3 / 5,
+            ),
+            (
+                "X",
+                "Y",
+                1,
+            ),
+            (
+                "X",
+                "Y Z",
+                3,
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_permutations_invariance(self):
+        cases = [
+            (
+                ["i", "am i good"],
+                ["i am", "i good"],
+                0.6,
+            ),
+            (
+                ["am i good", "i"],
+                [
+                    "i good",
+                    "i am",
+                ],
+                0.6,
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_return_dict(self):
+        # TODO: remove unit test once deprecated
+        with pytest.deprecated_call():
+            return_dict = jiwer.cer(
+                ["i", "am i good"], ["i am", "y good"], return_dict=True
+            )
+
+        assert_dict_almost_equal(
+            self,
+            return_dict,
+            {
+                "cer": 0.7,
+                "hits": 6,
+                "substitutions": 1,
+                "deletions": 3,
+                "insertions": 3,
+            },
+            delta=1e-16,
+        )
+
+    def _apply_test_on(self, cases):
+        for ref, hyp, correct_cer in cases:
+            cer = jiwer.cer(reference=ref, hypothesis=hyp)
+
+            self.assertTrue(isinstance(cer, float))
+            if isinstance(cer, float):
+                self.assertAlmostEqual(cer, correct_cer, delta=1e-16)

my_jiwer/tests/test_measures.py

@@ -0,0 +1,410 @@
+import unittest
+
+import pytest
+
+import jiwer
+
+
+def all_m(wer, mer, wil):
+    return {
+        "wer": wer,
+        "mer": mer,
+        "wip": 1 - wil,
+        "wil": wil,
+    }
+
+
+def to_measure_dict(x: jiwer.WordOutput):
+    return {"wer": x.wer, "mer": x.mer, "wip": x.wip, "wil": x.wil}
+
+
+def assert_dict_almost_equal(
+    test_case: unittest.TestCase, a, b, places=None, msg=None, delta=None
+):
+    test_case.assertIsInstance(a, dict)
+    test_case.assertIsInstance(b, dict)
+    test_case.assertEqual(set(a.keys()), set(b.keys()))
+
+    for k in a.keys():
+        test_case.assertAlmostEqual(a[k], b[k], places=places, msg=msg, delta=delta)
+
+
+class TestMeasuresContiguousSentencesTransform(unittest.TestCase):
+    def test_input_ref_string_hyp_string(self):
+        cases = [
+            ("This is a test", "This is a test", all_m(0, 0, 0)),
+            ("This is a test", "", all_m(1, 1, 1)),
+            ("This is a test", "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_string_hyp_list(self):
+        cases = [
+            ("This is a test", ["This is a test"], all_m(0, 0, 0)),
+            ("This is a test", [""], all_m(1, 1, 1)),
+            ("This is a test", ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_string(self):
+        cases = [
+            (["This is a test"], "This is a test", all_m(0, 0, 0)),
+            (["This is a test"], "", all_m(1, 1, 1)),
+            (["This is a test"], "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_list(self):
+        cases = [
+            (["This is a test"], ["This is a test"], all_m(0, 0, 0)),
+            (["This is a test"], [""], all_m(1, 1, 1)),
+            (["This is a test"], ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_different_sentence_length_equal_type(self):
+        cases = [
+            (
+                ["hello", "this", "sentence", "is fractured"],
+                ["this sentence"],
+                all_m(0.6, 0.6, 0.6),
+            ),
+            (
+                "i am a short ground truth",
+                "i am a considerably longer and very much incorrect hypothesis",
+                all_m(7 / 6, 0.7, 0.85),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_different_sentence_length_unequaL_type(self):
+        reference = [
+            "i like monthy python",
+            "what do you mean african or european swallow",
+        ]
+        hypothesis = ["i like", "python", "what you mean", "or swallow"]
+        x = jiwer.process_words(
+            reference,
+            hypothesis,
+            reference_transform=jiwer.transformations.wer_contiguous,
+            hypothesis_transform=jiwer.transformations.wer_contiguous,
+        )
+        x_dict = to_measure_dict(x)
+
+        # is equivalent to
+
+        reference = "i like monthy python what do you mean african or european swallow"
+        hypothesis = "i like python what you mean or swallow"
+        y = jiwer.process_words(
+            reference,
+            hypothesis,
+            reference_transform=jiwer.transformations.wer_contiguous,
+            hypothesis_transform=jiwer.transformations.wer_contiguous,
+        )
+        y_dict = to_measure_dict(y)
+
+        assert_dict_almost_equal(self, x_dict, y_dict, delta=1e-9)
+
+    def test_fail_on_empty_reference(self):
+        for method in [
+            jiwer.wer,
+            jiwer.wil,
+            jiwer.wip,
+            jiwer.mer,
+            jiwer.compute_measures,
+        ]:
+
+            def callback():
+                method("", "test")
+
+            self.assertRaises(ValueError, callback)
+
+    def test_known_values(self):
+        # Taken from the "From WER and RIL to MER and WIL" paper, for link see README.md
+        cases = [
+            (
+                "X",
+                "X",
+                all_m(0, 0, 0),
+            ),
+            (
+                "X",
+                "X X Y Y",
+                all_m(3, 0.75, 0.75),
+            ),
+            (
+                "X Y X",
+                "X Z",
+                all_m(2 / 3, 2 / 3, 5 / 6),
+            ),
+            (
+                "X",
+                "Y",
+                all_m(1, 1, 1),
+            ),
+            (
+                "X",
+                "Y Z",
+                all_m(2, 1, 1),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_permutations_variance(self):
+        cases = [
+            (
+                ["i", "am i good"],
+                ["i am", "i good"],
+                all_m(0.0, 0.0, 0),
+            ),
+            (
+                ["am i good", "i"],
+                [
+                    "i good",
+                    "i am",
+                ],
+                all_m(0.5, 0.4, 7 / 16),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def _apply_test_on(self, cases):
+        for ref, hyp, correct_measures in cases:
+            output = jiwer.process_words(
+                reference=ref,
+                hypothesis=hyp,
+                reference_transform=jiwer.transformations.wer_contiguous,
+                hypothesis_transform=jiwer.transformations.wer_contiguous,
+            )
+            output_dict = to_measure_dict(output)
+
+            assert_dict_almost_equal(self, output_dict, correct_measures, delta=1e-16)
+
+
+class TestMeasuresDefaultTransform(unittest.TestCase):
+    def test_input_gt_string_h_string(self):
+        cases = [
+            ("This is a test", "This is a test", all_m(0, 0, 0)),
+            ("This is a test", "", all_m(1, 1, 1)),
+            ("This is a test", "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_gt_string_h_list(self):
+        cases = [
+            ("This is a test", ["This is a test"], all_m(0, 0, 0)),
+            ("This is a test", [""], all_m(1, 1, 1)),
+            ("This is a test", ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_gt_list_h_string(self):
+        cases = [
+            (["This is a test"], "This is a test", all_m(0, 0, 0)),
+            (["This is a test"], "", all_m(1, 1, 1)),
+            (["This is a test"], "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_gt_list_h_list(self):
+        cases = [
+            (["This is a test"], ["This is a test"], all_m(0, 0, 0)),
+            (["This is a test"], [""], all_m(1, 1, 1)),
+            (["This is a test"], ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_fail_on_different_sentence_length(self):
+        for method in [
+            jiwer.process_words,
+            jiwer.wer,
+            jiwer.wil,
+            jiwer.wip,
+            jiwer.mer,
+            jiwer.compute_measures,
+        ]:
+
+            def callback():
+                method(["hello", "this", "sentence", "is fractured"], ["this sentence"])
+
+            self.assertRaises(ValueError, callback)
+
+    def test_fail_on_empty_reference(self):
+        for method in [
+            jiwer.process_words,
+            jiwer.wer,
+            jiwer.wil,
+            jiwer.wip,
+            jiwer.mer,
+            jiwer.compute_measures,
+        ]:
+
+            def callback():
+                method("", "test")
+
+            self.assertRaises(ValueError, callback)
+
+    def test_known_values(self):
+        # Taken from the "From WER and RIL to MER and WIL" paper, for link see README.md
+        cases = [
+            (
+                "X",
+                "X",
+                all_m(0, 0, 0),
+            ),
+            (
+                "X",
+                "X X Y Y",
+                all_m(3, 0.75, 0.75),
+            ),
+            (
+                "X Y X",
+                "X Z",
+                all_m(2 / 3, 2 / 3, 5 / 6),
+            ),
+            (
+                "X",
+                "Y",
+                all_m(1, 1, 1),
+            ),
+            (
+                "X",
+                "Y Z",
+                all_m(2, 1, 1),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_permutations_invariance(self):
+        cases = [
+            (
+                ["i", "am i good"],
+                ["i am", "i good"],
+                all_m(0.5, 0.4, 7 / 16),
+            ),
+            (
+                ["am i good", "i"],
+                [
+                    "i good",
+                    "i am",
+                ],
+                all_m(0.5, 0.4, 7 / 16),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def _apply_test_on(self, cases):
+        for ref, hyp, correct_measures in cases:
+            output = jiwer.process_words(reference=ref, hypothesis=hyp)
+            output_dict = to_measure_dict(output)
+
+            assert_dict_almost_equal(self, output_dict, correct_measures, delta=1e-16)
+
+            with pytest.deprecated_call():
+                output = jiwer.compute_measures(truth=ref, hypothesis=hyp)
+                output_dict = {
+                    "wer": output["wer"],
+                    "mer": output["mer"],
+                    "wil": output["wil"],
+                    "wip": output["wip"],
+                }
+                assert_dict_almost_equal(
+                    self, output_dict, correct_measures, delta=1e-16
+                )
+
+        self._apply_test_deprecated_truth(cases)
+
+    def _apply_test_deprecated_truth(self, cases):
+        with pytest.deprecated_call():
+            for ref, hyp, correct_measures in cases:
+                output_dict = {}
+                for key, method in [
+                    ("wer", jiwer.wer),
+                    ("mer", jiwer.mer),
+                    ("wil", jiwer.wil),
+                    ("wip", jiwer.wip),
+                ]:
+                    output = method(truth=ref, hypothesis=hyp)
+                    output_dict[key] = output
+
+                assert_dict_almost_equal(
+                    self, output_dict, correct_measures, delta=1e-16
+                )
+
+    def test_deprecated_truth_and_ref(self):
+        for key, method in [
+            ("wer", jiwer.wer),
+            ("mer", jiwer.mer),
+            ("wil", jiwer.wil),
+            ("wip", jiwer.wip),
+            ("cer", jiwer.cer),
+        ]:
+            with pytest.raises(ValueError):
+                method(truth="ref", reference="truth", hypothesis="huh")
+                method()
+                method(truth="only truth")
+                method(reference="only ref")
+                method(hypothesis="only hypothesis")
+
+    def test_deprecated_truth_and_ref_with_transform(self):
+        wer_transform = jiwer.Compose(
+            [
+                jiwer.ToLowerCase(),
+                jiwer.RemoveMultipleSpaces(),
+                jiwer.Strip(),
+                jiwer.ReduceToListOfListOfWords(),
+            ]
+        )
+        cer_transform = jiwer.Compose(
+            [
+                jiwer.ToLowerCase(),
+                jiwer.RemoveMultipleSpaces(),
+                jiwer.Strip(),
+                jiwer.ReduceToListOfListOfChars(),
+            ]
+        )
+
+        for key, method in [
+            ("wer", jiwer.wer),
+            ("mer", jiwer.mer),
+            ("wil", jiwer.wil),
+            ("wip", jiwer.wip),
+            ("cer", jiwer.cer),
+        ]:
+            if key == "cer":
+                tr = cer_transform
+            else:
+                tr = wer_transform
+
+            result = method(
+                truth="This is a short Sentence with a few Words with upper and Lower cases",
+                hypothesis="His is a short Sentence with a few Words with upper and Lower cases",
+                truth_transform=tr,
+                hypothesis_transform=tr,
+            )
+            result_same = method(
+                reference="This is a short Sentence with a few Words with upper and Lower cases",
+                hypothesis="His is a short Sentence with a few Words with upper and Lower cases",
+                reference_transform=tr,
+                hypothesis_transform=tr,
+            )
+            self.assertAlmostEqual(result, result_same)
+
+
+def test_deprecate_compute_measures():
+    # TODO: remove once deprecated
+    with pytest.deprecated_call():
+        jiwer.compute_measures("no more", "compute_measures")

my_jiwer/tests/test_speed.py

@@ -0,0 +1,24 @@
+from jiwer import wer
+
+
+def perform_computation(num_sentences):
+    truth = ["this is a speed test" for _ in range(0, num_sentences)]
+    hypo = ["this is not a speed test" for _ in range(0, num_sentences)]
+
+    wer(truth, hypo)
+
+
+def test_speed_n1(benchmark):
+    benchmark(perform_computation, 1)
+
+
+def test_speed_n10(benchmark):
+    benchmark(perform_computation, 10)
+
+
+def test_speed_n100(benchmark):
+    benchmark(perform_computation, 100)
+
+
+def test_speed_n1000(benchmark):
+    benchmark(perform_computation, 1000)

my_jiwer/tests/test_transforms.py

@@ -0,0 +1,337 @@
+import unittest
+
+from jiwer.transforms import *
+from jiwer.transforms import ReduceToListOfListOfChars
+
+
+def _apply_test_on(self: unittest.TestCase, tr, cases):
+    for inp, outp in cases:
+        self.assertEqual(outp, tr(inp))
+
+
+class TestReduceToSingleSentence(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ("this is a test", "this is a test"),
+            ("", ""),
+            (["this is one", "is two"], ["this is one is two"]),
+            (["one", "two", "three", "", "five six"], ["one two three five six"]),
+            ([""], []),
+        ]
+
+        _apply_test_on(self, ReduceToSingleSentence(), cases)
+
+    def test_delimiter(self):
+        cases = [
+            ("this_is_a_test", "this_is_a_test"),
+            ("", ""),
+            (["this_is_one", "is_two"], ["this_is_one_is_two"]),
+            (["one", "two", "three", "", "five_six"], ["one_two_three_five_six"]),
+            ([""], []),
+        ]
+
+        _apply_test_on(self, ReduceToSingleSentence("_"), cases)
+
+
+class TestReduceToListOfListOfWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ("this is a test", [["this", "is", "a", "test"]]),
+            ("", [[]]),
+            (["this is one", "is two"], [["this", "is", "one"], ["is", "two"]]),
+            (
+                ["one", "two", "three", "", "five six"],
+                [["one"], ["two"], ["three"], [], ["five", "six"]],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfWords(), cases)
+
+    def test_delimiter(self):
+        cases = [
+            ("this_is_a_test", [["this", "is", "a", "test"]]),
+            ("", [[]]),
+            (["this_is_one", "is_two"], [["this", "is", "one"], ["is", "two"]]),
+            (
+                ["one", "two", "three", "", "five_six"],
+                [["one"], ["two"], ["three"], [], ["five", "six"]],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfWords("_"), cases)
+
+
+class TestReduceToListOfListOfChars(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (
+                "this is a test",
+                [
+                    [
+                        "t",
+                        "h",
+                        "i",
+                        "s",
+                        " ",
+                        "i",
+                        "s",
+                        " ",
+                        "a",
+                        " ",
+                        "t",
+                        "e",
+                        "s",
+                        "t",
+                    ]
+                ],
+            ),
+            ("", [[]]),
+            (
+                ["this is one", "is two"],
+                [
+                    ["t", "h", "i", "s", " ", "i", "s", " ", "o", "n", "e"],
+                    ["i", "s", " ", "t", "w", "o"],
+                ],
+            ),
+            (
+                ["one", "two", "three", "", "five six"],
+                [
+                    ["o", "n", "e"],
+                    ["t", "w", "o"],
+                    ["t", "h", "r", "e", "e"],
+                    [],
+                    ["f", "i", "v", "e", " ", "s", "i", "x"],
+                ],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfChars(), cases)
+
+    def test_delimiter(self):
+        cases = [
+            (
+                "this_is_a_test",
+                [
+                    [
+                        "t",
+                        "h",
+                        "i",
+                        "s",
+                        "_",
+                        "i",
+                        "s",
+                        "_",
+                        "a",
+                        "_",
+                        "t",
+                        "e",
+                        "s",
+                        "t",
+                    ]
+                ],
+            ),
+            ("", [[]]),
+            (
+                ["this_is_one", "is_two"],
+                [
+                    ["t", "h", "i", "s", "_", "i", "s", "_", "o", "n", "e"],
+                    ["i", "s", "_", "t", "w", "o"],
+                ],
+            ),
+            (
+                ["one", "two", "three", "", "five_six"],
+                [
+                    ["o", "n", "e"],
+                    ["t", "w", "o"],
+                    ["t", "h", "r", "e", "e"],
+                    [],
+                    ["f", "i", "v", "e", "_", "s", "i", "x"],
+                ],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfChars(), cases)
+
+
+class TestRemoveSpecificWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["yhe about that bug"], ["  about that bug"]),
+            (["yeah about that bug"], ["  about that bug"]),
+            (["one bug"], ["one bug"]),
+            (["yhe", "about", "bug"], [" ", "about", "bug"]),
+            (["yeah", "about", "bug"], [" ", "about", "bug"]),
+            (["one", "bug"], ["one", "bug"]),
+            (["yhe about bug"], ["  about bug"]),
+            (["yeah about bug"], ["  about bug"]),
+            (["about bug yhe"], ["about bug  "]),
+            (["one bug"], ["one bug"]),
+            (["he asked a helpful question"], ["  asked   helpful question"]),
+            (["normal sentence"], ["normal sentence"]),
+            (["yhe awesome", "  awesome"]),
+            (["the apple is not a pear", "  apple is not   pear"]),
+            (["yhe", " "]),
+        ]
+
+        _apply_test_on(
+            self, RemoveSpecificWords(["yhe", "yeah", "a", "he", "the"]), cases
+        )
+
+
+class TestRemoveWhiteSpace(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["this is an example", "thisisanexample"]),
+            (["hello\tworld\n\r", "helloworld"]),
+        ]
+
+        _apply_test_on(self, RemoveWhiteSpace(), cases)
+
+    def test_replace_by_space(self):
+        cases = [
+            (["this is an example", "this is an example"]),
+            (["hello\tworld\n\r", "hello world  "]),
+        ]
+
+        _apply_test_on(self, RemoveWhiteSpace(replace_by_space=True), cases)
+
+
+class TestRemovePunctuation(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["this is an example!", "this is an example"]),
+            (["hello. goodbye", "hello goodbye"]),
+            (["this sentence has no punctuation", "this sentence has no punctuation"]),
+        ]
+
+        _apply_test_on(self, RemovePunctuation(), cases)
+
+    def test_non_ascii_punctuation(self):
+        cases = [
+            (["word༆’'", "word"]),
+            (["‘no’", "no"]),
+            (["“yes”", "yes"]),
+        ]
+
+        _apply_test_on(self, RemovePunctuation(), cases)
+
+
+class TestRemoveMultipleSpaces(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["this is   an   example "], ["this is an example "]),
+            (["  hello goodbye  "], [" hello goodbye "]),
+            (["  "], [" "]),
+        ]
+
+        _apply_test_on(self, RemoveMultipleSpaces(), cases)
+
+    pass
+
+
+class TestSubstituteWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["you're pretty"], ["i am awesome"]),
+            (["your book"], ["your book"]),
+            (["foobar"], ["foobar"]),
+        ]
+
+        _apply_test_on(
+            self,
+            SubstituteWords(
+                {"pretty": "awesome", "you": "i", "'re": " am", "foo": "bar"}
+            ),
+            cases,
+        )
+
+
+class TestSubstituteRegexes(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["is the world doomed or loved?"], ["is the world sacr or lov?"]),
+            (["the sun is loved"], ["the sun is lov"]),
+            (["edibles are allegedly cultivated"], ["edibles are allegedly cultivat"]),
+        ]
+
+        _apply_test_on(
+            self,
+            SubstituteRegexes({r"doom": r"sacr", r"\b(\w+)ed\b": r"\1"}),
+            cases,
+        )
+
+
+class TestStrip(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ([" this is an example "], ["this is an example"]),
+            (["  hello goodbye  "], ["hello goodbye"]),
+            (["  "], [""]),
+            (["                       "], [""]),
+        ]
+
+        _apply_test_on(self, Strip(), cases)
+
+
+class TestRemoveEmptyStrings(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ([""], []),
+            (["this is an example"], ["this is an example"]),
+            ([" "], []),
+            (["                "], []),
+        ]
+
+        _apply_test_on(self, RemoveEmptyStrings(), cases)
+
+
+class TestExpandCommonEnglishContractions(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (
+                ["she'll make sure you can't make it"],
+                ["she will make sure you can not make it"],
+            ),
+            (["let's party!"], ["let us party!"]),
+        ]
+
+        _apply_test_on(self, ExpandCommonEnglishContractions(), cases)
+
+
+class TestToLowerCase(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["You're PRETTY"], ["you're pretty"]),
+        ]
+
+        _apply_test_on(self, ToLowerCase(), cases)
+
+
+class TestToUpperCase(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["You're amazing"], ["YOU'RE AMAZING"]),
+        ]
+
+        _apply_test_on(self, ToUpperCase(), cases)
+
+
+class TestRemoveKaldiNonWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["you <unk> like [laugh]"], ["you  like "]),
+        ]
+
+        _apply_test_on(self, RemoveKaldiNonWords(), cases)