Upload folder using huggingface_hub

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/lastfailed

@@ -0,0 +1 @@
+{}

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,36 @@
+[
+  "tests/test_awwer.py::TestAlignWordsDP::test_deletion",
+  "tests/test_awwer.py::TestAlignWordsDP::test_empty_hyp",
+  "tests/test_awwer.py::TestAlignWordsDP::test_empty_ref",
+  "tests/test_awwer.py::TestAlignWordsDP::test_identical",
+  "tests/test_awwer.py::TestAlignWordsDP::test_insertion",
+  "tests/test_awwer.py::TestAlignWordsDP::test_substitution",
+  "tests/test_awwer.py::TestCalculateAWWER::test_all_deletions",
+  "tests/test_awwer.py::TestCalculateAWWER::test_high_weight_error",
+  "tests/test_awwer.py::TestCalculateAWWER::test_none_on_empty_ref",
+  "tests/test_awwer.py::TestCalculateAWWER::test_perfect_match",
+  "tests/test_awwer.py::TestCalculateAWWERComponents::test_breakdown",
+  "tests/test_awwer.py::TestCalculateAWWERFromString::test_json_weights",
+  "tests/test_awwer.py::TestCleanText::test_basic_normalization",
+  "tests/test_awwer.py::TestCleanText::test_empty_input",
+  "tests/test_awwer.py::TestCleanText::test_nan_handling",
+  "tests/test_awwer.py::TestCleanText::test_punctuation_removal",
+  "tests/test_awwer.py::TestCleanText::test_whitespace_collapse",
+  "tests/test_awwer.py::TestGetWordWeight::test_case_insensitive",
+  "tests/test_awwer.py::TestGetWordWeight::test_default",
+  "tests/test_awwer.py::TestGetWordWeight::test_empty",
+  "tests/test_awwer.py::TestGetWordWeight::test_exact_match",
+  "tests/test_awwer.py::TestParseWordWeights::test_empty",
+  "tests/test_awwer.py::TestParseWordWeights::test_invalid_json",
+  "tests/test_awwer.py::TestParseWordWeights::test_json_string",
+  "tests/test_awwer.py::TestParseWordWeights::test_list_input",
+  "tests/test_awwer.py::TestStandardMetrics::test_cer_nonzero",
+  "tests/test_awwer.py::TestStandardMetrics::test_cer_perfect",
+  "tests/test_awwer.py::TestStandardMetrics::test_mer_bounds",
+  "tests/test_awwer.py::TestStandardMetrics::test_mer_perfect",
+  "tests/test_awwer.py::TestStandardMetrics::test_nan_handling",
+  "tests/test_awwer.py::TestStandardMetrics::test_wer_all_wrong",
+  "tests/test_awwer.py::TestStandardMetrics::test_wer_empty_hyp",
+  "tests/test_awwer.py::TestStandardMetrics::test_wer_none_on_empty_ref",
+  "tests/test_awwer.py::TestStandardMetrics::test_wer_perfect"
+]

LICENSE

@@ -0,0 +1,190 @@
+                                 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 the 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 the 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 any 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
+
+   Copyright 2025 Digital Green
+
+   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.

README.md

