Datasets:

PeacefulData
/

Robust-HyPoradise

@@ -1,63 +0,0 @@
-# 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

jiwer/.github/workflows/pythonpublish.yml DELETED Viewed

@@ -1,33 +0,0 @@
-# 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

jiwer/.gitignore DELETED Viewed

@@ -1,28 +0,0 @@
-# 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/

jiwer/.mailmap DELETED Viewed

@@ -1,6 +0,0 @@
-# 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>

jiwer/LICENSE DELETED Viewed

@@ -1,201 +0,0 @@
-                                 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.

jiwer/README.md DELETED Viewed

@@ -1,55 +0,0 @@
-# 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)_

jiwer/docs/cli.md DELETED Viewed

@@ -1,29 +0,0 @@
-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.

jiwer/docs/gen_ref_pages.py DELETED Viewed

@@ -1,28 +0,0 @@
-"""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())

jiwer/docs/index.md DELETED Viewed

@@ -1,31 +0,0 @@
-# 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
-```

jiwer/docs/requirements.txt DELETED Viewed

@@ -1,5 +0,0 @@
-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

jiwer/docs/usage.md DELETED Viewed

@@ -1,111 +0,0 @@
-# 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.

jiwer/jiwer/__init__.py DELETED Viewed

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

jiwer/jiwer/__pycache__/__init__.cpython-38.pyc DELETED Viewed

Binary file (281 Bytes)

jiwer/jiwer/__pycache__/alignment.cpython-38.pyc DELETED Viewed

Binary file (4.97 kB)

jiwer/jiwer/__pycache__/measures.cpython-38.pyc DELETED Viewed

Binary file (11.2 kB)

jiwer/jiwer/__pycache__/process.cpython-38.pyc DELETED Viewed

Binary file (12.2 kB)

jiwer/jiwer/__pycache__/transformations.cpython-38.pyc DELETED Viewed

Binary file (1.19 kB)

jiwer/jiwer/__pycache__/transforms.cpython-38.pyc DELETED Viewed

Binary file (21.8 kB)

jiwer/jiwer/alignment.py DELETED Viewed

@@ -1,185 +0,0 @@
-#
-# 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"

jiwer/jiwer/cli.py DELETED Viewed

@@ -1,133 +0,0 @@
-#
-# 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()

jiwer/jiwer/measures.py DELETED Viewed

@@ -1,488 +0,0 @@
-#
-# 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

jiwer/jiwer/process.py DELETED Viewed

@@ -1,525 +0,0 @@
-#
-# 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

jiwer/jiwer/transformations.py DELETED Viewed

@@ -1,128 +0,0 @@
-#
-# 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.
-"""

jiwer/jiwer/transforms.py DELETED Viewed

@@ -1,620 +0,0 @@
-#
-# 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)

jiwer/mkdocs.yml DELETED Viewed

@@ -1,47 +0,0 @@
-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

jiwer/pyproject.toml DELETED Viewed

@@ -1,27 +0,0 @@
-[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"

jiwer/tests/__init__.py DELETED Viewed

File without changes

jiwer/tests/test_alignment.py DELETED Viewed

@@ -1,225 +0,0 @@
-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)

jiwer/tests/test_cer.py DELETED Viewed

@@ -1,135 +0,0 @@
-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)

jiwer/tests/test_measures.py DELETED Viewed

@@ -1,410 +0,0 @@
-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")

jiwer/tests/test_speed.py DELETED Viewed

@@ -1,24 +0,0 @@
-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)

jiwer/tests/test_transforms.py DELETED Viewed

@@ -1,337 +0,0 @@
-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)