Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/sacrebleu/dataset/__main__.py

@@ -0,0 +1,45 @@
+import sys
+
+from . import DATASETS
+
+try:
+    cmd = sys.argv[1]
+except IndexError:
+    print(f"Usage: {sys.argv[0]} --check | --dump")
+    sys.exit(1)
+
+if cmd == "--check":
+    import hashlib
+    import urllib.request
+
+    url_md5 = {}
+
+    for item in DATASETS.values():
+        if item.md5 is not None:
+            assert item.data
+            assert item.md5
+            assert len(item.data) == len(item.md5)
+            pairs = zip(item.data, item.md5)
+            for url, md5_hash in pairs:
+                url_md5[url] = md5_hash
+
+    for url, md5_hash in url_md5.items():
+        try:
+            print("Downloading ", url)
+            with urllib.request.urlopen(url) as f:
+                data = f.read()
+        except Exception as exc:
+            raise (exc)
+
+        if hashlib.md5(data).hexdigest() != md5_hash:
+            print("MD5 check failed for", url)
+elif cmd == "--dump":
+    import re
+
+    # Dumps a table in markdown format
+    print(f'| {"Dataset":<30} | {"Description":<115} |')
+    header = "| " + "-" * 30 + " | " + "-" * 115 + " |"
+    print(header)
+    for name, item in DATASETS.items():
+        desc = re.sub(r"(http[s]?:\/\/\S+)", r"[URL](\1)", str(item.description))
+        print(f"| {name:<30} | {desc:<115} |")

llmeval-env/lib/python3.10/site-packages/sacrebleu/dataset/base.py

@@ -0,0 +1,195 @@
+"""
+The base class for all types of datasets.
+"""
+import os
+import re
+from abc import ABCMeta, abstractmethod
+from typing import Dict, List, Optional
+
+from ..utils import SACREBLEU_DIR, download_file, smart_open
+
+
+class Dataset(metaclass=ABCMeta):
+    def __init__(
+        self,
+        name: str,
+        data: Optional[List[str]] = None,
+        description: Optional[str] = None,
+        citation: Optional[str] = None,
+        md5: Optional[List[str]] = None,
+        langpairs=Dict[str, List[str]],
+        **kwargs,
+    ):
+        """
+        Params come from the values in DATASETS.
+
+        :param name: Name of the dataset.
+        :param data: URL of the raw data of the dataset.
+        :param description: Description of the dataset.
+        :param citation: Citation for the dataset.
+        :param md5: MD5 checksum of the dataset.
+        :param langpairs: List of available language pairs.
+        """
+        self.name = name
+        self.data = data
+        self.description = description
+        self.citation = citation
+        self.md5 = md5
+        self.langpairs = langpairs
+        self.kwargs = kwargs
+
+        # Don't do any downloading or further processing now.
+        # Only do that lazily, when asked.
+
+        # where to store the dataset
+        self._outdir = os.path.join(SACREBLEU_DIR, self.name)
+        self._rawdir = os.path.join(self._outdir, "raw")
+
+    def maybe_download(self):
+        """
+        If the dataset isn't downloaded, use utils/download_file()
+        This can be implemented here in the base class. It should write
+        to ~/.sacreleu/DATASET/raw exactly as it does now.
+        """
+        os.makedirs(self._rawdir, exist_ok=True)
+
+        expected_checksums = self.md5 if self.md5 else [None] * len(self.data)
+
+        for url, expected_md5 in zip(self.data, expected_checksums):
+            tarball = os.path.join(self._rawdir, self._get_tarball_filename(url))
+
+            download_file(
+                url, tarball, extract_to=self._rawdir, expected_md5=expected_md5
+            )
+
+    @staticmethod
+    def _clean(s):
+        """
+        Removes trailing and leading spaces and collapses multiple consecutive internal spaces to a single one.
+
+        :param s: The string.
+        :return: A cleaned-up string.
+        """
+        return re.sub(r"\s+", " ", s.strip())
+
+    def _get_tarball_filename(self, url):
+        """
+        Produces a local filename for tarball.
+        :param url: The url to download.
+        :return: A name produced from the dataset identifier and the URL basename.
+        """
+        return self.name.replace("/", "_") + "." + os.path.basename(url)
+
+    def _get_txt_file_path(self, langpair, fieldname):
+        """
+        Given the language pair and fieldname, return the path to the text file.
+        The format is: ~/.sacrebleu/DATASET/DATASET.LANGPAIR.FIELDNAME
+
+        :param langpair: The language pair.
+        :param fieldname: The fieldname.
+        :return: The path to the text file.
+        """
+        # handle the special case of subsets. e.g. "wmt21/dev" > "wmt21_dev"
+        name = self.name.replace("/", "_")
+        # Colons are used to distinguish multiple references, but are not supported in Windows filenames
+        fieldname = fieldname.replace(":", "-")
+        return os.path.join(self._outdir, f"{name}.{langpair}.{fieldname}")
+
+    def _get_langpair_metadata(self, langpair):
+        """
+        Given a language pair, return the metadata for that language pair.
+        Deal with errors if the language pair is not available.
+
+        :param langpair: The language pair. e.g. "en-de"
+        :return: Dict format which is same as self.langpairs.
+        """
+        if langpair is None:
+            langpairs = self.langpairs
+        elif langpair not in self.langpairs:
+            raise Exception(f"No such language pair {self.name}/{langpair}")
+        else:
+            langpairs = {langpair: self.langpairs[langpair]}
+
+        return langpairs
+
+    @abstractmethod
+    def process_to_text(self, langpair=None) -> None:
+        """Processes raw files to plain text files.
+
+        :param langpair: The language pair to process. e.g. "en-de". If None, all files will be processed.
+        """
+        pass
+
+    def fieldnames(self, langpair) -> List[str]:
+        """
+        Return a list of all the field names. For most source, this is just
+        the source and the reference. For others, it might include the document
+        ID for each line, or the original language (origLang).
+
+        get_files() should return the same number of items as this.
+
+        :param langpair: The language pair (e.g., "de-en")
+        :return: a list of field names
+        """
+        return ["src", "ref"]
+
+    def __iter__(self, langpair):
+        """
+        Iterates over all fields (source, references, and other metadata) defined
+        by the dataset.
+        """
+        all_files = self.get_files(langpair)
+        all_fins = [smart_open(f) for f in all_files]
+
+        for item in zip(*all_fins):
+            yield item
+
+    def source(self, langpair):
+        """
+        Return an iterable over the source lines.
+        """
+        source_file = self.get_source_file(langpair)
+        with smart_open(source_file) as fin:
+            for line in fin:
+                yield line.strip()
+
+    def references(self, langpair):
+        """
+        Return an iterable over the references.
+        """
+        ref_files = self.get_reference_files(langpair)
+        ref_fins = [smart_open(f) for f in ref_files]
+
+        for item in zip(*ref_fins):
+            yield item
+
+    def get_source_file(self, langpair):
+        all_files = self.get_files(langpair)
+        all_fields = self.fieldnames(langpair)
+        index = all_fields.index("src")
+        return all_files[index]
+
+    def get_reference_files(self, langpair):
+        all_files = self.get_files(langpair)
+        all_fields = self.fieldnames(langpair)
+        ref_files = [
+            f for f, field in zip(all_files, all_fields) if field.startswith("ref")
+        ]
+        return ref_files
+
+    def get_files(self, langpair):
+        """
+        Returns the path of the source file and all reference files for
+        the provided test set / language pair.
+        Downloads the references first if they are not already local.
+
+        :param langpair: The language pair (e.g., "de-en")
+        :return: a list of the source file and all reference files
+        """
+        fields = self.fieldnames(langpair)
+        files = [self._get_txt_file_path(langpair, field) for field in fields]
+
+        for file in files:
+            if not os.path.exists(file):
+                self.process_to_text(langpair)
+        return files

llmeval-env/lib/python3.10/site-packages/sacrebleu/dataset/fake_sgml.py

@@ -0,0 +1,116 @@
+import os
+import re
+
+from ..utils import smart_open
+from .base import Dataset
+
+
+class FakeSGMLDataset(Dataset):
+    """
+    The fake SGML format used by WMT prior to 2021. Can't be properly parsed.
+    Source and reference(s) in separate files.
+    """
+
+    def _convert_format(self, input_file_path, output_filep_path):
+        """
+        Extract data from raw file and convert to raw txt format.
+        """
+        with smart_open(input_file_path) as fin, smart_open(
+            output_filep_path, "wt"
+        ) as fout:
+            for line in fin:
+                if line.startswith("<seg "):
+                    line = self._clean(re.sub(r"<seg.*?>(.*)</seg>.*?", "\\1", line))
+                    print(line, file=fout)
+
+    def _convert_meta(self, input_file_path, field, output_filep_path):
+        """
+        Extract metadata from document tags, projects across segments.
+        """
+        with smart_open(input_file_path) as fin, smart_open(
+            output_filep_path, "wt"
+        ) as fout:
+            value = ""
+            for line in fin:
+                if line.startswith("<doc "):
+                    match = re.search(rf'{field}="(.*?)"', line)
+                    if match is not None:
+                        value = match.group(1)
+
+                elif line.startswith("<seg "):
+                    # print the current value once for each field
+                    print(value, file=fout)
+
+    def process_to_text(self, langpair=None):
+        """Processes raw files to plain text files.
+
+        :param langpair: The language pair to process. e.g. "en-de". If None, all files will be processed.
+        """
+        # ensure that the dataset is downloaded
+        self.maybe_download()
+        langpairs = self._get_langpair_metadata(langpair)
+
+        for langpair in langpairs:
+            fieldnames = self.fieldnames(langpair)
+            origin_files = [
+                os.path.join(self._rawdir, path) for path in langpairs[langpair]
+            ]
+
+            # Add the source file three more times for docid, genre, origlang
+            origin_files += [
+                os.path.join(self._rawdir, langpairs[langpair][0]) for _ in range(3)
+            ]
+
+            for field, origin_file in zip(fieldnames, origin_files):
+
+                origin_file = os.path.join(self._rawdir, origin_file)
+                output_file = self._get_txt_file_path(langpair, field)
+
+                if field.startswith("src") or field.startswith("ref"):
+                    self._convert_format(origin_file, output_file)
+                else:
+                    # document metadata keys
+                    self._convert_meta(origin_file, field, output_file)
+
+    def fieldnames(self, langpair):
+        """
+        Return a list of all the field names. For most source, this is just
+        the source and the reference. For others, it might include the document
+        ID for each line, or the original language (origLang).
+
+        get_files() should return the same number of items as this.
+        """
+        meta = self._get_langpair_metadata(langpair)
+        length = len(meta[langpair])
+
+        assert (
+            length >= 2
+        ), f"Each language pair in {self.name} must have at least 2 fields."
+
+        fields = ["src"]
+
+        if length == 2:
+            fields.append("ref")
+        else:
+            for i, _ in enumerate(meta[langpair][1:]):
+                fields.append(f"ref:{i}")
+
+        if not self.name.startswith("wmt08"):
+            fields += ["docid", "genre", "origlang"]
+
+        return fields
+
+
+class WMTAdditionDataset(FakeSGMLDataset):
+    """
+    Handle special case of WMT Google addition dataset.
+    """
+
+    def _convert_format(self, input_file_path, output_filep_path):
+        if input_file_path.endswith(".sgm"):
+            return super()._convert_format(input_file_path, output_filep_path)
+        else:
+            with smart_open(input_file_path) as fin:
+                with smart_open(output_filep_path, "wt") as fout:
+                    for line in fin:
+                        print(line.rstrip(), file=fout)

llmeval-env/lib/python3.10/site-packages/sacrebleu/dataset/iwslt_xml.py

@@ -0,0 +1,8 @@
+from .fake_sgml import FakeSGMLDataset
+
+
+class IWSLTXMLDataset(FakeSGMLDataset):
+    """IWSLT dataset format. Can be parsed with the lxml parser."""
+
+    # Same as FakeSGMLDataset. Nothing to do here.
+    pass

llmeval-env/lib/python3.10/site-packages/sacrebleu/dataset/plain_text.py

@@ -0,0 +1,36 @@
+import os
+
+from ..utils import smart_open
+from .base import Dataset
+
+
+class PlainTextDataset(Dataset):
+    """
+    The plain text format. Data is separated into source and reference files.
+    Each line of the two files is aligned.
+    """
+
+    def process_to_text(self, langpair=None):
+        """Processes raw files to plain text files.
+
+        :param langpair: The language pair to process. e.g. "en-de". If None, all files will be processed.
+        """
+        # ensure that the dataset is downloaded
+        self.maybe_download()
+        langpairs = self._get_langpair_metadata(langpair)
+
+        for langpair in langpairs:
+            fieldnames = self.fieldnames(langpair)
+            origin_files = [
+                os.path.join(self._rawdir, path) for path in langpairs[langpair]
+            ]
+
+            for field, origin_file in zip(fieldnames, origin_files):
+
+                origin_file = os.path.join(self._rawdir, origin_file)
+                output_file = self._get_txt_file_path(langpair, field)
+
+                with smart_open(origin_file) as fin:
+                    with smart_open(output_file, "wt") as fout:
+                        for line in fin:
+                            print(line.rstrip(), file=fout)