@@ -0,0 +1,120 @@
+# Agri AWWER — Agriculture-Weighted Word Error Rate Evaluation Toolkit
+
+A lightweight Python toolkit for evaluating Automatic Speech Recognition (ASR) systems in agricultural domains. Provides the **Agriculture-Weighted Word Error Rate (AWWER)** metric alongside standard metrics (WER, CER, MER).
+
+AWWER penalises errors on domain-critical agricultural terms more heavily than errors on general vocabulary, giving a more realistic picture of how well an ASR system serves agricultural applications.
+
+## Installation
+
+```bash
+# From HuggingFace (recommended)
+pip install git+https://huggingface.co/DigiGreen/Agri_AWWER_Toolkit
+
+# For improved WER/CER/MER via jiwer
+pip install "agri-awwer[jiwer]"
+```
+
+**Zero required dependencies** — the toolkit works out of the box with only the Python standard library. `jiwer` is optional and used automatically when available for standard metrics.
+
+## Quick Start
+
+### AWWER — Domain-Weighted Error Rate
+
+```python
+from agri_awwer import calculate_awwer
+
+# Define domain word weights (1-4 scale)
+weights = {
+    "gehun": 4,    # wheat — core agriculture term
+    "keet": 4,     # pest
+    "mitti": 3,    # soil
+    "barish": 3,   # rain
+    "gaon": 1,     # village — general vocabulary
+}
+
+reference  = "gehun mein keet laga hai"
+hypothesis = "gaon mein keet laga hai"
+
+awwer = calculate_awwer(reference, hypothesis, weights)
+print(f"AWWER: {awwer:.3f}")
+# gehun→gaon is a weight-4 error, so AWWER > standard WER
+```
+
+### Standard Metrics
+
+```python
+from agri_awwer import calculate_wer, calculate_cer, calculate_mer
+
+ref = "gehun mein keet laga hai"
+hyp = "gaon mein keet laga hai"
+
+print(f"WER: {calculate_wer(ref, hyp):.3f}")
+print(f"CER: {calculate_cer(ref, hyp):.3f}")
+print(f"MER: {calculate_mer(ref, hyp):.3f}")
+```
+
+### Detailed AWWER Breakdown
+
+```python
+from agri_awwer import calculate_awwer_components
+
+result = calculate_awwer_components(reference, hypothesis, weights)
+print(f"AWWER:          {result['awwer']:.3f}")
+print(f"Substitutions:  {result['n_substitutions']}")
+print(f"Deletions:      {result['n_deletions']}")
+print(f"Insertions:     {result['n_insertions']}")
+print(f"High-weight errors: {result['high_weight_errors']}")
+```
+
+### Parse Weights from JSON
+
+```python
+import json
+from agri_awwer import calculate_awwer_from_string
+
+weights_json = json.dumps([["gehun", 4], ["keet", 4], ["mitti", 3]])
+awwer = calculate_awwer_from_string(ref, hyp, weights_json)
+```
+
+## Weight Scale
+
+| Weight | Category | Examples |
+|--------|----------|----------|
+| **4** | Core agriculture terms | Crop names, pests, farming practices |
+| **3** | Strongly agriculture-related | Soil types, weather, planting seasons |
+| **2** | Indirectly related | Quantities, measurement units, locations |
+| **1** | General vocabulary | Default for words not in the lexicon |
+
+## Language Support
+
+Built-in text normalization for:
+- **Hindi** (default) — chandrabindu, visarga, nukta removal
+- **Telugu** — candrabindu, visarga removal
+- **Odia** — candrabindu, visarga, nukta, isshar removal
+
+Pass the `language` parameter to any metric function:
+
+```python
+calculate_awwer(ref, hyp, weights, language="telugu")
+calculate_wer(ref, hyp, language="odia")
+```
+
+## Related Resources
+
+- **Paper**: *Benchmarking Automatic Speech Recognition for Indian Languages in Agricultural Contexts*
+- **Dataset**: [Agri STT Benchmarking Dataset](https://huggingface.co/datasets/DigiGreen/Agri_STT_Benchmarking_Dataset) — 10,864 audio-transcript pairs across Hindi, Telugu, and Odia
+
+## Citation
+
+```bibtex
+@misc{digigreen2025awwer,
+  title   = {Agri {AWWER}: Agriculture-Weighted Word Error Rate Evaluation Toolkit},
+  author  = {{Digital Green}},
+  year    = {2025},
+  url     = {https://huggingface.co/DigiGreen/Agri_AWWER_Toolkit},
+}
+```
+
+## License
+
+Apache 2.0

agri_awwer.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: agri-awwer
+Version: 0.1.0
+Summary: Agriculture-Weighted Word Error Rate (AWWER) evaluation toolkit for domain-specific ASR assessment
+Author-email: Digital Green <tech@digitalgreen.org>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://huggingface.co/DigiGreen/Agri_AWWER_Toolkit
+Project-URL: Paper, https://huggingface.co/datasets/DigiGreen/Agri_STT_Benchmarking_Dataset
+Keywords: asr,speech-recognition,agriculture,evaluation,wer,metrics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: jiwer
+Requires-Dist: jiwer>=3.0; extra == "jiwer"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# Agri AWWER — Agriculture-Weighted Word Error Rate Evaluation Toolkit
+
+A lightweight Python toolkit for evaluating Automatic Speech Recognition (ASR) systems in agricultural domains. Provides the **Agriculture-Weighted Word Error Rate (AWWER)** metric alongside standard metrics (WER, CER, MER).
+
+AWWER penalises errors on domain-critical agricultural terms more heavily than errors on general vocabulary, giving a more realistic picture of how well an ASR system serves agricultural applications.
+
+## Installation
+
+```bash
+# From HuggingFace (recommended)
+pip install git+https://huggingface.co/DigiGreen/Agri_AWWER_Toolkit
+
+# For improved WER/CER/MER via jiwer
+pip install "agri-awwer[jiwer]"
+```
+
+**Zero required dependencies** — the toolkit works out of the box with only the Python standard library. `jiwer` is optional and used automatically when available for standard metrics.
+
+## Quick Start
+
+### AWWER — Domain-Weighted Error Rate
+
+```python
+from agri_awwer import calculate_awwer
+
+# Define domain word weights (1-4 scale)
+weights = {
+    "gehun": 4,    # wheat — core agriculture term
+    "keet": 4,     # pest
+    "mitti": 3,    # soil
+    "barish": 3,   # rain
+    "gaon": 1,     # village — general vocabulary
+}
+
+reference  = "gehun mein keet laga hai"
+hypothesis = "gaon mein keet laga hai"
+
+awwer = calculate_awwer(reference, hypothesis, weights)
+print(f"AWWER: {awwer:.3f}")
+# gehun→gaon is a weight-4 error, so AWWER > standard WER
+```
+
+### Standard Metrics
+
+```python
+from agri_awwer import calculate_wer, calculate_cer, calculate_mer
+
+ref = "gehun mein keet laga hai"
+hyp = "gaon mein keet laga hai"
+
+print(f"WER: {calculate_wer(ref, hyp):.3f}")
+print(f"CER: {calculate_cer(ref, hyp):.3f}")
+print(f"MER: {calculate_mer(ref, hyp):.3f}")
+```
+
+### Detailed AWWER Breakdown
+
+```python
+from agri_awwer import calculate_awwer_components
+
+result = calculate_awwer_components(reference, hypothesis, weights)
+print(f"AWWER:          {result['awwer']:.3f}")
+print(f"Substitutions:  {result['n_substitutions']}")
+print(f"Deletions:      {result['n_deletions']}")
+print(f"Insertions:     {result['n_insertions']}")
+print(f"High-weight errors: {result['high_weight_errors']}")
+```
+
+### Parse Weights from JSON
+
+```python
+import json
+from agri_awwer import calculate_awwer_from_string
+
+weights_json = json.dumps([["gehun", 4], ["keet", 4], ["mitti", 3]])
+awwer = calculate_awwer_from_string(ref, hyp, weights_json)
+```
+
+## Weight Scale
+
+| Weight | Category | Examples |
+|--------|----------|----------|
+| **4** | Core agriculture terms | Crop names, pests, farming practices |
+| **3** | Strongly agriculture-related | Soil types, weather, planting seasons |
+| **2** | Indirectly related | Quantities, measurement units, locations |
+| **1** | General vocabulary | Default for words not in the lexicon |
+
+## Language Support
+
+Built-in text normalization for:
+- **Hindi** (default) — chandrabindu, visarga, nukta removal
+- **Telugu** — candrabindu, visarga removal
+- **Odia** — candrabindu, visarga, nukta, isshar removal
+
+Pass the `language` parameter to any metric function:
+
+```python
+calculate_awwer(ref, hyp, weights, language="telugu")
+calculate_wer(ref, hyp, language="odia")
+```
+
+## Related Resources
+
+- **Paper**: *Benchmarking Automatic Speech Recognition for Indian Languages in Agricultural Contexts*
+- **Dataset**: [Agri STT Benchmarking Dataset](https://huggingface.co/datasets/DigiGreen/Agri_STT_Benchmarking_Dataset) — 10,864 audio-transcript pairs across Hindi, Telugu, and Odia
+
+## Citation
+
+```bibtex
+@misc{digigreen2025awwer,
+  title   = {Agri {AWWER}: Agriculture-Weighted Word Error Rate Evaluation Toolkit},
+  author  = {{Digital Green}},
+  year    = {2025},
+  url     = {https://huggingface.co/DigiGreen/Agri_AWWER_Toolkit},
+}
+```
+
+## License
+
+Apache 2.0

agri_awwer.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+agri_awwer/__init__.py
+agri_awwer/awwer.py
+agri_awwer/wer.py
+agri_awwer.egg-info/PKG-INFO
+agri_awwer.egg-info/SOURCES.txt
+agri_awwer.egg-info/dependency_links.txt
+agri_awwer.egg-info/requires.txt
+agri_awwer.egg-info/top_level.txt
+tests/test_awwer.py

agri_awwer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agri_awwer.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[dev]
+pytest>=7.0
+
+[jiwer]
+jiwer>=3.0

agri_awwer.egg-info/top_level.txt

@@ -0,0 +1 @@
+agri_awwer

agri_awwer/__init__.py

@@ -0,0 +1,35 @@
+"""
+Agri AWWER — Agriculture-Weighted Word Error Rate Evaluation Toolkit.
+
+Provides domain-weighted ASR evaluation metrics for agricultural contexts.
+"""
+
+from .awwer import (
+    calculate_awwer,
+    calculate_awwer_from_string,
+    calculate_awwer_components,
+    parse_word_weights,
+    get_word_weight,
+    align_words_dp,
+)
+from .wer import (
+    calculate_wer,
+    calculate_cer,
+    calculate_mer,
+    calculate_metrics_for_sample,
+    clean_text,
+)
+
+__all__ = [
+    "calculate_awwer",
+    "calculate_awwer_from_string",
+    "calculate_awwer_components",
+    "parse_word_weights",
+    "get_word_weight",
+    "align_words_dp",
+    "calculate_wer",
+    "calculate_cer",
+    "calculate_mer",
+    "calculate_metrics_for_sample",
+    "clean_text",
+]

agri_awwer/awwer.py

@@ -0,0 +1,370 @@
+"""
+Agriculture-Weighted Word Error Rate (AWWER) Calculator.
+
+AWWER gives more weight to agriculture-specific terms in error calculation.
+This provides a domain-relevant metric for agricultural ASR evaluation.
+
+Weight scale:
+- Weight 4: Core agriculture terms (crops, pests, practices)
+- Weight 3: Strongly agriculture-related (soil, weather, timing)
+- Weight 2: Indirectly related (quantities, locations)
+- Weight 1: General vocabulary
+
+CRITICAL: Uses Dynamic Programming alignment (not position-based matching)
+to correctly identify substitutions, deletions, and insertions.
+"""
+
+import json
+import math
+import re
+from typing import Optional, Dict, List, Tuple
+
+from .wer import clean_text
+
+
+def _isna(value) -> bool:
+    """Check if a value is NA/NaN/None without requiring pandas."""
+    if value is None:
+        return True
+    if isinstance(value, float) and math.isnan(value):
+        return True
+    if isinstance(value, (str, bytes, int)):
+        return False
+    try:
+        import pandas as pd
+        result = pd.isna(value)
+        if isinstance(result, bool):
+            return result
+        return False
+    except (ImportError, TypeError, ValueError):
+        return False
+
+
+def parse_word_weights(word_weights_str: str) -> Dict[str, float]:
+    """
+    Parse word_weights column from JSON string.
+
+    Expected format: [["word1", weight1], ["word2", weight2], ...]
+
+    Args:
+        word_weights_str: JSON string of word weights
+
+    Returns:
+        Dictionary mapping words to weights
+    """
+    if not word_weights_str or _isna(word_weights_str):
+        return {}
+
+    try:
+        if isinstance(word_weights_str, str):
+            weights_list = json.loads(word_weights_str)
+        else:
+            weights_list = word_weights_str
+
+        result = {}
+        for item in weights_list:
+            if isinstance(item, (list, tuple)) and len(item) >= 2:
+                word = str(item[0]).strip()
+                weight = float(item[1])
+                result[word] = weight
+
+        return result
+    except (json.JSONDecodeError, ValueError, TypeError):
+        return {}
+
+
+def get_word_weight(word: str, weights: Dict[str, float], default_weight: float = 1.0) -> float:
+    """
+    Get weight for a single word.
+
+    Tries exact match first, then normalized match.
+
+    Args:
+        word: Word to look up
+        weights: Dictionary of word weights
+        default_weight: Default weight if word not found
+
+    Returns:
+        Weight value (1-4)
+    """
+    if not word or not weights:
+        return default_weight
+
+    # Try exact match
+    if word in weights:
+        return weights[word]
+
+    # Try lowercase match
+    word_lower = word.lower()
+    for w, weight in weights.items():
+        if w.lower() == word_lower:
+            return weight
+
+    # Try with punctuation removed
+    word_clean = re.sub(r'[^\w]', '', word)
+    for w, weight in weights.items():
+        w_clean = re.sub(r'[^\w]', '', w)
+        if w_clean.lower() == word_clean.lower():
+            return weight
+
+    return default_weight
+
+
+def align_words_dp(ref_words: List[str], hyp_words: List[str]) -> List[Tuple]:
+    """
+    Align reference and hypothesis words using dynamic programming.
+
+    This is the CORRECT alignment algorithm that uses Levenshtein-style DP
+    to find optimal alignment. DO NOT replace with position-based matching.
+
+    Returns list of operations:
+        ('match', ref_idx, hyp_idx),
+        ('sub', ref_idx, hyp_idx),
+        ('ins', None, hyp_idx),
+        ('del', ref_idx, None)
+
+    Args:
+        ref_words: Reference word list
+        hyp_words: Hypothesis word list
+
+    Returns:
+        List of alignment operations
+    """
+    n, m = len(ref_words), len(hyp_words)
+
+    # DP table
+    dp = [[float('inf')] * (m + 1) for _ in range(n + 1)]
+    dp[0][0] = 0
+
+    # Initialize first row and column
+    for j in range(1, m + 1):
+        dp[0][j] = j  # All insertions
+    for i in range(1, n + 1):
+        dp[i][0] = i  # All deletions
+
+    # Fill DP table
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            ref_w, hyp_w = ref_words[i-1], hyp_words[j-1]
+
+            if ref_w == hyp_w:
+                dp[i][j] = dp[i-1][j-1]  # Match
+            else:
+                # Substitution, deletion, or insertion
+                dp[i][j] = min(
+                    dp[i-1][j-1] + 1,  # Substitution
+                    dp[i-1][j] + 1,     # Deletion
+                    dp[i][j-1] + 1      # Insertion
+                )
+
+    # Backtrack to get alignment
+    alignment = []
+    i, j = n, m
+
+    while i > 0 or j > 0:
+        if i > 0 and j > 0:
+            ref_w, hyp_w = ref_words[i-1], hyp_words[j-1]
+
+            if ref_w == hyp_w and dp[i][j] == dp[i-1][j-1]:
+                alignment.append(('match', i-1, j-1))
+                i -= 1
+                j -= 1
+                continue
+            elif dp[i][j] == dp[i-1][j-1] + 1:
+                alignment.append(('sub', i-1, j-1))
+                i -= 1
+                j -= 1
+                continue
+
+        if i > 0 and dp[i][j] == dp[i-1][j] + 1:
+            alignment.append(('del', i-1, None))
+            i -= 1
+        elif j > 0 and dp[i][j] == dp[i][j-1] + 1:
+            alignment.append(('ins', None, j-1))
+            j -= 1
+        else:
+            break
+
+    alignment.reverse()
+    return alignment
+
+
+def calculate_awwer(reference: str, hypothesis: str,
+                    word_weights: Dict[str, float],
+                    language: str = 'hindi',
+                    default_weight: float = 1.0) -> Optional[float]:
+    """
+    Calculate Agriculture-Weighted Word Error Rate.
+
+    AWWER = sum(weights of error words) / sum(weights of all reference words)
+
+    Uses DP alignment to correctly identify errors.
+
+    Args:
+        reference: Reference text
+        hypothesis: Hypothesis text
+        word_weights: Dictionary mapping words to weights (1-4)
+        language: Language for normalization
+        default_weight: Default weight for words not in dictionary
+
+    Returns:
+        AWWER value (0 = perfect, higher = worse) or None
+    """
+    if not reference or _isna(reference):
+        return None
+
+    # Clean texts
+    ref_clean = clean_text(str(reference), language)
+    hyp_clean = clean_text(str(hypothesis) if hypothesis and not _isna(hypothesis) else '', language)
+
+    ref_words = ref_clean.split() if ref_clean else []
+    hyp_words = hyp_clean.split() if hyp_clean else []
+
+    if not ref_words:
+        return None
+
+    # Get alignment using DP
+    alignment = align_words_dp(ref_words, hyp_words)
+
+    # Calculate total reference weight
+    total_weight = sum(get_word_weight(w, word_weights, default_weight) for w in ref_words)
+
+    # Calculate error weight
+    error_weight = 0.0
+
+    for op in alignment:
+        op_type = op[0]
+
+        if op_type == 'match':
+            continue  # No error
+        elif op_type == 'sub':
+            # Substitution - use reference word weight
+            ref_idx = op[1]
+            ref_word = ref_words[ref_idx]
+            error_weight += get_word_weight(ref_word, word_weights, default_weight)
+        elif op_type == 'del':
+            # Deletion - use reference word weight
+            ref_idx = op[1]
+            ref_word = ref_words[ref_idx]
+            error_weight += get_word_weight(ref_word, word_weights, default_weight)
+        elif op_type == 'ins':
+            # Insertion - count as error but with lower weight
+            error_weight += default_weight * 0.5  # Half weight for insertions
+
+    if total_weight == 0:
+        return None
+
+    return error_weight / total_weight
+
+
+def calculate_awwer_components(reference: str, hypothesis: str,
+                               word_weights: Dict[str, float],
+                               language: str = 'hindi') -> Dict:
+    """
+    Calculate AWWER with detailed breakdown.
+
+    Args:
+        reference: Reference text
+        hypothesis: Hypothesis text
+        word_weights: Dictionary mapping words to weights
+        language: Language for normalization
+
+    Returns:
+        Dictionary with AWWER and breakdown details including:
+        - awwer: The AWWER score
+        - total_ref_weight: Sum of all reference word weights
+        - error_weight: Sum of error weights
+        - n_substitutions, n_deletions, n_insertions: Error counts
+        - high_weight_errors: List of weight 3-4 errors
+    """
+    result = {
+        'awwer': None,
+        'total_ref_weight': 0,
+        'error_weight': 0,
+        'n_substitutions': 0,
+        'n_deletions': 0,
+        'n_insertions': 0,
+        'high_weight_errors': [],
+    }
+
+    if not reference or _isna(reference):
+        return result
+
+    # Clean texts
+    ref_clean = clean_text(str(reference), language)
+    hyp_clean = clean_text(str(hypothesis) if hypothesis and not _isna(hypothesis) else '', language)
+
+    ref_words = ref_clean.split() if ref_clean else []
+    hyp_words = hyp_clean.split() if hyp_clean else []
+
+    if not ref_words:
+        return result
+
+    # Get alignment using DP
+    alignment = align_words_dp(ref_words, hyp_words)
+
+    # Calculate metrics
+    total_weight = sum(get_word_weight(w, word_weights, 1.0) for w in ref_words)
+    result['total_ref_weight'] = total_weight
+
+    error_weight = 0.0
+
+    for op in alignment:
+        op_type = op[0]
+
+        if op_type == 'match':
+            continue
+        elif op_type == 'sub':
+            result['n_substitutions'] += 1
+            ref_idx = op[1]
+            hyp_idx = op[2]
+            ref_word = ref_words[ref_idx]
+            hyp_word = hyp_words[hyp_idx]
+            weight = get_word_weight(ref_word, word_weights, 1.0)
+            error_weight += weight
+            if weight >= 3:
+                result['high_weight_errors'].append({
+                    'type': 'substitution',
+                    'ref_word': ref_word,
+                    'hyp_word': hyp_word,
+                    'weight': weight
+                })
+        elif op_type == 'del':
+            result['n_deletions'] += 1
+            ref_idx = op[1]
+            ref_word = ref_words[ref_idx]
+            weight = get_word_weight(ref_word, word_weights, 1.0)
+            error_weight += weight
+            if weight >= 3:
+                result['high_weight_errors'].append({
+                    'type': 'deletion',
+                    'ref_word': ref_word,
+                    'weight': weight
+                })
+        elif op_type == 'ins':
+            result['n_insertions'] += 1
+            error_weight += 0.5  # Half weight for insertions
+
+    result['error_weight'] = error_weight
+    result['awwer'] = error_weight / total_weight if total_weight > 0 else None
+
+    return result
+
+
+def calculate_awwer_from_string(reference: str, hypothesis: str,
+                                 word_weights_str: str,
+                                 language: str = 'hindi') -> Optional[float]:
+    """
+    Calculate AWWER from word_weights JSON string (convenience function).
+
+    Args:
+        reference: Reference text
+        hypothesis: Hypothesis text
+        word_weights_str: JSON string of word weights
+        language: Language for normalization
+
+    Returns:
+        AWWER value or None
+    """
+    weights = parse_word_weights(word_weights_str)
+    return calculate_awwer(reference, hypothesis, weights, language)

agri_awwer/wer.py

@@ -0,0 +1,352 @@
+"""
+Word Error Rate (WER) and Character Error Rate (CER) Calculation.
+
+Clean implementation from scratch using only reference and hypothesis texts.
+"""
+
+import math
+import re
+import unicodedata
+from typing import Optional, List
+
+try:
+    from jiwer import wer as jiwer_wer, cer as jiwer_cer
+    JIWER_AVAILABLE = True
+except ImportError:
+    JIWER_AVAILABLE = False
+
+try:
+    from jiwer import mer as jiwer_mer
+    JIWER_MER_AVAILABLE = True
+except ImportError:
+    JIWER_MER_AVAILABLE = False
+
+
+def _isna(value) -> bool:
+    """Check if a value is NA/NaN/None without requiring pandas."""
+    if value is None:
+        return True
+    if isinstance(value, float) and math.isnan(value):
+        return True
+    try:
+        import pandas as pd
+        return pd.isna(value)
+    except (ImportError, TypeError, ValueError):
+        return False
+
+
+# Punctuation patterns to remove
+PUNCTUATION_PATTERN = re.compile(r'[।,?!।॥,.;:"\'\-\(\)\[\]{}॰…\u0964\u0965]')
+MULTI_SPACE_PATTERN = re.compile(r'\s+')
+
+# Language-specific normalization patterns
+# Hindi diacritics that may cause matching issues
+HINDI_NORMALIZE = {
+    '\u0901': '',      # chandrabindu (ँ) - remove
+    '\u0903': '',      # visarga (ः) - remove
+    '\u093C': '',      # nukta (़) - remove
+    '\u093D': '',      # avagraha (ऽ) - remove
+    '\u0902': '\u0902',  # anusvara (ं) - keep but could normalize
+}
+
+# Telugu diacritics
+TELUGU_NORMALIZE = {
+    '\u0C01': '',      # candrabindu - remove
+    '\u0C02': '\u0C02',  # anusvara (sunna ం) - keep
+    '\u0C03': '',      # visarga (ః) - remove
+    '\u0C3C': '',      # nukta - remove (if present)
+}
+
+# Odia diacritics
+ODIA_NORMALIZE = {
+    '\u0B01': '',      # candrabindu (ଁ) - remove
+    '\u0B02': '\u0B02',  # anusvara (ଂ) - keep
+    '\u0B03': '',      # visarga (ଃ) - remove
+    '\u0B3C': '',      # nukta - remove
+    '\u0B70': '',      # isshar (୰) - remove
+}
+
+# Combined normalization map
+LANGUAGE_NORMALIZE_MAPS = {
+    'hindi': HINDI_NORMALIZE,
+    'telugu': TELUGU_NORMALIZE,
+    'odia': ODIA_NORMALIZE,
+}
+
+def _apply_language_normalization(text: str, language: str) -> str:
+    """Apply language-specific character normalization."""
+    norm_map = LANGUAGE_NORMALIZE_MAPS.get(language, {})
+    for char, replacement in norm_map.items():
+        text = text.replace(char, replacement)
+    return text
+
+
+def clean_text(text: str, language: str = 'hindi') -> str:
+    """
+    Clean and normalize text for WER/CER calculation.
+
+    Applies language-specific normalization for diacritics that commonly
+    cause mismatches (chandrabindu, visarga, nukta, etc.).
+
+    Args:
+        text: Input text
+        language: Language for normalization ('hindi', 'telugu', 'odia')
+
+    Returns:
+        Cleaned text ready for comparison
+    """
+    if not text or not isinstance(text, str):
+        return ""
+
+    if _isna(text):
+        return ""
+
+    # Unicode normalization (NFC canonical form)
+    result = unicodedata.normalize('NFC', text)
+
+    # Apply language-specific diacritic normalization
+    result = _apply_language_normalization(result, language)
+
+    # Lowercase
+    result = result.lower()
+
+    # Remove punctuation
+    result = PUNCTUATION_PATTERN.sub(' ', result)
+
+    # Remove remaining special characters (but keep Indic scripts)
+    result = re.sub(r'[^\w\s]', '', result)
+
+    # Collapse multiple spaces
+    result = MULTI_SPACE_PATTERN.sub(' ', result).strip()
+
+    return result
+
+
+def _levenshtein_distance(s1: str, s2: str) -> int:
+    """Calculate Levenshtein edit distance between two strings."""
+    if len(s1) < len(s2):
+        return _levenshtein_distance(s2, s1)
+
+    if len(s2) == 0:
+        return len(s1)
+
+    prev_row = list(range(len(s2) + 1))
+
+    for i, c1 in enumerate(s1):
+        curr_row = [i + 1]
+        for j, c2 in enumerate(s2):
+            insertions = prev_row[j + 1] + 1
+            deletions = curr_row[j] + 1
+            substitutions = prev_row[j] + (c1 != c2)
+            curr_row.append(min(insertions, deletions, substitutions))
+        prev_row = curr_row
+
+    return prev_row[-1]
+
+
+def _simple_wer(ref_words: List[str], hyp_words: List[str]) -> float:
+    """Simple WER calculation using dynamic programming."""
+    n = len(ref_words)
+    m = len(hyp_words)
+
+    if n == 0:
+        return 0.0 if m == 0 else float(m)
+    if m == 0:
+        return 1.0
+
+    # DP table
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+
+    # Initialize
+    for i in range(n + 1):
+        dp[i][0] = i
+    for j in range(m + 1):
+        dp[0][j] = j
+
+    # Fill table
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            if ref_words[i-1] == hyp_words[j-1]:
+                dp[i][j] = dp[i-1][j-1]
+            else:
+                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+
+    return dp[n][m] / n
+
+
+def calculate_wer(reference: str, hypothesis: str, language: str = 'hindi') -> Optional[float]:
+    """
+    Calculate Word Error Rate (WER).
+
+    WER = (Substitutions + Deletions + Insertions) / Total_Words_in_Reference
+
+    Args:
+        reference: Ground truth transcription
+        hypothesis: Model prediction
+        language: Language for normalization
+
+    Returns:
+        WER score (0.0 = perfect, higher = worse) or None if invalid
+    """
+    if not reference or _isna(reference):
+        return None
+
+    if not hypothesis or _isna(hypothesis):
+        return 1.0  # Empty hypothesis = all deletions
+
+    ref_clean = clean_text(str(reference), language)
+    hyp_clean = clean_text(str(hypothesis), language)
+
+    if not ref_clean:
+        return None
+
+    if not hyp_clean:
+        return 1.0
+
+    if JIWER_AVAILABLE:
+        try:
+            return float(jiwer_wer(ref_clean, hyp_clean))
+        except Exception:
+            return _simple_wer(ref_clean.split(), hyp_clean.split())
+    else:
+        return _simple_wer(ref_clean.split(), hyp_clean.split())
+
+
+def calculate_cer(reference: str, hypothesis: str, language: str = 'hindi') -> Optional[float]:
+    """
+    Calculate Character Error Rate (CER).
+
+    CER = (Substitutions + Deletions + Insertions) / Total_Chars_in_Reference
+
+    Args:
+        reference: Ground truth transcription
+        hypothesis: Model prediction
+        language: Language for normalization
+
+    Returns:
+        CER score (0.0 = perfect, higher = worse) or None if invalid
+    """
+    if not reference or _isna(reference):
+        return None
+
+    if not hypothesis or _isna(hypothesis):
+        return 1.0
+
+    ref_clean = clean_text(str(reference), language)
+    hyp_clean = clean_text(str(hypothesis), language)
+
+    # Remove spaces for character comparison
+    ref_chars = ref_clean.replace(' ', '')
+    hyp_chars = hyp_clean.replace(' ', '')
+
+    if not ref_chars:
+        return None
+
+    if not hyp_chars:
+        return 1.0
+
+    if JIWER_AVAILABLE:
+        try:
+            return float(jiwer_cer(ref_chars, hyp_chars))
+        except Exception:
+            return _levenshtein_distance(ref_chars, hyp_chars) / len(ref_chars)
+    else:
+        return _levenshtein_distance(ref_chars, hyp_chars) / len(ref_chars)
+
+
+def _simple_mer(ref_words: List[str], hyp_words: List[str]) -> float:
+    """Simple MER calculation using dynamic programming.
+
+    MER = (S + D + I) / (S + D + C) where C = correct matches.
+    The denominator is the total alignment length (substitutions + deletions + correct).
+    """
+    n = len(ref_words)
+    m = len(hyp_words)
+
+    if n == 0:
+        return 0.0 if m == 0 else 1.0
+    if m == 0:
+        return 1.0
+
+    # DP table
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1):
+        dp[i][0] = i
+    for j in range(m + 1):
+        dp[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            if ref_words[i-1] == hyp_words[j-1]:
+                dp[i][j] = dp[i-1][j-1]
+            else:
+                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+
+    edit_distance = dp[n][m]
+    alignment_length = max(n, m)
+    if alignment_length == 0:
+        return 0.0
+    return edit_distance / alignment_length
+
+
+def calculate_mer(reference: str, hypothesis: str, language: str = 'hindi') -> Optional[float]:
+    """
+    Calculate Match Error Rate (MER).
+
+    MER = (S + D + I) / (S + D + C) where C = correct matches.
+    Unlike WER (which divides by reference length N), MER divides by the
+    total alignment length, giving a match-aware error rate.
+
+    Args:
+        reference: Ground truth transcription
+        hypothesis: Model prediction
+        language: Language for normalization
+
+    Returns:
+        MER score (0.0 = perfect, 1.0 = worst) or None if invalid
+    """
+    if not reference or _isna(reference):
+        return None
+
+    if not hypothesis or _isna(hypothesis):
+        return 1.0
+
+    ref_clean = clean_text(str(reference), language)
+    hyp_clean = clean_text(str(hypothesis), language)
+
+    if not ref_clean:
+        return None
+
+    if not hyp_clean:
+        return 1.0
+
+    if JIWER_MER_AVAILABLE:
+        try:
+            return float(jiwer_mer(ref_clean, hyp_clean))
+        except Exception:
+            return _simple_mer(ref_clean.split(), hyp_clean.split())
+    else:
+        return _simple_mer(ref_clean.split(), hyp_clean.split())
+
+
+def calculate_metrics_for_sample(reference: str, hypothesis: str, language: str = 'hindi') -> dict:
+    """
+    Calculate all metrics for a single sample.
+
+    Args:
+        reference: Ground truth transcription
+        hypothesis: Model prediction
+        language: Language for normalization
+
+    Returns:
+        Dictionary with wer, cer, and word counts
+    """
+    ref_clean = clean_text(str(reference) if reference else '', language)
+    hyp_clean = clean_text(str(hypothesis) if hypothesis else '', language)
+
+    return {
+        'wer': calculate_wer(reference, hypothesis, language),
+        'cer': calculate_cer(reference, hypothesis, language),
+        'mer': calculate_mer(reference, hypothesis, language),
+        'ref_word_count': len(ref_clean.split()) if ref_clean else 0,
+        'hyp_word_count': len(hyp_clean.split()) if hyp_clean else 0,
+    }

pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agri-awwer"
+version = "0.1.0"
+description = "Agriculture-Weighted Word Error Rate (AWWER) evaluation toolkit for domain-specific ASR assessment"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.8"
+authors = [
+    { name = "Digital Green", email = "tech@digitalgreen.org" },
+]
+keywords = ["asr", "speech-recognition", "agriculture", "evaluation", "wer", "metrics"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.optional-dependencies]
+jiwer = ["jiwer>=3.0"]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://huggingface.co/DigiGreen/Agri_AWWER_Toolkit"
+Paper = "https://huggingface.co/datasets/DigiGreen/Agri_STT_Benchmarking_Dataset"
+
+[tool.setuptools.packages.find]
+include = ["agri_awwer*"]

tests/test_awwer.py

@@ -0,0 +1,222 @@
+"""Tests for the agri_awwer package."""
+
+import json
+import math
+
+from agri_awwer import (
+    clean_text,
+    align_words_dp,
+    parse_word_weights,
+    calculate_awwer,
+    calculate_awwer_components,
+    calculate_awwer_from_string,
+    calculate_wer,
+    calculate_cer,
+    calculate_mer,
+    get_word_weight,
+)
+
+
+# ---------------------------------------------------------------------------
+# clean_text
+# ---------------------------------------------------------------------------
+
+class TestCleanText:
+    def test_basic_normalization(self):
+        assert clean_text("Hello, World!") == "hello world"
+
+    def test_empty_input(self):
+        assert clean_text("") == ""
+        assert clean_text(None) == ""
+
+    def test_punctuation_removal(self):
+        assert clean_text("gehun, aur makka.") == "gehun aur makka"
+
+    def test_whitespace_collapse(self):
+        assert clean_text("  gehun   mein   keet  ") == "gehun mein keet"
+
+    def test_nan_handling(self):
+        assert clean_text(float("nan")) == ""
+
+
+# ---------------------------------------------------------------------------
+# align_words_dp
+# ---------------------------------------------------------------------------
+
+class TestAlignWordsDP:
+    def test_identical(self):
+        ops = align_words_dp(["a", "b", "c"], ["a", "b", "c"])
+        assert all(op[0] == "match" for op in ops)
+
+    def test_substitution(self):
+        ops = align_words_dp(["a", "b"], ["a", "x"])
+        types = [op[0] for op in ops]
+        assert types == ["match", "sub"]
+
+    def test_deletion(self):
+        ops = align_words_dp(["a", "b", "c"], ["a", "c"])
+        types = [op[0] for op in ops]
+        assert "del" in types
+        assert sum(1 for t in types if t == "match") == 2
+
+    def test_insertion(self):
+        ops = align_words_dp(["a", "c"], ["a", "b", "c"])
+        types = [op[0] for op in ops]
+        assert "ins" in types
+        assert sum(1 for t in types if t == "match") == 2
+
+    def test_empty_ref(self):
+        ops = align_words_dp([], ["a", "b"])
+        assert all(op[0] == "ins" for op in ops)
+
+    def test_empty_hyp(self):
+        ops = align_words_dp(["a", "b"], [])
+        assert all(op[0] == "del" for op in ops)
+
+
+# ---------------------------------------------------------------------------
+# parse_word_weights
+# ---------------------------------------------------------------------------
+
+class TestParseWordWeights:
+    def test_json_string(self):
+        s = json.dumps([["gehun", 4], ["keet", 3]])
+        w = parse_word_weights(s)
+        assert w == {"gehun": 4.0, "keet": 3.0}
+
+    def test_empty(self):
+        assert parse_word_weights("") == {}
+        assert parse_word_weights(None) == {}
+
+    def test_invalid_json(self):
+        assert parse_word_weights("not json") == {}
+
+    def test_list_input(self):
+        w = parse_word_weights([["a", 2], ["b", 3]])
+        assert w == {"a": 2.0, "b": 3.0}
+
+
+# ---------------------------------------------------------------------------
+# get_word_weight
+# ---------------------------------------------------------------------------
+
+class TestGetWordWeight:
+    def test_exact_match(self):
+        assert get_word_weight("gehun", {"gehun": 4.0}) == 4.0
+
+    def test_case_insensitive(self):
+        assert get_word_weight("Gehun", {"gehun": 4.0}) == 4.0
+
+    def test_default(self):
+        assert get_word_weight("unknown", {"gehun": 4.0}, default_weight=1.0) == 1.0
+
+    def test_empty(self):
+        assert get_word_weight("", {}) == 1.0
+
+
+# ---------------------------------------------------------------------------
+# calculate_awwer
+# ---------------------------------------------------------------------------
+
+class TestCalculateAWWER:
+    def setup_method(self):
+        self.weights = {
+            "gehun": 4.0,
+            "keet": 4.0,
+            "mitti": 3.0,
+            "gaon": 1.0,
+        }
+
+    def test_perfect_match(self):
+        ref = "gehun mein keet laga hai"
+        assert calculate_awwer(ref, ref, self.weights) == 0.0
+
+    def test_high_weight_error(self):
+        ref = "gehun mein keet laga hai"
+        hyp = "gaon mein keet laga hai"
+        awwer = calculate_awwer(ref, hyp, self.weights)
+        wer = calculate_wer(ref, hyp)
+        # AWWER should be > WER because gehun (weight 4) was substituted
+        assert awwer is not None
+        assert wer is not None
+        assert awwer > wer
+
+    def test_none_on_empty_ref(self):
+        assert calculate_awwer("", "something", self.weights) is None
+        assert calculate_awwer(None, "something", self.weights) is None
+
+    def test_all_deletions(self):
+        ref = "gehun keet"
+        hyp = ""
+        awwer = calculate_awwer(ref, hyp, self.weights)
+        # All reference words deleted → error_weight == total_weight → AWWER = 1.0
+        assert awwer == 1.0
+
+
+# ---------------------------------------------------------------------------
+# calculate_awwer_components
+# ---------------------------------------------------------------------------
+
+class TestCalculateAWWERComponents:
+    def test_breakdown(self):
+        weights = {"gehun": 4.0, "keet": 4.0}
+        ref = "gehun mein keet"
+        hyp = "gaon mein keet"
+        result = calculate_awwer_components(ref, hyp, weights)
+        assert result["n_substitutions"] == 1
+        assert result["n_deletions"] == 0
+        assert result["n_insertions"] == 0
+        assert len(result["high_weight_errors"]) == 1
+        assert result["high_weight_errors"][0]["ref_word"] == "gehun"
+
+
+# ---------------------------------------------------------------------------
+# calculate_awwer_from_string
+# ---------------------------------------------------------------------------
+
+class TestCalculateAWWERFromString:
+    def test_json_weights(self):
+        weights_json = json.dumps([["gehun", 4], ["keet", 4]])
+        ref = "gehun mein keet"
+        awwer = calculate_awwer_from_string(ref, ref, weights_json)
+        assert awwer == 0.0
+
+
+# ---------------------------------------------------------------------------
+# calculate_wer / calculate_cer / calculate_mer
+# ---------------------------------------------------------------------------
+
+class TestStandardMetrics:
+    def test_wer_perfect(self):
+        assert calculate_wer("hello world", "hello world") == 0.0
+
+    def test_wer_all_wrong(self):
+        wer = calculate_wer("a b c", "x y z")
+        assert wer == 1.0
+
+    def test_wer_none_on_empty_ref(self):
+        assert calculate_wer("", "hello") is None
+
+    def test_wer_empty_hyp(self):
+        assert calculate_wer("hello world", "") == 1.0
+
+    def test_cer_perfect(self):
+        assert calculate_cer("hello", "hello") == 0.0
+
+    def test_cer_nonzero(self):
+        cer = calculate_cer("abc", "axc")
+        assert cer is not None
+        assert cer > 0
+
+    def test_mer_perfect(self):
+        assert calculate_mer("hello world", "hello world") == 0.0
+
+    def test_mer_bounds(self):
+        mer = calculate_mer("a b c", "x y z")
+        assert mer is not None
+        assert 0.0 <= mer <= 1.0
+
+    def test_nan_handling(self):
+        assert calculate_wer(float("nan"), "hello") is None
+        assert calculate_cer(float("nan"), "hello") is None
+        assert calculate_mer(float("nan"), "hello") is None