llmeval-env/lib/python3.10/site-packages/sacrebleu/dataset/tsv.py

@@ -0,0 +1,61 @@
+import os
+
+from ..utils import smart_open
+from .base import Dataset
+
+
+class TSVDataset(Dataset):
+    """
+    The format used by the MTNT datasets. Data is in a single TSV file.
+    """
+
+    @staticmethod
+    def _split_index_and_filename(meta, field):
+        """
+        Splits the index and filename from a metadata string.
+
+        e.g. meta="3:en-de.tsv", filed=[Any value] -> (3, "en-de.tsv")
+             "en-de.tsv", filed="src" -> (1, "en-de.tsv")
+             "en-de.tsv", filed="tgt" -> (2, "en-de.tsv")
+        """
+        arr = meta.split(":")
+        if len(arr) == 2:
+            try:
+                index = int(arr[0])
+            except ValueError:
+                raise Exception(f"Invalid meta for TSVDataset: {meta}")
+            return index, arr[1]
+
+        else:
+            index = 0 if field == "src" else 1
+            return index, meta
+
+    def process_to_text(self, langpair=None):
+        """Processes raw files to plain text files.
+
+        :param langpair: The language pair to process. e.g. "en-de". If None, all files will be processed.
+        """
+        # ensure that the dataset is downloaded
+        self.maybe_download()
+        langpairs = self._get_langpair_metadata(langpair)
+
+        for langpair in langpairs:
+            fieldnames = self.fieldnames(langpair)
+            origin_files = [
+                os.path.join(self._rawdir, path) for path in langpairs[langpair]
+            ]
+
+            for field, origin_file, meta in zip(
+                fieldnames, origin_files, langpairs[langpair]
+            ):
+                index, origin_file = self._split_index_and_filename(meta, field)
+
+                origin_file = os.path.join(self._rawdir, origin_file)
+                output_file = self._get_txt_file_path(langpair, field)
+
+                with smart_open(origin_file) as fin:
+                    with smart_open(output_file, "wt") as fout:
+                        for line in fin:
+                            # be careful with empty source or reference lines
+                            # MTNT2019/ja-en.final.tsv:632 `'1033\t718\t\t\n'`
+                            print(line.rstrip("\n").split("\t")[index], file=fout)

llmeval-env/lib/python3.10/site-packages/sacrebleu/metrics/__init__.py

@@ -0,0 +1,11 @@
+"""The implementation of various metrics."""
+
+from .bleu import BLEU, BLEUScore   # noqa: F401
+from .chrf import CHRF, CHRFScore   # noqa: F401
+from .ter import TER, TERScore      # noqa: F401
+
+METRICS = {
+    'BLEU': BLEU,
+    'CHRF': CHRF,
+    'TER': TER,
+}

llmeval-env/lib/python3.10/site-packages/sacrebleu/metrics/base.py

@@ -0,0 +1,438 @@
+"""The base `Score`, `Metric` and `Signature` classes to derive from.
+
+`Metric` is an abstract class that enforces the implementation of a set
+of abstract methods. This way, a correctly implemented metric will work
+seamlessly with the rest of the codebase.
+"""
+
+import json
+import logging
+import statistics
+from typing import List, Sequence, Any, Optional, Dict
+from abc import ABCMeta, abstractmethod
+
+from .. import __version__
+
+sacrelogger = logging.getLogger('sacrebleu')
+
+
+class Score:
+    """A base score class to derive from.
+
+    :param name: The name of the underlying metric.
+    :param score: A floating point number for the final metric.
+    """
+    def __init__(self, name: str, score: float):
+        """`Score` initializer."""
+        self.name = name
+        self.score = score
+
+        # Statistical test related fields
+        self._mean = -1.0
+        self._ci = -1.0
+
+        # More info can be added right after the score
+        self._verbose = ''
+
+    def format(self, width: int = 2, score_only: bool = False,
+               signature: str = '', is_json: bool = False) -> str:
+        """Returns a pretty representation of the score.
+        :param width: Floating point decimal precision width.
+        :param score_only: If `True`, and the format is not `json`,
+        returns a single score string.
+        :param signature: A string representation of the given `Signature`
+        instance.
+        :param is_json: If `True`, will output the score in JSON string.
+        :return: A plain or JSON-formatted string representation.
+        """
+        d = {
+            'name': self.name,
+            'score': float(f'{self.score:.{width}f}'),
+            'signature': signature,
+        }
+
+        sc = f'{self.score:.{width}f}'
+
+        if self._mean > 0:
+            confidence_mean = f'{self._mean:.{width}f}'
+            confidence_var = f'{self._ci:.{width}f}'
+            confidence_str = f'μ = {confidence_mean} ± {confidence_var}'
+
+            sc += f' ({confidence_str})'
+            if is_json:
+                d['confidence_mean'] = float(confidence_mean)
+                d['confidence_var'] = float(confidence_var)
+                d['confidence'] = confidence_str
+
+        # Construct full score line
+        full_score = f"{self.name}|{signature}" if signature else self.name
+        full_score = f"{full_score} = {sc}"
+        if self._verbose:
+            full_score += f' {self._verbose}'
+            d['verbose_score'] = self._verbose
+
+        if score_only:
+            return sc
+
+        if is_json:
+            for param in signature.split('|'):
+                key, value = param.split(':')
+                d[key] = value
+            return json.dumps(d, indent=1, ensure_ascii=False)
+
+        return full_score
+
+    def estimate_ci(self, scores: List['Score']):
+        """Takes a list of scores and stores mean, stdev and 95% confidence
+        interval around the mean.
+
+        :param scores: A list of `Score` objects obtained from bootstrap
+        resampling for example.
+        """
+        # Sort the scores
+        raw_scores = sorted([x.score for x in scores])
+        n = len(raw_scores)
+
+        # Get CI bounds (95%, i.e. 1/40 from left)
+        lower_idx = n // 40
+        upper_idx = n - lower_idx - 1
+        lower, upper = raw_scores[lower_idx], raw_scores[upper_idx]
+        self._ci = 0.5 * (upper - lower)
+        self._mean = statistics.mean(raw_scores)
+
+    def __repr__(self):
+        """Returns a human readable score string."""
+        return self.format()
+
+
+class Signature:
+    """A convenience class to represent sacreBLEU reproducibility signatures.
+
+    :param args: key-value dictionary passed from the actual metric instance.
+    """
+    def __init__(self, args: dict):
+        """`Signature` initializer."""
+        # Global items that are shared across all metrics
+        self._abbr = {
+            'version': 'v',
+            'nrefs': '#',
+            'test': 't',
+            'lang': 'l',
+            'subset': 'S',
+            'origlang': 'o',
+            'bs': 'bs',     # Bootstrap resampling trials
+            'ar': 'ar',     # Approximate randomization trials
+            'seed': 'rs',   # RNG's seed
+        }
+
+        if 'num_refs' not in args:
+            raise ValueError(
+                'Number of references unknown, please evaluate the metric first.')
+
+        num_refs = args['num_refs']
+        if num_refs == -1:
+            # Detect variable number of refs
+            num_refs = 'var'
+
+        # Global items that are shared across all metrics
+        # None's will be ignored
+        self.info = {
+            'version': __version__,
+            'nrefs': num_refs,
+            'bs': args.get('n_bootstrap', None),
+            'ar': None,
+            'seed': args.get('seed', None),
+            'test': args.get('test_set', None),
+            'lang': args.get('langpair', None),
+            'origlang': args.get('origlang', None),
+            'subset': args.get('subset', None),
+        }
+
+    def format(self, short: bool = False) -> str:
+        """Returns a string representation of the signature.
+
+        :param short: If True, shortened signature is produced.
+        :return: A string representation of the signature.
+        """
+        pairs = []
+        keys = list(self.info.keys())
+        # keep version always at end
+        keys.remove('version')
+        for name in keys + ['version']:
+            value = self.info[name]
+            if value is not None:
+                if isinstance(value, bool):
+                    # Replace True/False with yes/no
+                    value = 'yes' if value else 'no'
+                final_name = self._abbr[name] if short else name
+                pairs.append(f'{final_name}:{value}')
+
+        return '|'.join(pairs)
+
+    def update(self, key: str, value: Any):
+        """Add a new item or update an existing one.
+
+        :param key: The key to use in the dictionary.
+        :param value: The associated value for the `key`.
+        """
+        self.info[key] = value
+
+    def __str__(self):
+        """Returns a human-readable signature string."""
+        return self.format()
+
+    def __repr__(self):
+        """Returns a human-readable signature string."""
+        return self.format()
+
+
+class Metric(metaclass=ABCMeta):
+    """A base class for all metrics that ensures the implementation of some
+    methods. Much of the common functionality is moved to this base class
+    from other metrics."""
+
+    # Each metric should define its Signature class' name here
+    _SIGNATURE_TYPE = Signature
+
+    def __init__(self):
+        """`Metric` initializer."""
+        # The pre-computed reference cache
+        self._ref_cache = None
+
+        # only useful for BLEU tokenized warnings. Set to True so that
+        # warnings are not issued for other metrics.
+        self._force = True
+
+        # Will be used by the signature when bootstrap resampling
+        self.n_bootstrap = None
+        self.seed = None
+
+    def _check_sentence_score_args(self, hyp: str, refs: Sequence[str]):
+        """Performs sanity checks on `sentence_score` method's arguments.
+
+        :param hyp: A single hypothesis string.
+        :param refs: A sequence of reference strings.
+        """
+        prefix = self.__class__.__name__
+        err_msg = None
+
+        if not isinstance(hyp, str):
+            err_msg = 'The argument `hyp` should be a string.'
+        elif isinstance(refs, str) or not isinstance(refs, Sequence):
+            err_msg = 'The argument `refs` should be a sequence of strings.'
+        elif not isinstance(refs[0], str) and refs[0] is not None:
+            err_msg = 'Each element of `refs` should be a string.'
+
+        if err_msg:
+            raise TypeError(f'{prefix}: {err_msg}')
+
+    def _check_corpus_score_args(self, hyps: Sequence[str],
+                                 refs: Optional[Sequence[Sequence[str]]]):
+        """Performs sanity checks on `corpus_score` method's arguments.
+
+        :param hypses: A sequence of hypothesis strings.
+        :param refs: A sequence of reference documents with document being
+        defined as a sequence of reference strings. If `None`, cached references
+        will be used.
+        """
+
+        prefix = self.__class__.__name__
+        err_msg = None
+
+        if not isinstance(hyps, Sequence):
+            err_msg = "`hyps` should be a sequence of strings."
+        elif not isinstance(hyps[0], str):
+            err_msg = 'Each element of `hyps` should be a string.'
+        elif any(line is None for line in hyps):
+            err_msg = "Undefined line in hypotheses stream!"
+
+        if refs is not None:
+            if not isinstance(refs, Sequence):
+                err_msg = "`refs` should be a sequence of sequence of strings."
+            elif not isinstance(refs[0], Sequence):
+                err_msg = "Each element of `refs` should be a sequence of strings."
+            elif not isinstance(refs[0][0], str) and refs[0][0] is not None:
+                err_msg = "`refs` should be a sequence of sequence of strings."
+
+        if err_msg:
+            raise TypeError(f'{prefix}: {err_msg}')
+
+    @abstractmethod
+    def _aggregate_and_compute(self, stats: List[List[Any]]) -> Any:
+        """Computes the final score given the pre-computed match statistics.
+
+        :param stats: A list of segment-level statistics.
+        :return: A `Score` instance.
+        """
+        pass
+
+    @abstractmethod
+    def _compute_score_from_stats(self, stats: List[Any]) -> Any:
+        """Computes the final score from already aggregated statistics.
+
+        :param stats: A list or numpy array of segment-level statistics.
+        :return: A `Score` object.
+        """
+        pass
+
+    @abstractmethod
+    def _preprocess_segment(self, sent: str) -> str:
+        """A wrapper around the metric's tokenization and pre-processing logic.
+        This should be implemented for reference caching to work correctly.
+
+        :param sent: The input sentence.
+        :return: The pre-processed output sentence.
+        """
+        pass
+
+    @abstractmethod
+    def _extract_reference_info(self, refs: Sequence[str]) -> Dict[str, Any]:
+        """Given a list of reference segments, extract the required
+        information (such as n-grams for BLEU and chrF). This should be implemented
+        for the generic `_cache_references()` to work across all metrics.
+
+        :param refs: A sequence of strings.
+        """
+        pass
+
+    @abstractmethod
+    def _compute_segment_statistics(self, hypothesis: str, ref_kwargs: Dict) -> List[Any]:
+        """Given a (pre-processed) hypothesis sentence and already computed
+        reference info, returns the best match statistics across the
+        references. The return type is usually a List of ints or floats.
+
+        :param hypothesis: A pre-processed hypothesis sentence.
+        :param ref_kwargs: A dictionary with reference-related information
+        within. This is formulated as a dictionary as different metrics may
+        require different information regarding a reference segment.
+        """
+        pass
+
+    def _cache_references(self, references: Sequence[Sequence[str]]) -> List[Any]:
+        """Given the full set of document references, extract segment n-grams
+        (or other necessary information) for caching purposes.
+
+        :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings. A particular reference
+        segment can be '' or `None` to allow the use of variable number
+        of references per segment.
+        :return: A list where each element is a tuple of segment n-grams and
+        reference lengths, as returned by `_extract_reference_info()`.
+        """
+        ref_cache = []
+
+        # Decide on final number of refs here as well
+        num_refs = set()
+
+        for refs in zip(*references):
+            # Remove undefined references
+            lines = [x for x in refs if x is not None]
+
+            # Keep track of reference counts to allow variable reference
+            # info in the signature
+            num_refs.add(len(lines))
+
+            lines = [self._preprocess_segment(x) for x in lines]
+
+            # Get n-grams
+            ref_cache.append(self._extract_reference_info(lines))
+
+        if len(num_refs) == 1:
+            self.num_refs = list(num_refs)[0]
+        else:
+            # A variable number of refs exist
+            self.num_refs = -1
+
+        return ref_cache
+
+    def _extract_corpus_statistics(self, hypotheses: Sequence[str],
+                                   references: Optional[Sequence[Sequence[str]]]) -> Any:
+        """Reads the corpus and returns sentence-level match statistics for
+        faster re-computations esp. during statistical tests.
+
+        :param hypotheses: A sequence of hypothesis strings.
+        :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings. If `None`, cached references
+        will be used.
+        :return: A list where each sublist corresponds to segment statistics.
+        """
+        # Pre-compute references
+        # Don't store the cache as the user is explicitly passing refs
+        if references:
+            ref_cache = self._cache_references(references)
+        elif self._ref_cache:
+            ref_cache = self._ref_cache
+        else:
+            raise RuntimeError('No references provided and the cache is empty.')
+
+        stats = []
+        tok_count = 0
+
+        for hyp, ref_kwargs in zip(hypotheses, ref_cache):
+            # Check for already-tokenized input problem (only for BLEU)
+            if not self._force and hyp.endswith(' .'):
+                tok_count += 1
+
+            hyp = self._preprocess_segment(hyp)
+
+            # Collect stats
+            stats.append(self._compute_segment_statistics(hyp, ref_kwargs))
+
+        if tok_count >= 100:
+            sacrelogger.warning("That's 100 lines that end in a tokenized period ('.')")
+            sacrelogger.warning("It looks like you forgot to detokenize your test data, which may hurt your score.")
+            sacrelogger.warning("If you insist your data is detokenized, or don't care, you can suppress this message with the `force` parameter.")
+
+        return stats
+
+    def sentence_score(self, hypothesis: str, references: Sequence[str]) -> Any:
+        """Compute the metric for a single sentence against a single (or multiple) reference(s).
+
+        :param hypothesis: A single hypothesis string.
+        :param references: A sequence of reference strings.
+        :return: A `Score` object.
+        """
+        self._check_sentence_score_args(hypothesis, references)
+
+        stats = self._extract_corpus_statistics(
+            [hypothesis], [[refs] for refs in references])
+        return self._aggregate_and_compute(stats)
+
+    def corpus_score(self, hypotheses: Sequence[str],
+                     references: Optional[Sequence[Sequence[str]]],
+                     n_bootstrap: int = 1) -> Any:
+        """Compute the metric for a corpus against a single (or multiple) reference(s).
+
+        :param hypotheses: A sequence of hypothesis strings.
+        :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings. If `None`, cached references
+        will be used.
+        :param n_bootstrap: If > 1, provides 95% confidence interval around true mean
+        using bootstrap resampling with `n_bootstrap` samples.
+        :return: A `Score` object.
+        """
+        self._check_corpus_score_args(hypotheses, references)
+
+        # Collect corpus stats
+        stats = self._extract_corpus_statistics(hypotheses, references)
+
+        # Compute the actual system score
+        actual_score = self._aggregate_and_compute(stats)
+
+        if n_bootstrap > 1:
+            # Compute bootstrap estimate as well
+            # Delayed import is to escape from numpy import if bootstrap
+            # is not requested.
+            from ..significance import _bootstrap_resample
+
+            self.n_bootstrap = n_bootstrap
+            self.seed, bs_scores = _bootstrap_resample(stats, self, n_bootstrap)
+            actual_score.estimate_ci(bs_scores)
+
+        return actual_score
+
+    def get_signature(self) -> Signature:
+        """Creates and returns the signature for the metric. The creation
+        of signatures is delayed as the number of references is resolved
+        only at the point of reference caching."""
+        return self._SIGNATURE_TYPE(self.__dict__)

llmeval-env/lib/python3.10/site-packages/sacrebleu/metrics/bleu.py

@@ -0,0 +1,420 @@
+"""The implementation of the BLEU metric (Papineni et al., 2002)."""
+
+import math
+import logging
+from importlib import import_module
+from typing import List, Sequence, Optional, Dict, Any
+
+from ..utils import my_log, sum_of_lists
+
+from .base import Score, Signature, Metric
+from .helpers import extract_all_word_ngrams
+
+sacrelogger = logging.getLogger('sacrebleu')
+
+# The default for the maximum n-gram order when computing precisions
+MAX_NGRAM_ORDER = 4
+
+_TOKENIZERS = {
+    'none': 'tokenizer_none.NoneTokenizer',
+    'zh': 'tokenizer_zh.TokenizerZh',
+    '13a': 'tokenizer_13a.Tokenizer13a',
+    'intl': 'tokenizer_intl.TokenizerV14International',
+    'char': 'tokenizer_char.TokenizerChar',
+    'ja-mecab': 'tokenizer_ja_mecab.TokenizerJaMecab',
+    'ko-mecab': 'tokenizer_ko_mecab.TokenizerKoMecab',
+    'spm': 'tokenizer_spm.TokenizerSPM',
+    'flores101': 'tokenizer_spm.Flores101Tokenizer',
+    'flores200': 'tokenizer_spm.Flores200Tokenizer',
+}
+
+
+def _get_tokenizer(name: str):
+    """Dynamically import tokenizer as importing all is slow."""
+    module_name, class_name = _TOKENIZERS[name].rsplit('.', 1)
+    return getattr(
+        import_module(f'.tokenizers.{module_name}', 'sacrebleu'),
+        class_name)
+
+
+class BLEUSignature(Signature):
+    """A convenience class to represent the reproducibility signature for BLEU.
+
+    :param args: key-value dictionary passed from the actual metric instance.
+    """
+    def __init__(self, args: dict):
+        """`BLEUSignature` initializer."""
+        super().__init__(args)
+
+        self._abbr.update({
+            'case': 'c',
+            'eff': 'e',
+            'tok': 'tok',
+            'smooth': 's',
+        })
+
+        # Construct a combined string for smoothing method and value
+        smooth_str = args['smooth_method']
+        smooth_def = BLEU.SMOOTH_DEFAULTS[smooth_str]
+
+        # If the method requires a parameter, add it within brackets
+        if smooth_def is not None:
+            # the following can be None if the user wants to use the default
+            smooth_val = args['smooth_value']
+
+            if smooth_val is None:
+                smooth_val = smooth_def
+
+            smooth_str += f'[{smooth_val:.2f}]'
+
+        self.info.update({
+            'case': 'lc' if args['lowercase'] else 'mixed',
+            'eff': 'yes' if args['effective_order'] else 'no',
+            'tok': args['tokenizer_signature'],
+            'smooth': smooth_str,
+        })
+
+
+class BLEUScore(Score):
+    """A convenience class to represent BLEU scores.
+
+    :param score: The BLEU score.
+    :param counts: List of counts of correct ngrams, 1 <= n <= max_ngram_order
+    :param totals: List of counts of total ngrams, 1 <= n <= max_ngram_order
+    :param precisions: List of precisions, 1 <= n <= max_ngram_order
+    :param bp: The brevity penalty.
+    :param sys_len: The cumulative system length.
+    :param ref_len: The cumulative reference length.
+    """
+    def __init__(self, score: float, counts: List[int], totals: List[int],
+                 precisions: List[float], bp: float,
+                 sys_len: int, ref_len: int):
+        """`BLEUScore` initializer."""
+        super().__init__('BLEU', score)
+        self.bp = bp
+        self.counts = counts
+        self.totals = totals
+        self.sys_len = sys_len
+        self.ref_len = ref_len
+        self.precisions = precisions
+
+        self.prec_str = "/".join([f"{p:.1f}" for p in self.precisions])
+        self.ratio = self.sys_len / self.ref_len if self.ref_len else 0
+
+        # The verbose part of BLEU
+        self._verbose = f"{self.prec_str} (BP = {self.bp:.3f} "
+        self._verbose += f"ratio = {self.ratio:.3f} hyp_len = {self.sys_len:d} "
+        self._verbose += f"ref_len = {self.ref_len:d})"
+
+
+class BLEU(Metric):
+    """Computes the BLEU metric given hypotheses and references.
+
+    :param lowercase: If True, lowercased BLEU is computed.
+    :param force: Ignore data that looks already tokenized.
+    :param tokenize: The tokenizer to use. If None, defaults to language-specific tokenizers with '13a' as the fallback default.
+    :param smooth_method: The smoothing method to use ('floor', 'add-k', 'exp' or 'none').
+    :param smooth_value: The smoothing value for `floor` and `add-k` methods. `None` falls back to default value.
+    :param max_ngram_order: If given, it overrides the maximum n-gram order (default: 4) when computing precisions.
+    :param effective_order: If `True`, stop including n-gram orders for which precision is 0. This should be
+        `True`, if sentence-level BLEU will be computed.
+    :param trg_lang: An optional language code to raise potential tokenizer warnings.
+    :param references: A sequence of reference documents with document being
+    defined as a sequence of reference strings. If given, the reference n-grams
+    and lengths will be pre-computed and cached for faster BLEU computation
+    across many systems.
+    """
+
+    SMOOTH_DEFAULTS: Dict[str, Optional[float]] = {
+        # The defaults for `floor` and `add-k` are obtained from the following paper
+        # A Systematic Comparison of Smoothing Techniques for Sentence-Level BLEU
+        # Boxing Chen and Colin Cherry
+        # http://aclweb.org/anthology/W14-3346
+        'none': None,   # No value is required
+        'floor': 0.1,
+        'add-k': 1,
+        'exp': None,    # No value is required
+    }
+
+    TOKENIZERS = _TOKENIZERS.keys()
+
+    # mteval-v13a.pl tokenizer unless Chinese or Japanese is provided
+    TOKENIZER_DEFAULT = '13a'
+
+    # Some language specific mappings to use if `trg_lang` is given
+    # and the tokenizer is not explicitly specified
+    _TOKENIZER_MAP = {
+        'zh': 'zh',
+        'ja': 'ja-mecab',
+        'ko': 'ko-mecab',
+    }
+
+    _SIGNATURE_TYPE = BLEUSignature
+
+    def __init__(self, lowercase: bool = False,
+                 force: bool = False,
+                 tokenize: Optional[str] = None,
+                 smooth_method: str = 'exp',
+                 smooth_value: Optional[float] = None,
+                 max_ngram_order: int = MAX_NGRAM_ORDER,
+                 effective_order: bool = False,
+                 trg_lang: str = '',
+                 references: Optional[Sequence[Sequence[str]]] = None):
+        """`BLEU` initializer."""
+        super().__init__()
+
+        self._force = force
+        self.trg_lang = trg_lang
+        self.lowercase = lowercase
+        self.smooth_value = smooth_value
+        self.smooth_method = smooth_method
+        self.max_ngram_order = max_ngram_order
+        self.effective_order = effective_order
+
+        # Sanity check
+        assert self.smooth_method in self.SMOOTH_DEFAULTS.keys(), \
+            "Unknown smooth_method {self.smooth_method!r}"
+
+        # If the tokenizer wasn't specified, choose it according to the
+        # following logic. We use 'v13a' except for ZH and JA. Note that
+        # this logic can only be applied when sacrebleu knows the target
+        # language, which is only the case for builtin datasets.
+        if tokenize is None:
+            best_tokenizer = self.TOKENIZER_DEFAULT
+
+            # Set `zh` or `ja-mecab` or `ko-mecab` if target language is provided
+            if self.trg_lang in self._TOKENIZER_MAP:
+                best_tokenizer = self._TOKENIZER_MAP[self.trg_lang]
+        else:
+            best_tokenizer = tokenize
+            if self.trg_lang == 'zh' and best_tokenizer != 'zh':
+                sacrelogger.warning(
+                    "Consider using the 'zh' or 'spm' tokenizer for Chinese.")
+            if self.trg_lang == 'ja' and best_tokenizer != 'ja-mecab':
+                sacrelogger.warning(
+                    "Consider using the 'ja-mecab' or 'spm' tokenizer for Japanese.")
+            if self.trg_lang == 'ko' and best_tokenizer != 'ko-mecab':
+                sacrelogger.warning(
+                    "Consider using the 'ko-mecab' or 'spm' tokenizer for Korean.")
+
+        # Create the tokenizer
+        self.tokenizer = _get_tokenizer(best_tokenizer)()
+
+        # Build the signature
+        self.tokenizer_signature = self.tokenizer.signature()
+
+        if references is not None:
+            # Pre-compute reference ngrams and lengths
+            self._ref_cache = self._cache_references(references)
+
+    @staticmethod
+    def compute_bleu(correct: List[int],
+                     total: List[int],
+                     sys_len: int,
+                     ref_len: int,
+                     smooth_method: str = 'none',
+                     smooth_value=None,
+                     effective_order: bool = False,
+                     max_ngram_order: int = MAX_NGRAM_ORDER) -> BLEUScore:
+        """Computes BLEU score from its sufficient statistics with smoothing.
+
+        Smoothing methods (citing "A Systematic Comparison of Smoothing Techniques for Sentence-Level BLEU",
+        Boxing Chen and Colin Cherry, WMT 2014: http://aclweb.org/anthology/W14-3346)
+
+        - none: No smoothing.
+        - floor: Method 1 (requires small positive value (0.1 in the paper) to be set)
+        - add-k: Method 2 (Generalizing Lin and Och, 2004)
+        - exp: Method 3 (NIST smoothing method i.e. in use with mteval-v13a.pl)
+
+        :param correct: List of counts of correct ngrams, 1 <= n <= max_ngram_order
+        :param total: List of counts of total ngrams, 1 <= n <= max_ngram_order
+        :param sys_len: The cumulative system length
+        :param ref_len: The cumulative reference length
+        :param smooth_method: The smoothing method to use ('floor', 'add-k', 'exp' or 'none')
+        :param smooth_value: The smoothing value for `floor` and `add-k` methods. `None` falls back to default value.
+        :param effective_order: If `True`, stop including n-gram orders for which precision is 0. This should be
+            `True`, if sentence-level BLEU will be computed.
+        :param max_ngram_order: If given, it overrides the maximum n-gram order (default: 4) when computing precisions.
+        :return: A `BLEUScore` instance.
+        """
+        assert smooth_method in BLEU.SMOOTH_DEFAULTS.keys(), \
+            "Unknown smooth_method {smooth_method!r}"
+
+        # Fetch the default value for floor and add-k
+        if smooth_value is None:
+            smooth_value = BLEU.SMOOTH_DEFAULTS[smooth_method]
+
+        # Compute brevity penalty
+        if sys_len < ref_len:
+            bp = math.exp(1 - ref_len / sys_len) if sys_len > 0 else 0.0
+        else:
+            bp = 1.0
+
+        # n-gram precisions
+        precisions = [0.0 for x in range(max_ngram_order)]
+
+        # Early stop if there are no matches (#141)
+        if not any(correct):
+            return BLEUScore(0.0, correct, total, precisions, bp, sys_len, ref_len)
+
+        smooth_mteval = 1.
+        eff_order = max_ngram_order
+        for n in range(1, len(precisions) + 1):
+            if smooth_method == 'add-k' and n > 1:
+                correct[n - 1] += smooth_value
+                total[n - 1] += smooth_value
+
+            if total[n - 1] == 0:
+                break
+
+            # If the system guesses no i-grams, 1 <= i <= max_ngram_order,
+            # the BLEU score is 0 (technically undefined). This is a problem for sentence
+            # level BLEU or a corpus of short sentences, where systems will get
+            # no credit if sentence lengths fall under the max_ngram_order threshold.
+            # This fix scales max_ngram_order to the observed maximum order.
+            # It is only available through the API and off by default
+            if effective_order:
+                eff_order = n
+
+            if correct[n - 1] == 0:
+                if smooth_method == 'exp':
+                    smooth_mteval *= 2
+                    precisions[n - 1] = 100. / (smooth_mteval * total[n - 1])
+                elif smooth_method == 'floor':
+                    precisions[n - 1] = 100. * smooth_value / total[n - 1]
+            else:
+                precisions[n - 1] = 100. * correct[n - 1] / total[n - 1]
+
+        # Compute BLEU score
+        score = bp * math.exp(
+            sum([my_log(p) for p in precisions[:eff_order]]) / eff_order)
+
+        return BLEUScore(score, correct, total, precisions, bp, sys_len, ref_len)
+
+    def _preprocess_segment(self, sent: str) -> str:
+        """Given a sentence, lowercases (optionally) and tokenizes it
+        :param sent: The input sentence string.
+        :return: The pre-processed output string.
+        """
+        if self.lowercase:
+            sent = sent.lower()
+        return self.tokenizer(sent.rstrip())
+
+    def _compute_score_from_stats(self, stats: List[int]) -> BLEUScore:
+        """Computes the final score from already aggregated statistics.
+
+        :param stats: A list or numpy array of segment-level statistics.
+        :return: A `BLEUScore` object.
+        """
+        return self.compute_bleu(
+            correct=stats[2: 2 + self.max_ngram_order],
+            total=stats[2 + self.max_ngram_order:],
+            sys_len=int(stats[0]), ref_len=int(stats[1]),
+            smooth_method=self.smooth_method, smooth_value=self.smooth_value,
+            effective_order=self.effective_order,
+            max_ngram_order=self.max_ngram_order
+        )
+
+    def _aggregate_and_compute(self, stats: List[List[int]]) -> BLEUScore:
+        """Computes the final BLEU score given the pre-computed corpus statistics.
+
+        :param stats: A list of segment-level statistics
+        :return: A `BLEUScore` instance.
+        """
+        return self._compute_score_from_stats(sum_of_lists(stats))
+
+    def _get_closest_ref_len(self, hyp_len: int, ref_lens: List[int]) -> int:
+        """Given a hypothesis length and a list of reference lengths, returns
+        the closest reference length to be used by BLEU.
+
+        :param hyp_len: The hypothesis length.
+        :param ref_lens: A list of reference lengths.
+        :return: The closest reference length.
+        """
+        closest_diff, closest_len = -1, -1
+
+        for ref_len in ref_lens:
+            diff = abs(hyp_len - ref_len)
+            if closest_diff == -1 or diff < closest_diff:
+                closest_diff = diff
+                closest_len = ref_len
+            elif diff == closest_diff and ref_len < closest_len:
+                closest_len = ref_len
+
+        return closest_len
+
+    def _extract_reference_info(self, refs: Sequence[str]) -> Dict[str, Any]:
+        """Given a list of reference segments, extract the n-grams and reference lengths.
+        The latter will be useful when comparing hypothesis and reference lengths for BLEU.
+
+        :param refs: A sequence of strings.
+        :return: A dictionary that will be passed to `_compute_segment_statistics()`
+        through keyword arguments.
+        """
+        ngrams = None
+        ref_lens = []
+
+        for ref in refs:
+            # extract n-grams for this ref
+            this_ngrams, ref_len = extract_all_word_ngrams(ref, 1, self.max_ngram_order)
+            ref_lens.append(ref_len)
+
+            if ngrams is None:
+                # Set it directly for first set of refs
+                ngrams = this_ngrams
+            else:
+                # Merge counts across multiple references
+                # The below loop is faster than `ngrams |= this_ngrams`
+                for ngram, count in this_ngrams.items():
+                    ngrams[ngram] = max(ngrams[ngram], count)
+
+        return {'ref_ngrams': ngrams, 'ref_lens': ref_lens}
+
+    def _compute_segment_statistics(self, hypothesis: str,
+                                    ref_kwargs: Dict) -> List[int]:
+        """Given a (pre-processed) hypothesis sentence and already computed
+        reference n-grams & lengths, returns the best match statistics across the
+        references.
+
+        :param hypothesis: Hypothesis sentence.
+        :param ref_kwargs: A dictionary with `refs_ngrams`and `ref_lens` keys
+        that denote the counter containing all n-gram counts and reference lengths,
+        respectively.
+        :return: A list of integers with match statistics.
+        """
+
+        ref_ngrams, ref_lens = ref_kwargs['ref_ngrams'], ref_kwargs['ref_lens']
+
+        # Extract n-grams for the hypothesis
+        hyp_ngrams, hyp_len = extract_all_word_ngrams(
+            hypothesis, 1, self.max_ngram_order)
+
+        ref_len = self._get_closest_ref_len(hyp_len, ref_lens)
+
+        # Count the stats
+        # Although counter has its internal & and | operators, this is faster
+        correct = [0 for i in range(self.max_ngram_order)]
+        total = correct[:]
+        for hyp_ngram, hyp_count in hyp_ngrams.items():
+            # n-gram order
+            n = len(hyp_ngram) - 1
+            # count hypothesis n-grams
+            total[n] += hyp_count
+            # count matched n-grams
+            if hyp_ngram in ref_ngrams:
+                correct[n] += min(hyp_count, ref_ngrams[hyp_ngram])
+
+        # Return a flattened list for efficient computation
+        return [hyp_len, ref_len] + correct + total
+
+    def sentence_score(self, hypothesis: str, references: Sequence[str]) -> BLEUScore:
+        """Compute the metric for a single sentence against a single (or multiple) reference(s).
+
+        :param hypothesis: A single hypothesis string.
+        :param references: A sequence of reference strings.
+        :return: a `BLEUScore` object.
+        """
+        if not self.effective_order:
+            sacrelogger.warning(
+                'It is recommended to enable `effective_order` for sentence-level BLEU.')
+        return super().sentence_score(hypothesis, references)

llmeval-env/lib/python3.10/site-packages/sacrebleu/metrics/chrf.py

@@ -0,0 +1,284 @@
+"""The implementation of chrF (Popović 2015) and chrF++ (Popović 2017) metrics."""
+
+from typing import List, Sequence, Optional, Dict
+from collections import Counter
+
+from ..utils import sum_of_lists
+from .base import Score, Signature, Metric
+from .helpers import extract_all_char_ngrams, extract_word_ngrams
+
+
+class CHRFSignature(Signature):
+    """A convenience class to represent the reproducibility signature for chrF.
+
+    :param args: key-value dictionary passed from the actual metric instance.
+    """
+    def __init__(self, args: dict):
+        """`CHRFSignature` initializer."""
+        super().__init__(args)
+        self._abbr.update({
+            'case': 'c',
+            'eff': 'e',
+            'nc': 'nc',
+            'nw': 'nw',
+            'space': 's',
+        })
+
+        self.info.update({
+            'case': 'lc' if args['lowercase'] else 'mixed',
+            'eff': 'yes' if not args['eps_smoothing'] else 'no',
+            'nc': args['char_order'],
+            'nw': args['word_order'],
+            'space': 'yes' if args['whitespace'] else 'no',
+        })
+
+
+class CHRFScore(Score):
+    """A convenience class to represent chrF scores.
+
+    :param score: The chrF (chrF++) score.
+    :param char_order: The character n-gram order.
+    :param word_order: The word n-gram order. If equals to 2, the metric is referred to as chrF++.
+    :param beta: Determine the importance of recall w.r.t precision.
+    """
+    def __init__(self, score: float, char_order: int, word_order: int, beta: int):
+        """`CHRFScore` initializer."""
+        self.beta = beta
+        self.char_order = char_order
+        self.word_order = word_order
+
+        # Add + signs to denote chrF+ variant
+        name = f'chrF{self.beta}' + '+' * self.word_order
+
+        super().__init__(name, score)
+
+
+class CHRF(Metric):
+    """Computes the chrF(++) metric given hypotheses and references.
+
+    :param char_order: Character n-gram order.
+    :param word_order: Word n-gram order. If equals to 2, the metric is referred to as chrF++.
+    :param beta: Determine the importance of recall w.r.t precision.
+    :param lowercase: Enable case-insensitivity.
+    :param whitespace: If `True`, include whitespaces when extracting character n-grams.
+    :param eps_smoothing: If `True`, applies epsilon smoothing similar
+    to reference chrF++.py, NLTK and Moses implementations. Otherwise,
+    it takes into account effective match order similar to sacreBLEU < 2.0.0.
+    :param references: A sequence of reference documents with document being
+    defined as a sequence of reference strings. If given, the reference n-grams
+    will be pre-computed and cached for faster re-computation across many systems.
+    """
+
+    # Maximum character n-gram order to take into account
+    CHAR_ORDER = 6
+
+    # chrF+ additionally takes into account some of the word n-grams
+    WORD_ORDER = 0
+
+    # Defaults to 2 (per http://www.aclweb.org/anthology/W16-2341)
+    BETA = 2
+
+    # Cache string.punctuation for chrF+' punctuation stripper
+    _PUNCTS = set('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~')
+
+    _SIGNATURE_TYPE = CHRFSignature
+
+    def __init__(self, char_order: int = CHAR_ORDER,
+                 word_order: int = WORD_ORDER,
+                 beta: int = BETA,
+                 lowercase: bool = False,
+                 whitespace: bool = False,
+                 eps_smoothing: bool = False,
+                 references: Optional[Sequence[Sequence[str]]] = None):
+        """`CHRF` initializer."""
+        super().__init__()
+
+        self.beta = beta
+        self.char_order = char_order
+        self.word_order = word_order
+        self.order = self.char_order + self.word_order
+        self.lowercase = lowercase
+        self.whitespace = whitespace
+        self.eps_smoothing = eps_smoothing
+
+        if references is not None:
+            # Pre-compute reference ngrams
+            self._ref_cache = self._cache_references(references)
+
+    @staticmethod
+    def _get_match_statistics(hyp_ngrams: Counter, ref_ngrams: Counter) -> List[int]:
+        """Computes the match statistics between hypothesis and reference n-grams.
+
+        :param hyp_ngrams: A `Counter` holding hypothesis n-grams.
+        :param ref_ngrams: A `Counter` holding reference n-grams.
+        :return: A list of three numbers denoting hypothesis n-gram count,
+            reference n-gram count and the intersection count.
+        """
+        # Counter's internal intersection is not that fast, count manually
+        match_count, hyp_count = 0, 0
+        for ng, count in hyp_ngrams.items():
+            hyp_count += count
+            if ng in ref_ngrams:
+                match_count += min(count, ref_ngrams[ng])
+
+        return [
+            # Don't count hits if no reference exists for that n-gram
+            hyp_count if ref_ngrams else 0,
+            sum(ref_ngrams.values()),
+            match_count,
+        ]
+
+    def _remove_punctuation(self, sent: str) -> List[str]:
+        """Separates out punctuations from beginning and end of words for chrF.
+        Adapted from https://github.com/m-popovic/chrF
+
+        :param sent: A string.
+        :return: A list of words.
+        """
+        tokenized = []
+        for w in sent.split():
+            if len(w) == 1:
+                tokenized.append(w)
+            else:
+                # NOTE: This splits '(hi)' to '(hi' and ')' (issue #124)
+                if w[-1] in self._PUNCTS:
+                    tokenized += [w[:-1], w[-1]]
+                elif w[0] in self._PUNCTS:
+                    tokenized += [w[0], w[1:]]
+                else:
+                    tokenized.append(w)
+        return tokenized
+
+    def _preprocess_segment(self, sent: str) -> str:
+        """Given a sentence, apply optional lowercasing.
+
+        :param sent: The input sentence string.
+        :return: The pre-processed output string.
+        """
+        return sent.lower() if self.lowercase else sent
+
+    def _compute_f_score(self, statistics: List[int]) -> float:
+        """Compute the chrF score given the n-gram match statistics.
+
+        :param statistics: A flattened list of 3 * (`char_order` + `word_order`)
+            elements giving the [hyp, ref, match] counts for each order.
+        :return: The final f_beta score between [0, 100].
+        """
+        eps = 1e-16
+        score = 0.0
+        effective_order = 0
+        factor = self.beta ** 2
+        avg_prec, avg_rec = 0.0, 0.0
+
+        for i in range(self.order):
+            n_hyp, n_ref, n_match = statistics[3 * i: 3 * i + 3]
+
+            # chrF++.py style EPS smoothing (also used by Moses and NLTK)
+            prec = n_match / n_hyp if n_hyp > 0 else eps
+            rec = n_match / n_ref if n_ref > 0 else eps
+
+            denom = factor * prec + rec
+            score += ((1 + factor) * prec * rec / denom) if denom > 0 else eps
+
+            # sacreBLEU <2.0.0 style effective order smoothing
+            if n_hyp > 0 and n_ref > 0:
+                avg_prec += prec
+                avg_rec += rec
+                effective_order += 1
+
+        if self.eps_smoothing:
+            return 100 * score / self.order
+
+        if effective_order == 0:
+            avg_prec = avg_rec = 0.0
+        else:
+            avg_prec /= effective_order
+            avg_rec /= effective_order
+
+        if avg_prec + avg_rec:
+            score = (1 + factor) * avg_prec * avg_rec
+            score /= ((factor * avg_prec) + avg_rec)
+            return 100 * score
+        else:
+            return 0.0
+
+    def _compute_score_from_stats(self, stats: List[int]) -> CHRFScore:
+        """Computes the final score from already aggregated statistics.
+
+        :param stats: A list or numpy array of segment-level statistics.
+        :return: A `CHRFScore` object.
+        """
+        return CHRFScore(
+            self._compute_f_score(stats), self.char_order,
+            self.word_order, self.beta)
+
+    def _aggregate_and_compute(self, stats: List[List[int]]) -> CHRFScore:
+        """Computes the final score given the pre-computed corpus statistics.
+
+        :param stats: A list of segment-level statistics
+        :return: A `CHRFScore` object.
+        """
+        return self._compute_score_from_stats(sum_of_lists(stats))
+
+    def _extract_reference_info(self, refs: Sequence[str]) -> Dict[str, List[List[Counter]]]:
+        """Given a list of reference segments, extract the character and word n-grams.
+
+        :param refs: A sequence of reference segments.
+        :return: A list where each element contains n-grams per reference segment.
+        """
+        ngrams = []
+
+        for ref in refs:
+            # extract character n-grams
+            stats = extract_all_char_ngrams(ref, self.char_order, self.whitespace)
+
+            # Check chrF+ mode
+            if self.word_order > 0:
+                ref_words = self._remove_punctuation(ref)
+
+                for n in range(self.word_order):
+                    stats.append(extract_word_ngrams(ref_words, n + 1))
+
+            ngrams.append(stats)
+
+        return {'ref_ngrams': ngrams}
+
+    def _compute_segment_statistics(
+            self, hypothesis: str, ref_kwargs: Dict) -> List[int]:
+        """Given a (pre-processed) hypothesis sentence and already computed
+        reference n-grams, returns the best match statistics across the
+        references.
+
+        :param hypothesis: Hypothesis sentence.
+        :param ref_kwargs: A dictionary with key `ref_ngrams` which is a list
+        where each sublist contains n-gram counters for a particular reference sentence.
+        :return: A list of integers where each triplet denotes [hyp, ref, match]
+        statistics.
+        """
+        best_stats = []
+        best_f_score = -1.0
+
+        # extract character n-grams
+        all_hyp_ngrams = extract_all_char_ngrams(
+            hypothesis, self.char_order, self.whitespace)
+
+        # Check chrF+ mode to see if we'll add word n-grams as well
+        if self.word_order > 0:
+            # Primitive tokenization: separate out punctuations
+            hwords = self._remove_punctuation(hypothesis)
+            _range = range(1, self.word_order + 1)
+            all_hyp_ngrams.extend([extract_word_ngrams(hwords, n) for n in _range])
+
+        # Iterate over multiple references, pick the one with best F score
+        for _ref_ngrams in ref_kwargs['ref_ngrams']:
+            stats = []
+            # Traverse all orders
+            for h, r in zip(all_hyp_ngrams, _ref_ngrams):
+                stats.extend(self._get_match_statistics(h, r))
+            f_score = self._compute_f_score(stats)
+
+            if f_score > best_f_score:
+                best_f_score = f_score
+                best_stats = stats
+
+        return best_stats

llmeval-env/lib/python3.10/site-packages/sacrebleu/metrics/helpers.py

@@ -0,0 +1,69 @@
+"""Various utility functions for word and character n-gram extraction."""
+
+from collections import Counter
+from typing import List, Tuple
+
+
+def extract_all_word_ngrams(line: str, min_order: int, max_order: int) -> Tuple[Counter, int]:
+    """Extracts all ngrams (min_order <= n <= max_order) from a sentence.
+
+    :param line: A string sentence.
+    :param min_order: Minimum n-gram order.
+    :param max_order: Maximum n-gram order.
+    :return: a Counter object with n-grams counts and the sequence length.
+    """
+
+    ngrams = []
+    tokens = line.split()
+
+    for n in range(min_order, max_order + 1):
+        for i in range(0, len(tokens) - n + 1):
+            ngrams.append(tuple(tokens[i: i + n]))
+
+    return Counter(ngrams), len(tokens)
+
+
+def extract_word_ngrams(tokens: List[str], n: int) -> Counter:
+    """Extracts n-grams with order `n` from a list of tokens.
+
+    :param tokens: A list of tokens.
+    :param n: The order of n-grams.
+    :return: a Counter object with n-grams counts.
+    """
+    return Counter([' '.join(tokens[i:i + n]) for i in range(len(tokens) - n + 1)])
+
+
+def extract_char_ngrams(line: str, n: int, include_whitespace: bool = False) -> Counter:
+    """Yields counts of character n-grams from a sentence.
+
+    :param line: A segment containing a sequence of words.
+    :param n: The order of the n-grams.
+    :param include_whitespace: If given, will not strip whitespaces from the line.
+    :return: a dictionary containing ngrams and counts
+    """
+    if not include_whitespace:
+        line = ''.join(line.split())
+
+    return Counter([line[i:i + n] for i in range(len(line) - n + 1)])
+
+
+def extract_all_char_ngrams(
+        line: str, max_order: int, include_whitespace: bool = False) -> List[Counter]:
+    """Extracts all character n-grams at once for convenience.
+
+    :param line: A segment containing a sequence of words.
+    :param max_order: The maximum order of the n-grams.
+    :param include_whitespace: If given, will not strip whitespaces from the line.
+    :return: a list of Counter objects containing ngrams and counts.
+    """
+
+    counters = []
+
+    if not include_whitespace:
+        line = ''.join(line.split())
+
+    for n in range(1, max_order + 1):
+        ngrams = Counter([line[i:i + n] for i in range(len(line) - n + 1)])
+        counters.append(ngrams)
+
+    return counters

llmeval-env/lib/python3.10/site-packages/sacrebleu/metrics/lib_ter.py

@@ -0,0 +1,478 @@
+"""This module implements various utility functions for the TER metric."""
+
+# Copyright 2020 Memsource
+#
+# 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.
+
+
+import math
+from typing import List, Tuple, Dict
+
+
+_COST_INS = 1
+_COST_DEL = 1
+_COST_SUB = 1
+
+# Tercom-inspired limits
+_MAX_SHIFT_SIZE = 10
+_MAX_SHIFT_DIST = 50
+_BEAM_WIDTH = 25
+
+# Our own limits
+_MAX_CACHE_SIZE = 10000
+_MAX_SHIFT_CANDIDATES = 1000
+_INT_INFINITY = int(1e16)
+
+_OP_INS = 'i'
+_OP_DEL = 'd'
+_OP_NOP = ' '
+_OP_SUB = 's'
+_OP_UNDEF = 'x'
+
+_FLIP_OPS = str.maketrans(_OP_INS + _OP_DEL, _OP_DEL + _OP_INS)
+
+
+def translation_edit_rate(words_hyp: List[str], words_ref: List[str]) -> Tuple[int, int]:
+    """Calculate the translation edit rate.
+
+    :param words_hyp: Tokenized translation hypothesis.
+    :param words_ref: Tokenized reference translation.
+    :return: tuple (number of edits, length)
+    """
+    n_words_ref = len(words_ref)
+    n_words_hyp = len(words_hyp)
+    if n_words_ref == 0:
+        # FIXME: This trace here is not used?
+        trace = _OP_DEL * n_words_hyp
+        # special treatment of empty refs
+        return n_words_hyp, 0
+
+    cached_ed = BeamEditDistance(words_ref)
+    shifts = 0
+
+    input_words = words_hyp
+    checked_candidates = 0
+    while True:
+        # do shifts until they stop reducing the edit distance
+        delta, new_input_words, checked_candidates = _shift(
+            input_words, words_ref, cached_ed, checked_candidates)
+
+        if checked_candidates >= _MAX_SHIFT_CANDIDATES:
+            break
+
+        if delta <= 0:
+            break
+        shifts += 1
+        input_words = new_input_words
+
+    edit_distance, trace = cached_ed(input_words)
+    total_edits = shifts + edit_distance
+
+    return total_edits, n_words_ref
+
+
+def _shift(words_h: List[str], words_r: List[str], cached_ed,
+           checked_candidates: int) -> Tuple[int, List[str], int]:
+    """Attempt to shift words in hypothesis to match reference.
+
+    Returns the shift that reduces the edit distance the most.
+
+    Note that the filtering of possible shifts and shift selection are heavily
+    based on somewhat arbitrary heuristics. The code here follows as closely
+    as possible the logic in Tercom, not always justifying the particular design
+    choices.
+
+    :param words_h: Hypothesis.
+    :param words_r: Reference.
+    :param cached_ed: Cached edit distance.
+    :param checked_candidates: Number of shift candidates that were already
+                               evaluated.
+    :return: (score, shifted_words, checked_candidates). Best shift and updated
+             number of evaluated shift candidates.
+    """
+    pre_score, inv_trace = cached_ed(words_h)
+
+    # to get alignment, we pretend we are rewriting reference into hypothesis,
+    # so we need to flip the trace of edit operations
+    trace = _flip_trace(inv_trace)
+    align, ref_err, hyp_err = trace_to_alignment(trace)
+
+    best = None
+
+    for start_h, start_r, length in _find_shifted_pairs(words_h, words_r):
+        # don't do the shift unless both the hypothesis was wrong and the
+        # reference doesn't match hypothesis at the target position
+        if sum(hyp_err[start_h: start_h + length]) == 0:
+            continue
+
+        if sum(ref_err[start_r: start_r + length]) == 0:
+            continue
+
+        # don't try to shift within the subsequence
+        if start_h <= align[start_r] < start_h + length:
+            continue
+
+        prev_idx = -1
+        for offset in range(-1, length):
+            if start_r + offset == -1:
+                idx = 0  # insert before the beginning
+            elif start_r + offset in align:
+                # Unlike Tercom which inserts *after* the index, we insert
+                # *before* the index.
+                idx = align[start_r + offset] + 1
+            else:
+                break  # offset is out of bounds => aims past reference
+
+            if idx == prev_idx:
+                continue  # skip idx if already tried
+
+            prev_idx = idx
+
+            shifted_words = _perform_shift(words_h, start_h, length, idx)
+            assert(len(shifted_words) == len(words_h))
+
+            # Elements of the tuple are designed to replicate Tercom ranking
+            # of shifts:
+            candidate = (
+                pre_score - cached_ed(shifted_words)[0],  # highest score first
+                length,  # then, longest match first
+                -start_h,  # then, earliest match first
+                -idx,   # then, earliest target position first
+                shifted_words,
+            )
+
+            checked_candidates += 1
+
+            if not best or candidate > best:
+                best = candidate
+
+        if checked_candidates >= _MAX_SHIFT_CANDIDATES:
+            break
+
+    if not best:
+        return 0, words_h, checked_candidates
+    else:
+        best_score, _, _, _, shifted_words = best
+        return best_score, shifted_words, checked_candidates
+
+
+def _perform_shift(words: List[str], start: int, length: int, target: int) -> List[str]:
+    """Perform a shift in `words` from `start` to `target`.
+
+    :param words: Words to shift.
+    :param start: Where from.
+    :param length: How many words.
+    :param target: Where to.
+    :return: Shifted words.
+    """
+    if target < start:
+        # shift before previous position
+        return words[:target] + words[start: start + length] \
+            + words[target: start] + words[start + length:]
+    elif target > start + length:
+        # shift after previous position
+        return words[:start] + words[start + length: target] \
+            + words[start: start + length] + words[target:]
+    else:
+        # shift within the shifted string
+        return words[:start] + words[start + length: length + target] \
+            + words[start: start + length] + words[length + target:]
+
+
+def _find_shifted_pairs(words_h: List[str], words_r: List[str]):
+    """Find matching word sub-sequences in two lists of words.
+
+    Ignores sub-sequences starting at the same position.
+
+    :param words_h: First word list.
+    :param words_r: Second word list.
+    :return: Yields tuples of (h_start, r_start, length) such that:
+         words_h[h_start:h_start+length] = words_r[r_start:r_start+length]
+    """
+    n_words_h = len(words_h)
+    n_words_r = len(words_r)
+    for start_h in range(n_words_h):
+        for start_r in range(n_words_r):
+            # this is slightly different from what tercom does but this should
+            # really only kick in in degenerate cases
+            if abs(start_r - start_h) > _MAX_SHIFT_DIST:
+                continue
+
+            length = 0
+            while words_h[start_h + length] == words_r[start_r + length] and length < _MAX_SHIFT_SIZE:
+                length += 1
+
+                yield start_h, start_r, length
+
+                # If one sequence is consumed, stop processing
+                if n_words_h == start_h + length or n_words_r == start_r + length:
+                    break
+
+
+def _flip_trace(trace):
+    """Flip the trace of edit operations.
+
+    Instead of rewriting a->b, get a recipe for rewriting b->a.
+
+    Simply flips insertions and deletions.
+    """
+    return trace.translate(_FLIP_OPS)
+
+
+def trace_to_alignment(trace: str) -> Tuple[Dict, List, List]:
+    """Transform trace of edit operations into an alignment of the sequences.
+
+    :param trace: Trace of edit operations (' '=no change or 's'/'i'/'d').
+    :return: Alignment, error positions in reference, error positions in hypothesis.
+    """
+    pos_hyp = -1
+    pos_ref = -1
+    hyp_err = []
+    ref_err = []
+    align = {}
+
+    # we are rewriting a into b
+    for op in trace:
+        if op == _OP_NOP:
+            pos_hyp += 1
+            pos_ref += 1
+            align[pos_ref] = pos_hyp
+            hyp_err.append(0)
+            ref_err.append(0)
+        elif op == _OP_SUB:
+            pos_hyp += 1
+            pos_ref += 1
+            align[pos_ref] = pos_hyp
+            hyp_err.append(1)
+            ref_err.append(1)
+        elif op == _OP_INS:
+            pos_hyp += 1
+            hyp_err.append(1)
+        elif op == _OP_DEL:
+            pos_ref += 1
+            align[pos_ref] = pos_hyp
+            ref_err.append(1)
+        else:
+            raise Exception(f"unknown operation {op!r}")
+
+    return align, ref_err, hyp_err
+
+
+class BeamEditDistance:
+    """Edit distance with several features required for TER calculation.
+
+        * internal cache
+        * "beam" search
+        * tracking of edit operations
+
+    The internal self._cache works like this:
+
+    Keys are words of the hypothesis. Values are tuples (next_node, row) where:
+
+        * next_node is the cache for the next word in the sequence
+        * row is the stored row of the edit distance matrix
+
+    Effectively, caching allows to skip several rows in the edit distance
+    matrix calculation and instead, to initialize the computation with the last
+    matching matrix row.
+
+    Beam search, as implemented here, only explores a fixed-size sub-row of
+    candidates around the matrix diagonal (more precisely, it's a
+    "pseudo"-diagonal since we take the ratio of sequence lengths into account).
+
+    Tracking allows to reconstruct the optimal sequence of edit operations.
+
+    :param words_ref: A list of reference tokens.
+    """
+    def __init__(self, words_ref: List[str]):
+        """`BeamEditDistance` initializer."""
+        self._words_ref = words_ref
+        self._n_words_ref = len(self._words_ref)
+
+        # first row corresponds to insertion operations of the reference,
+        # so we do 1 edit operation per reference word
+        self._initial_row = [(i * _COST_INS, _OP_INS)
+                             for i in range(self._n_words_ref + 1)]
+
+        self._cache = {}  # type: Dict[str, Tuple]
+        self._cache_size = 0
+
+        # Precomputed empty matrix row. Contains infinities so that beam search
+        # avoids using the uninitialized cells.
+        self._empty_row = [(_INT_INFINITY, _OP_UNDEF)] * (self._n_words_ref + 1)
+
+    def __call__(self, words_hyp: List[str]) -> Tuple[int, str]:
+        """Calculate edit distance between self._words_ref and the hypothesis.
+
+        Uses cache to skip some of the computation.
+
+        :param words_hyp: Words in translation hypothesis.
+        :return: Edit distance score.
+        """
+
+        # skip initial words in the hypothesis for which we already know the
+        # edit distance
+        start_position, dist = self._find_cache(words_hyp)
+
+        # calculate the rest of the edit distance matrix
+        edit_distance, newly_created_matrix, trace = self._edit_distance(
+            words_hyp, start_position, dist)
+
+        # update our cache with the newly calculated rows
+        self._add_cache(words_hyp, newly_created_matrix)
+
+        return edit_distance, trace
+
+    def _edit_distance(self, words_h: List[str], start_h: int,
+                       cache: List[List[Tuple[int, str]]]) -> Tuple[int, List, str]:
+        """Actual edit distance calculation.
+
+        Can be initialized with the last cached row and a start position in
+        the hypothesis that it corresponds to.
+
+        :param words_h: Words in translation hypothesis.
+        :param start_h: Position from which to start the calculation.
+                        (This is zero if no cache match was found.)
+        :param cache: Precomputed rows corresponding to edit distance matrix
+                      before `start_h`.
+        :return: Edit distance value, newly computed rows to update the
+                 cache, trace.
+        """
+
+        n_words_h = len(words_h)
+
+        # initialize the rest of the matrix with infinite edit distances
+        rest_empty = [list(self._empty_row)
+                      for _ in range(n_words_h - start_h)]
+
+        dist = cache + rest_empty
+
+        assert len(dist) == n_words_h + 1
+
+        length_ratio = self._n_words_ref / n_words_h if words_h else 1
+
+        # in some crazy sentences, the difference in length is so large that
+        # we may end up with zero overlap with previous row
+        if _BEAM_WIDTH < length_ratio / 2:
+            beam_width = math.ceil(length_ratio / 2 + _BEAM_WIDTH)
+        else:
+            beam_width = _BEAM_WIDTH
+
+        # calculate the Levenshtein distance
+        for i in range(start_h + 1, n_words_h + 1):
+            pseudo_diag = math.floor(i * length_ratio)
+            min_j = max(0, pseudo_diag - beam_width)
+            max_j = min(self._n_words_ref + 1, pseudo_diag + beam_width)
+
+            if i == n_words_h:
+                max_j = self._n_words_ref + 1
+
+            for j in range(min_j, max_j):
+                if j == 0:
+                    dist[i][j] = (dist[i - 1][j][0] + _COST_DEL, _OP_DEL)
+                else:
+                    if words_h[i - 1] == self._words_ref[j - 1]:
+                        cost_sub = 0
+                        op_sub = _OP_NOP
+                    else:
+                        cost_sub = _COST_SUB
+                        op_sub = _OP_SUB
+
+                    # Tercom prefers no-op/sub, then insertion, then deletion.
+                    # But since we flip the trace and compute the alignment from
+                    # the inverse, we need to swap order of insertion and
+                    # deletion in the preference.
+                    ops = (
+                        (dist[i - 1][j - 1][0] + cost_sub, op_sub),
+                        (dist[i - 1][j][0] + _COST_DEL, _OP_DEL),
+                        (dist[i][j - 1][0] + _COST_INS, _OP_INS),
+                    )
+
+                    for op_cost, op_name in ops:
+                        if dist[i][j][0] > op_cost:
+                            dist[i][j] = op_cost, op_name
+
+        # get the trace
+        trace = ""
+        i = n_words_h
+        j = self._n_words_ref
+
+        while i > 0 or j > 0:
+            op = dist[i][j][1]
+            trace = op + trace
+            if op in (_OP_SUB, _OP_NOP):
+                i -= 1
+                j -= 1
+            elif op == _OP_INS:
+                j -= 1
+            elif op == _OP_DEL:
+                i -= 1
+            else:
+                raise Exception(f"unknown operation {op!r}")
+
+        return dist[-1][-1][0], dist[len(cache):], trace
+
+    def _add_cache(self, words_hyp: List[str], mat: List[List[Tuple]]):
+        """Add newly computed rows to cache.
+
+        Since edit distance is only calculated on the hypothesis suffix that
+        was not in cache, the number of rows in `mat` may be shorter than
+        hypothesis length. In that case, we skip over these initial words.
+
+        :param words_hyp: Hypothesis words.
+        :param mat: Edit distance matrix rows for each position.
+        """
+        if self._cache_size >= _MAX_CACHE_SIZE:
+            return
+
+        node = self._cache
+
+        n_mat = len(mat)
+
+        # how many initial words to skip
+        skip_num = len(words_hyp) - n_mat
+
+        # jump through the cache to the current position
+        for i in range(skip_num):
+            node = node[words_hyp[i]][0]
+
+        assert len(words_hyp[skip_num:]) == n_mat
+
+        # update cache with newly computed rows
+        for word, row in zip(words_hyp[skip_num:], mat):
+            if word not in node:
+                node[word] = ({}, tuple(row))
+                self._cache_size += 1
+            value = node[word]
+            node = value[0]
+
+    def _find_cache(self, words_hyp: List[str]) -> Tuple[int, List[List]]:
+        """Find the already computed rows of the edit distance matrix in cache.
+
+        Returns a partially computed edit distance matrix.
+
+        :param words_hyp: Translation hypothesis.
+        :return: Tuple (start position, dist).
+        """
+        node = self._cache
+        start_position = 0
+        dist = [self._initial_row]
+        for word in words_hyp:
+            if word in node:
+                start_position += 1
+                node, row = node[word]
+                dist.append(row)
+            else:
+                break
+
+        return start_position, dist

llmeval-env/lib/python3.10/site-packages/sacrebleu/metrics/ter.py

@@ -0,0 +1,195 @@
+"""The implementation of the TER metric (Snover et al., 2006)."""
+
+# Copyright 2020 Memsource
+#
+# 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.
+
+
+from typing import List, Dict, Sequence, Optional, Any
+
+from ..tokenizers.tokenizer_ter import TercomTokenizer
+from ..utils import sum_of_lists
+from .base import Score, Signature, Metric
+from .lib_ter import translation_edit_rate
+
+
+class TERSignature(Signature):
+    """A convenience class to represent the reproducibility signature for TER.
+
+    :param args: key-value dictionary passed from the actual metric instance.
+    """
+    def __init__(self, args: dict):
+        """`TERSignature` initializer."""
+        super().__init__(args)
+        self._abbr.update({
+            'case': 'c',
+            'tok': 't',
+            'norm': 'nr',
+            'punct': 'pn',
+            'asian': 'as',
+        })
+
+        self.info.update({
+            'case': 'mixed' if args['case_sensitive'] else 'lc',
+            'tok': args['tokenizer_signature'],
+            'norm': args['normalized'],
+            'punct': not args['no_punct'],
+            'asian': args['asian_support'],
+        })
+
+
+class TERScore(Score):
+    """A convenience class to represent TER scores.
+
+    :param score: The TER score.
+    :param num_edits: The cumulative number of edits.
+    :param ref_length: The cumulative average reference length.
+    """
+    def __init__(self, score: float, num_edits: float, ref_length: float):
+        """`TERScore` initializer."""
+        super().__init__('TER', score)
+        self.num_edits = int(num_edits)
+        self.ref_length = ref_length
+
+
+class TER(Metric):
+    """Translation edit rate (TER). A near-exact reimplementation of the Tercom
+    algorithm, produces identical results on all "sane" outputs.
+
+    Tercom original implementation: https://github.com/jhclark/tercom
+
+    The beam edit distance algorithm uses a slightly different approach (we stay
+    around the diagonal which is faster, at least in Python) so in some
+    (extreme) corner cases, the output could differ.
+
+    Caching in the edit distance is based partly on the PyTer package by Hiroyuki
+    Tanaka (MIT license). (https://github.com/aflc/pyter)
+
+    :param normalized: Enable character normalization. By default, normalizes a couple of things such as
+        newlines being stripped, retrieving XML encoded characters, and fixing tokenization for punctuation. When
+        'asian_support' is enabled, also normalizes specific Asian (CJK) character sequences, i.e.
+        split them down to the character level.
+    :param no_punct: Remove punctuation. Can be used in conjunction with 'asian_support' to also remove typical
+        punctuation markers in Asian languages (CJK).
+    :param asian_support: Enable special treatment of Asian characters. This option only has an effect when
+        'normalized' and/or 'no_punct' is enabled. If 'normalized' is also enabled, then Asian (CJK)
+        characters are split down to the character level. If 'no_punct' is enabled alongside 'asian_support',
+        specific unicode ranges for CJK and full-width punctuations are also removed.
+    :param case_sensitive: If `True`, does not lowercase sentences.
+    :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings. If given, the reference info
+        will be pre-computed and cached for faster re-computation across many systems.
+    """
+
+    _SIGNATURE_TYPE = TERSignature
+
+    def __init__(self, normalized: bool = False,
+                 no_punct: bool = False,
+                 asian_support: bool = False,
+                 case_sensitive: bool = False,
+                 references: Optional[Sequence[Sequence[str]]] = None):
+        """`TER` initializer."""
+        super().__init__()
+
+        self.no_punct = no_punct
+        self.normalized = normalized
+        self.asian_support = asian_support
+        self.case_sensitive = case_sensitive
+
+        self.tokenizer = TercomTokenizer(
+            normalized=self.normalized,
+            no_punct=self.no_punct,
+            asian_support=self.asian_support,
+            case_sensitive=self.case_sensitive,
+        )
+        self.tokenizer_signature = self.tokenizer.signature()
+
+        if references is not None:
+            self._ref_cache = self._cache_references(references)
+
+    def _preprocess_segment(self, sent: str) -> str:
+        """Given a sentence, apply tokenization if enabled.
+
+        :param sent: The input sentence string.
+        :return: The pre-processed output string.
+        """
+        return self.tokenizer(sent.rstrip())
+
+    def _compute_score_from_stats(self, stats: List[float]) -> TERScore:
+        """Computes the final score from already aggregated statistics.
+
+        :param stats: A list or numpy array of segment-level statistics.
+        :return: A `TERScore` object.
+        """
+        total_edits, sum_ref_lengths = stats[0], stats[1]
+
+        if sum_ref_lengths > 0:
+            score = total_edits / sum_ref_lengths
+        elif total_edits > 0:
+            score = 1.0  # empty reference(s) and non-empty hypothesis
+        else:
+            score = 0.0  # both reference(s) and hypothesis are empty
+
+        return TERScore(100 * score, total_edits, sum_ref_lengths)
+
+    def _aggregate_and_compute(self, stats: List[List[float]]) -> TERScore:
+        """Computes the final TER score given the pre-computed corpus statistics.
+
+        :param stats: A list of segment-level statistics
+        :return: A `TERScore` instance.
+        """
+        return self._compute_score_from_stats(sum_of_lists(stats))
+
+    def _compute_segment_statistics(
+            self, hypothesis: str, ref_kwargs: Dict) -> List[float]:
+        """Given a (pre-processed) hypothesis sentence and already computed
+        reference words, returns the segment statistics required to compute
+        the full TER score.
+
+        :param hypothesis: Hypothesis sentence.
+        :param ref_kwargs: A dictionary with `ref_words` key which is a list
+        where each sublist contains reference words.
+        :return: A two-element list that contains the 'minimum number of edits'
+        and 'the average reference length'.
+        """
+
+        ref_lengths = 0
+        best_num_edits = int(1e16)
+
+        words_hyp = hypothesis.split()
+
+        # Iterate the references
+        ref_words = ref_kwargs['ref_words']
+        for words_ref in ref_words:
+            num_edits, ref_len = translation_edit_rate(words_hyp, words_ref)
+            ref_lengths += ref_len
+            if num_edits < best_num_edits:
+                best_num_edits = num_edits
+
+        avg_ref_len = ref_lengths / len(ref_words)
+        return [best_num_edits, avg_ref_len]
+
+    def _extract_reference_info(self, refs: Sequence[str]) -> Dict[str, Any]:
+        """Given a list of reference segments, applies pre-processing & tokenization
+        and returns list of tokens for each reference.
+
+        :param refs: A sequence of strings.
+        :return: A dictionary that will be passed to `_compute_segment_statistics()`
+        through keyword arguments.
+        """
+        ref_words = []
+
+        for ref in refs:
+            ref_words.append(self._preprocess_segment(ref).split())
+
+        return {'ref_words': ref_words}

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/__init__.py

@@ -0,0 +1,2 @@
+# Base tokenizer to derive from
+from .tokenizer_base import BaseTokenizer   # noqa: F401

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_13a.py

@@ -0,0 +1,34 @@
+from functools import lru_cache
+from .tokenizer_base import BaseTokenizer
+from .tokenizer_re import TokenizerRegexp
+
+
+class Tokenizer13a(BaseTokenizer):
+
+    def signature(self):
+        return '13a'
+
+    def __init__(self):
+        self._post_tokenizer = TokenizerRegexp()
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Tokenizes an input line using a relatively minimal tokenization
+        that is however equivalent to mteval-v13a, used by WMT.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+
+        # language-independent part:
+        line = line.replace('<skipped>', '')
+        line = line.replace('-\n', '')
+        line = line.replace('\n', ' ')
+
+        if '&' in line:
+            line = line.replace('&quot;', '"')
+            line = line.replace('&amp;', '&')
+            line = line.replace('&lt;', '<')
+            line = line.replace('&gt;', '>')
+
+        return self._post_tokenizer(f' {line} ')

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_base.py

@@ -0,0 +1,19 @@
+class BaseTokenizer:
+    """A base dummy tokenizer to derive from."""
+
+    def signature(self):
+        """
+        Returns a signature for the tokenizer.
+
+        :return: signature string
+        """
+        raise NotImplementedError()
+
+    def __call__(self, line):
+        """
+        Tokenizes an input line with the tokenizer.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        raise NotImplementedError()

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_char.py

@@ -0,0 +1,19 @@
+from functools import lru_cache
+from .tokenizer_base import BaseTokenizer
+
+
+class TokenizerChar(BaseTokenizer):
+    def signature(self):
+        return 'char'
+
+    def __init__(self):
+        pass
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Tokenizes all the characters in the input line.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        return " ".join((char for char in line))

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_intl.py

@@ -0,0 +1,50 @@
+from functools import lru_cache
+
+import regex
+
+from .tokenizer_base import BaseTokenizer
+
+
+class TokenizerV14International(BaseTokenizer):
+    """Tokenizes a string following the official BLEU implementation.
+
+    See github.com/moses-smt/mosesdecoder/blob/master/scripts/generic/mteval-v14.pl#L954-L983
+
+    In our case, the input string is expected to be just one line.
+    We just tokenize on punctuation and symbols,
+    except when a punctuation is preceded and followed by a digit
+    (e.g. a comma/dot as a thousand/decimal separator).
+    We do not recover escaped forms of punctuations such as ' or >
+    as these should never appear in MT system outputs (see issue #138)
+
+    Note that a number (e.g., a year) followed by a dot at the end of
+    sentence is NOT tokenized, i.e. the dot stays with the number because
+    `s/(\\p{P})(\\P{N})/ $1 $2/g` does not match this case (unless we add a
+    space after each sentence). However, this error is already in the
+    original mteval-v14.pl and we want to be consistent with it.
+    The error is not present in the non-international version,
+    which uses `$norm_text = " $norm_text "`.
+
+    :param line: the input string to tokenize.
+    :return: The tokenized string.
+    """
+
+    def signature(self):
+        return 'intl'
+
+    def __init__(self):
+        self._re = [
+            # Separate out punctuations preceeded by a non-digit
+            (regex.compile(r'(\P{N})(\p{P})'), r'\1 \2 '),
+            # Separate out punctuations followed by a non-digit
+            (regex.compile(r'(\p{P})(\P{N})'), r' \1 \2'),
+            # Separate out symbols
+            (regex.compile(r'(\p{S})'), r' \1 '),
+        ]
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line: str) -> str:
+        for (_re, repl) in self._re:
+            line = _re.sub(repl, line)
+
+        return ' '.join(line.split())

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_ja_mecab.py

@@ -0,0 +1,52 @@
+from functools import lru_cache
+
+try:
+    import MeCab
+    import ipadic
+except ImportError:
+    # Don't fail until the tokenizer is actually used
+    MeCab = None
+
+from .tokenizer_base import BaseTokenizer
+
+FAIL_MESSAGE = """
+Japanese tokenization requires extra dependencies, but you do not have them installed.
+Please install them like so.
+
+    pip install sacrebleu[ja]
+"""
+
+
+class TokenizerJaMecab(BaseTokenizer):
+    def __init__(self):
+        if MeCab is None:
+            raise RuntimeError(FAIL_MESSAGE)
+        self.tagger = MeCab.Tagger(ipadic.MECAB_ARGS + " -Owakati")
+
+        # make sure the dictionary is IPA
+        d = self.tagger.dictionary_info()
+        assert d.size == 392126, \
+            "Please make sure to use the IPA dictionary for MeCab"
+        # This asserts that no user dictionary has been loaded
+        assert d.next is None
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """
+        Tokenizes an Japanese input line using MeCab morphological analyzer.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        line = line.strip()
+        sentence = self.tagger.parse(line).strip()
+        return sentence
+
+    def signature(self):
+        """
+        Returns the MeCab parameters.
+
+        :return: signature string
+        """
+        signature = self.tagger.version() + "-IPA"
+        return 'ja-mecab-' + signature

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_ko_mecab.py

@@ -0,0 +1,52 @@
+from functools import lru_cache
+
+try:
+    import mecab_ko as MeCab
+    import mecab_ko_dic
+except ImportError:
+    # Don't fail until the tokenizer is actually used
+    MeCab = None
+
+from .tokenizer_base import BaseTokenizer
+
+FAIL_MESSAGE = """
+Korean tokenization requires extra dependencies, but you do not have them installed.
+Please install them like so.
+
+    pip install sacrebleu[ko]
+"""
+
+
+class TokenizerKoMecab(BaseTokenizer):
+    def __init__(self):
+        if MeCab is None:
+            raise RuntimeError(FAIL_MESSAGE)
+        self.tagger = MeCab.Tagger(mecab_ko_dic.MECAB_ARGS + " -Owakati")
+
+        # make sure the dictionary is mecab-ko-dic
+        d = self.tagger.dictionary_info()
+        assert d.size == 811795, \
+            "Please make sure to use the mecab-ko-dic for MeCab-ko"
+        # This asserts that no user dictionary has been loaded
+        assert d.next is None
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """
+        Tokenizes an Korean input line using MeCab-ko morphological analyzer.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        line = line.strip()
+        sentence = self.tagger.parse(line).strip()
+        return sentence
+
+    def signature(self):
+        """
+        Returns the MeCab-ko parameters.
+
+        :return: signature string
+        """
+        signature = self.tagger.version() + "-KO"
+        return 'ko-mecab-' + signature

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_none.py

@@ -0,0 +1,10 @@
+from .tokenizer_base import BaseTokenizer
+
+class NoneTokenizer(BaseTokenizer):
+    """Don't apply any tokenization. Not recommended!."""
+
+    def signature(self):
+        return 'none'
+
+    def __call__(self, line):
+        return line

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_re.py

@@ -0,0 +1,38 @@
+from functools import lru_cache
+import re
+
+from .tokenizer_base import BaseTokenizer
+
+
+class TokenizerRegexp(BaseTokenizer):
+
+    def signature(self):
+        return 're'
+
+    def __init__(self):
+        self._re = [
+            # language-dependent part (assuming Western languages)
+            (re.compile(r'([\{-\~\[-\` -\&\(-\+\:-\@\/])'), r' \1 '),
+            # tokenize period and comma unless preceded by a digit
+            (re.compile(r'([^0-9])([\.,])'), r'\1 \2 '),
+            # tokenize period and comma unless followed by a digit
+            (re.compile(r'([\.,])([^0-9])'), r' \1 \2'),
+            # tokenize dash when preceded by a digit
+            (re.compile(r'([0-9])(-)'), r'\1 \2 '),
+            # one space only between words
+            # NOTE: Doing this in Python (below) is faster
+            # (re.compile(r'\s+'), r' '),
+        ]
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Common post-processing tokenizer for `13a` and `zh` tokenizers.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        for (_re, repl) in self._re:
+            line = _re.sub(repl, line)
+
+        # no leading or trailing spaces, single space within words
+        return ' '.join(line.split())

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_spm.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from functools import lru_cache
+from ..utils import SACREBLEU_DIR, download_file
+from .tokenizer_base import BaseTokenizer
+
+sacrelogger = logging.getLogger('sacrebleu')
+
+
+SPM_MODELS = {
+    "spm": {
+        "url": "https://dl.fbaipublicfiles.com/fairseq/models/flores/sacrebleu_tokenizer_spm.model",
+        "signature": "flores101",
+    },
+    # same as the default of "spm"
+    "flores101": {
+        "url": "https://dl.fbaipublicfiles.com/fairseq/models/flores/sacrebleu_tokenizer_spm.model",
+        "signature": "flores101",
+    },
+    "flores200": {
+        "url": "https://tinyurl.com/flores200sacrebleuspm",
+        "signature": "flores200",
+    },
+}
+
+class TokenizerSPM(BaseTokenizer):
+    def signature(self):
+        return self.name
+
+    def __init__(self, key="spm"):
+        self.name = SPM_MODELS[key]["signature"]
+
+        if key == "spm":
+            sacrelogger.warn("Tokenizer 'spm' has been changed to 'flores101', and may be removed in the future.")
+
+        try:
+            import sentencepiece as spm
+        except (ImportError, ModuleNotFoundError):
+            raise ImportError(
+                '\n\nPlease install the sentencepiece library for SPM tokenization:'
+                '\n\n  pip install sentencepiece '
+            )
+        self.sp = spm.SentencePieceProcessor()
+
+        model_path = os.path.join(SACREBLEU_DIR, "models", os.path.basename(SPM_MODELS[key]["url"]))
+        if not os.path.exists(model_path):
+            url = SPM_MODELS[self.name]["url"]
+            download_file(url, model_path)
+        self.sp.Load(model_path)
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Tokenizes all the characters in the input line.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        return " ".join(self.sp.EncodeAsPieces(line))
+
+
+class Flores200Tokenizer(TokenizerSPM):
+    def __init__(self):
+        super().__init__("flores200")
+
+class Flores101Tokenizer(TokenizerSPM):
+    def __init__(self):
+        super().__init__("flores101")

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_ter.py

@@ -0,0 +1,171 @@
+# Copyright 2020 Memsource
+#
+# 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.
+
+
+import re
+from functools import lru_cache
+
+from .tokenizer_base import BaseTokenizer
+
+
+def _normalize_general_and_western(sent: str) -> str:
+    # language-independent (general) part
+
+    # strip end-of-line hyphenation and join lines
+    sent = re.sub(r"\n-", "", sent)
+
+    # join lines
+    sent = re.sub(r"\n", " ", sent)
+
+    # handle XML escaped symbols
+    sent = re.sub(r""", "\"", sent)
+    sent = re.sub(r"&", "&", sent)
+    sent = re.sub(r"&lt;", "<", sent)
+    sent = re.sub(r"&gt;", ">", sent)
+
+    # language-dependent (Western) part
+    sent = f" {sent} "
+
+    # tokenize punctuation
+    sent = re.sub(r"([{-~[-` -&(-+:-@/])", r" \1 ", sent)
+
+    # handle possesives
+    sent = re.sub(r"'s ", r" 's ", sent)
+    sent = re.sub(r"'s$", r" 's", sent)
+
+    # tokenize period and comma unless preceded by a digit
+    sent = re.sub(r"([^0-9])([\.,])", r"\1 \2 ", sent)
+
+    # tokenize period and comma unless followed by a digit
+    sent = re.sub(r"([\.,])([^0-9])", r" \1 \2", sent)
+
+    # tokenize dash when preceded by a digit
+    sent = re.sub(r"([0-9])(-)", r"\1 \2 ", sent)
+
+    return sent
+
+
+def _normalize_asian(sent: str) -> str:
+    # Split Chinese chars and Japanese kanji down to character level
+
+    # 4E00—9FFF CJK Unified Ideographs
+    # 3400—4DBF CJK Unified Ideographs Extension A
+    sent = re.sub(r"([\u4e00-\u9fff\u3400-\u4dbf])", r" \1 ", sent)
+
+    # 31C0—31EF CJK Strokes
+    # 2E80—2EFF CJK Radicals Supplement
+    sent = re.sub(r"([\u31c0-\u31ef\u2e80-\u2eff])", r" \1 ", sent)
+
+    # 3300—33FF CJK Compatibility
+    # F900—FAFF CJK Compatibility Ideographs
+    # FE30—FE4F CJK Compatibility Forms
+    sent = re.sub(
+        r"([\u3300-\u33ff\uf900-\ufaff\ufe30-\ufe4f])", r" \1 ", sent)
+
+    # 3200—32FF Enclosed CJK Letters and Months
+    sent = re.sub(r"([\u3200-\u3f22])", r" \1 ", sent)
+
+    # Split Hiragana, Katakana, and KatakanaPhoneticExtensions
+    # only when adjacent to something else
+    # 3040—309F Hiragana
+    # 30A0—30FF Katakana
+    # 31F0—31FF Katakana Phonetic Extensions
+    sent = re.sub(
+        r"(^|^[\u3040-\u309f])([\u3040-\u309f]+)(?=$|^[\u3040-\u309f])",
+        r"\1 \2 ", sent)
+    sent = re.sub(
+        r"(^|^[\u30a0-\u30ff])([\u30a0-\u30ff]+)(?=$|^[\u30a0-\u30ff])",
+        r"\1 \2 ", sent)
+    sent = re.sub(
+        r"(^|^[\u31f0-\u31ff])([\u31f0-\u31ff]+)(?=$|^[\u31f0-\u31ff])",
+        r"\1 \2 ", sent)
+
+    sent = re.sub(TercomTokenizer.ASIAN_PUNCT, r" \1 ", sent)
+    sent = re.sub(TercomTokenizer.FULL_WIDTH_PUNCT, r" \1 ", sent)
+    return sent
+
+
+def _remove_punct(sent: str) -> str:
+    return re.sub(r"[\.,\?:;!\"\(\)]", "", sent)
+
+
+def _remove_asian_punct(sent: str) -> str:
+    sent = re.sub(TercomTokenizer.ASIAN_PUNCT, r"", sent)
+    sent = re.sub(TercomTokenizer.FULL_WIDTH_PUNCT, r"", sent)
+    return sent
+
+
+class TercomTokenizer(BaseTokenizer):
+    """Re-implementation of Tercom Tokenizer in Python 3.
+
+    See src/ter/core/Normalizer.java in https://github.com/jhclark/tercom
+
+    Note that Python doesn't support named Unicode blocks so the mapping for
+    relevant blocks was taken from here:
+
+    https://unicode-table.com/en/blocks/
+    """
+    ASIAN_PUNCT = r"([\u3001\u3002\u3008-\u3011\u3014-\u301f\uff61-\uff65\u30fb])"
+    FULL_WIDTH_PUNCT = r"([\uff0e\uff0c\uff1f\uff1a\uff1b\uff01\uff02\uff08\uff09])"
+
+    def __init__(self,
+                 normalized: bool = False,
+                 no_punct: bool = False,
+                 asian_support: bool = False,
+                 case_sensitive: bool = False):
+        """Initialize the tokenizer.
+
+        :param normalized: Enable character normalization. By default, normalizes a couple of things such as
+            newlines being stripped, retrieving XML encoded characters, and fixing tokenization for punctuation. When
+            'asian_support' is enabled, also normalizes specific Asian (CJK) character sequences, i.e.
+            split them down to the character level.
+        :param no_punct: Remove punctuation. Can be used in conjunction with 'asian_support' to also remove typical
+            punctuation markers in Asian languages (CJK).
+        :param asian_support: Enable special treatment of Asian characters. This option only has an effect when
+            'normalized' and/or 'no_punct' is enabled. If 'normalized' is also enabled, then Asian (CJK)
+            characters are split down to the character level. If 'no_punct' is enabled alongside 'asian_support',
+            specific unicode ranges for CJK and full-width punctuations are also removed.
+        :param case_sensitive: Enable case sensitivity, i.e., do not lower case data.
+        """
+        self._normalized = normalized
+        self._no_punct = no_punct
+        self._asian_support = asian_support
+        self._case_sensitive = case_sensitive
+
+    @lru_cache(maxsize=2**16)
+    # Although the cache is shared across different instances, same sentence
+    # queries do not return invalid returns across different instances since
+    # `self` becomes part of the query as well.
+    def __call__(self, sent: str) -> str:
+        if not sent:
+            return ""
+
+        if not self._case_sensitive:
+            sent = sent.lower()
+
+        if self._normalized:
+            sent = _normalize_general_and_western(sent)
+            if self._asian_support:
+                sent = _normalize_asian(sent)
+
+        if self._no_punct:
+            sent = _remove_punct(sent)
+            if self._asian_support:
+                sent = _remove_asian_punct(sent)
+
+        # Strip extra whitespaces
+        return ' '.join(sent.split())
+
+    def signature(self):
+        return 'tercom'

llmeval-env/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_zh.py

@@ -0,0 +1,119 @@
+# Copyright 2017--2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not
+# use this file except in compliance with the License. A copy of the License
+# is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+##############
+
+# MIT License
+# Copyright (c) 2017 - Shujian Huang <[email protected]>
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Author: Shujian Huang [email protected]
+
+
+from functools import lru_cache
+
+from .tokenizer_base import BaseTokenizer
+from .tokenizer_re import TokenizerRegexp
+
+_UCODE_RANGES = [
+    (u'\u3400', u'\u4db5'),  # CJK Unified Ideographs Extension A, release 3.0
+    (u'\u4e00', u'\u9fa5'),  # CJK Unified Ideographs, release 1.1
+    (u'\u9fa6', u'\u9fbb'),  # CJK Unified Ideographs, release 4.1
+    (u'\uf900', u'\ufa2d'),  # CJK Compatibility Ideographs, release 1.1
+    (u'\ufa30', u'\ufa6a'),  # CJK Compatibility Ideographs, release 3.2
+    (u'\ufa70', u'\ufad9'),  # CJK Compatibility Ideographs, release 4.1
+    (u'\u20000', u'\u2a6d6'),  # (UTF16) CJK Unified Ideographs Extension B, release 3.1
+    (u'\u2f800', u'\u2fa1d'),  # (UTF16) CJK Compatibility Supplement, release 3.1
+    (u'\uff00', u'\uffef'),  # Full width ASCII, full width of English punctuation,
+                             # half width Katakana, half wide half width kana, Korean alphabet
+    (u'\u2e80', u'\u2eff'),  # CJK Radicals Supplement
+    (u'\u3000', u'\u303f'),  # CJK punctuation mark
+    (u'\u31c0', u'\u31ef'),  # CJK stroke
+    (u'\u2f00', u'\u2fdf'),  # Kangxi Radicals
+    (u'\u2ff0', u'\u2fff'),  # Chinese character structure
+    (u'\u3100', u'\u312f'),  # Phonetic symbols
+    (u'\u31a0', u'\u31bf'),  # Phonetic symbols (Taiwanese and Hakka expansion)
+    (u'\ufe10', u'\ufe1f'),
+    (u'\ufe30', u'\ufe4f'),
+    (u'\u2600', u'\u26ff'),
+    (u'\u2700', u'\u27bf'),
+    (u'\u3200', u'\u32ff'),
+    (u'\u3300', u'\u33ff'),
+]
+
+
+class TokenizerZh(BaseTokenizer):
+
+    def signature(self):
+        return 'zh'
+
+    def __init__(self):
+        self._post_tokenizer = TokenizerRegexp()
+
+    @staticmethod
+    @lru_cache(maxsize=2**16)
+    def _is_chinese_char(uchar):
+        """
+        :param uchar: input char in unicode
+        :return: whether the input char is a Chinese character.
+        """
+        for start, end in _UCODE_RANGES:
+            if start <= uchar <= end:
+                return True
+        return False
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """The tokenization of Chinese text in this script contains two
+        steps: separate each Chinese characters (by utf-8 encoding); tokenize
+        the non Chinese part (following the `13a` i.e. mteval tokenizer).
+
+        Author: Shujian Huang [email protected]
+
+        :param line: input sentence
+        :return: tokenized sentence
+        """
+
+        line = line.strip()
+        line_in_chars = ""
+
+        # TODO: the below code could probably be replaced with the following:
+        # @ozan: Gives slightly different scores, need to investigate
+        # import regex
+        # line = regex.sub(r'(\p{Han})', r' \1 ', line)
+        for char in line:
+            if self._is_chinese_char(char):
+                line_in_chars += " "
+                line_in_chars += char
+                line_in_chars += " "
+            else:
+                line_in_chars += char
+
+        return self._post_tokenizer(line_in_chars)