code: 
  
  
  
  
  
  import sacrebleu as scb
  from packaging import version
  
  import datasets
  
  
  _UpperCamelCase       = '''\\n@inproceedings{post-2018-call,\n    title = "A Call for Clarity in Reporting {BLEU} Scores",\n    author = "Post, Matt",\n    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n    month = oct,\n    year = "2018",\n    address = "Belgium, Brussels",\n    publisher = "Association for Computational Linguistics",\n    url = "https://www.aclweb.org/anthology/W18-6319",\n    pages = "186--191",\n}\n'''
  
  _UpperCamelCase       = '''\\nSacreBLEU provides hassle-free computation of shareable, comparable, and reproducible BLEU scores.\nInspired by Rico Sennrich\'s `multi-bleu-detok.perl`, it produces the official WMT scores but works with plain text.\nIt also knows all the standard test sets and handles downloading, processing, and tokenization for you.\n\nSee the [README.md] file at https://github.com/mjpost/sacreBLEU for more information.\n'''
  
  _UpperCamelCase       = '''\nProduces BLEU scores along with its sufficient statistics\nfrom a source against one or more references.\n\nArgs:\n    predictions (`list` of `str`): list of translations to score. Each translation should be tokenized into a list of tokens.\n    references (`list` of `list` of `str`): A list of lists of references. The contents of the first sub-list are the references for the first prediction, the contents of the second sub-list are for the second prediction, etc. Note that there must be the same number of references for each prediction (i.e. all sub-lists must be of the same length).\n    smooth_method (`str`): The smoothing method to use, defaults to `\'exp\'`. Possible values are:\n        - `\'none\'`: no smoothing\n        - `\'floor\'`: increment zero counts\n        - `\'add-k\'`: increment num/denom by k for n>1\n        - `\'exp\'`: exponential decay\n    smooth_value (`float`): The smoothing value. Only valid when `smooth_method=\'floor\'` (in which case `smooth_value` defaults to `0.1`) or `smooth_method=\'add-k\'` (in which case `smooth_value` defaults to `1`).\n    tokenize (`str`): Tokenization method to use for BLEU. If not provided, defaults to `\'zh\'` for Chinese, `\'ja-mecab\'` for Japanese and `\'13a\'` (mteval) otherwise. Possible values are:\n        - `\'none\'`: No tokenization.\n        - `\'zh\'`: Chinese tokenization.\n        - `\'13a\'`: mimics the `mteval-v13a` script from Moses.\n        - `\'intl\'`: International tokenization, mimics the `mteval-v14` script from Moses\n        - `\'char\'`: Language-agnostic character-level tokenization.\n        - `\'ja-mecab\'`: Japanese tokenization. Uses the [MeCab tokenizer](https://pypi.org/project/mecab-python3).\n    lowercase (`bool`): If `True`, lowercases the input, enabling case-insensitivity. Defaults to `False`.\n    force (`bool`): If `True`, insists that your tokenized input is actually detokenized. Defaults to `False`.\n    use_effective_order (`bool`): If `True`, stops including n-gram orders for which precision is 0. This should be `True`, if sentence-level BLEU will be computed. Defaults to `False`.\n\nReturns:\n    \'score\': BLEU score,\n    \'counts\': Counts,\n    \'totals\': Totals,\n    \'precisions\': Precisions,\n    \'bp\': Brevity penalty,\n    \'sys_len\': predictions length,\n    \'ref_len\': reference length,\n\nExamples:\n\n    Example 1:\n        >>> predictions = ["hello there general kenobi", "foo bar foobar"]\n        >>> references = [["hello there general kenobi", "hello there !"], ["foo bar foobar", "foo bar foobar"]]\n        >>> sacrebleu = datasets.load_metric("sacrebleu")\n        >>> results = sacrebleu.compute(predictions=predictions, references=references)\n        >>> print(list(results.keys()))\n        [\'score\', \'counts\', \'totals\', \'precisions\', \'bp\', \'sys_len\', \'ref_len\']\n        >>> print(round(results["score"], 1))\n        100.0\n\n    Example 2:\n        >>> predictions = ["hello there general kenobi",\n        ...                 "on our way to ankh morpork"]\n        >>> references = [["hello there general kenobi", "hello there !"],\n        ...                 ["goodbye ankh morpork", "ankh morpork"]]\n        >>> sacrebleu = datasets.load_metric("sacrebleu")\n        >>> results = sacrebleu.compute(predictions=predictions,\n        ...                             references=references)\n        >>> print(list(results.keys()))\n        [\'score\', \'counts\', \'totals\', \'precisions\', \'bp\', \'sys_len\', \'ref_len\']\n        >>> print(round(results["score"], 1))\n        39.8\n'''
  
  
  
  
  @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,   _KWARGS_DESCRIPTION    )
  class 				_lowerCamelCase (    datasets.Metric    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   List[str]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          if version.parse(scb.__version__   ) < version.parse("1.4.12"   ):
            raise ImportWarning(
                "To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n"
                "You can install it with `pip install \"sacrebleu>=1.4.12\"`."   )
          return datasets.MetricInfo(
              description=_DESCRIPTION				,						citation=_CITATION				,						homepage="https://github.com/mjpost/sacreBLEU"				,						inputs_description=_KWARGS_DESCRIPTION				,						features=datasets.Features(
                  {
                      "predictions": datasets.Value("string"				,						id="sequence"   ),
                      "references": datasets.Sequence(datasets.Value("string"				,						id="sequence"   )				,						id="references"   ),
                  }   )				,						codebase_urls=["https://github.com/mjpost/sacreBLEU"]				,						reference_urls=[
                  "https://github.com/mjpost/sacreBLEU",
                  "https://en.wikipedia.org/wiki/BLEU",
                  "https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213",
              ]				,						)
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase="exp"				,						UpperCAmelCase=None				,						UpperCAmelCase=False				,						UpperCAmelCase=False				,						UpperCAmelCase=None				,						UpperCAmelCase=False				,						)       ->   Union[str, Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				List[str]        =       len(references[0]   )
          if any(len(SCREAMING_SNAKE_CASE_   ) != references_per_prediction for refs in references   ):
            raise ValueError("Sacrebleu requires the same number of references for each prediction"   )
          __snake_case   :				int        =       [[refs[i] for refs in references] for i in range(SCREAMING_SNAKE_CASE_   )]
          __snake_case   :				List[str]        =       scb.corpus_bleu(
              SCREAMING_SNAKE_CASE_				,						SCREAMING_SNAKE_CASE_				,						smooth_method=SCREAMING_SNAKE_CASE_				,						smooth_value=SCREAMING_SNAKE_CASE_				,						force=SCREAMING_SNAKE_CASE_				,						lowercase=SCREAMING_SNAKE_CASE_				,						use_effective_order=SCREAMING_SNAKE_CASE_				,						**({"tokenize": tokenize} if tokenize else {})				,						)
          __snake_case   :				Tuple        =       {
              "score": output.score,
              "counts": output.counts,
              "totals": output.totals,
              "precisions": output.precisions,
              "bp": output.bp,
              "sys_len": output.sys_len,
              "ref_len": output.ref_len,
          }
          return output_dict
  
  
style_context: 
  
  
  
  
  
  from __future__ import annotations
  
  from collections.abc import Callable
  from typing import Generic, TypeVar
  
  _UpperCamelCase       = TypeVar('''T''')
  _UpperCamelCase       = TypeVar('''U''')
  
  
  
  
  class 				_lowerCamelCase (    Generic[T, U]    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        def __init__( self				,						UpperCAmelCase				,						UpperCAmelCase   )       ->   Dict:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Any        =       key
          __snake_case   :				Tuple        =       val
          __snake_case   :				int        =       0
          __snake_case   :				DoubleLinkedListNode[T, U] | None        =       None
          __snake_case   :				DoubleLinkedListNode[T, U] | None        =       None
  
  
  
  
  
  
  
        def __repr__( self   )       ->   str:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          return "Node: key: {}, val: {}, freq: {}, has next: {}, has prev: {}".format(
              self.key				,						self.val				,						self.freq				,						self.next is not None				,						self.prev is not None   )
  
  
  
  
  class 				_lowerCamelCase (    Generic[T, U]    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        def __init__( self   )       ->   None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				DoubleLinkedListNode[T, U]        =       DoubleLinkedListNode(UpperCAmelCase				,						UpperCAmelCase   )
          __snake_case   :				DoubleLinkedListNode[T, U]        =       DoubleLinkedListNode(UpperCAmelCase				,						UpperCAmelCase   )
          __snake_case    ,   __snake_case   :				Any        =       self.rear, self.head
  
  
  
  
  
  
  
        def __repr__( self   )       ->   str:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Union[str, Any]        =       ["DoubleLinkedList"]
          __snake_case   :				List[Any]        =       self.head
          while node.next is not None:
            rep.append(str(UpperCAmelCase   )   )
            __snake_case   :				List[Any]        =       node.next
          rep.append(str(self.rear   )   )
          return ",\n    ".join(UpperCAmelCase   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self				,						UpperCAmelCase   )       ->   None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Dict        =       self.rear.prev
  
          # All nodes other than self.head are guaranteed to have non-None previous
          assert previous is not None
  
          __snake_case   :				int        =       node
          __snake_case   :				List[str]        =       previous
          __snake_case   :				Optional[int]        =       node
          __snake_case   :				int        =       self.rear
          node.freq += 1
          self._position_node(UpperCAmelCase   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self				,						UpperCAmelCase   )       ->   None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          while node.prev is not None and node.prev.freq > node.freq:
            # swap node with previous node
            __snake_case   :				List[Any]        =       node.prev
  
            __snake_case   :				Dict        =       previous_node.prev
            __snake_case   :				Union[str, Any]        =       node.prev
            __snake_case   :				Union[str, Any]        =       previous_node
            __snake_case   :				int        =       node
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self				,						UpperCAmelCase   )       ->   DoubleLinkedListNode[T, U] | None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          if node.prev is None or node.next is None:
            return None
  
          __snake_case   :				Optional[int]        =       node.next
          __snake_case   :				Optional[Any]        =       node.prev
          __snake_case   :				Optional[int]        =       None
          __snake_case   :				Any        =       None
          return node
  
  
  
  
  class 				_lowerCamelCase (    Generic[T, U]    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        UpperCAmelCase_						:      dict[Callable[[T], U], LFUCache[T, U]]       ={}
  
  
  
  
  
  
  
        def __init__( self				,						UpperCAmelCase   )       ->   Tuple:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				DoubleLinkedList[T, U]        =       DoubleLinkedList()
          __snake_case   :				str        =       capacity
          __snake_case   :				str        =       0
          __snake_case   :				Optional[int]        =       0
          __snake_case   :				Any        =       0
          __snake_case   :				dict[T, DoubleLinkedListNode[T, U]]        =       {}
  
  
  
  
  
  
  
        def __repr__( self   )       ->   str:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          return (
              F"""CacheInfo(hits={self.hits}, misses={self.miss}, """
              F"""capacity={self.capacity}, current_size={self.num_keys})"""
          )
  
  
  
  
  
  
  
        def __contains__( self				,						UpperCAmelCase   )       ->   bool:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          return key in self.cache
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self				,						UpperCAmelCase   )       ->   U | None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          if key in self.cache:
            self.hits += 1
            __snake_case   :				DoubleLinkedListNode[T, U]        =       self.cache[key]
            __snake_case   :				Union[str, Any]        =       self.list.remove(self.cache[key]   )
            assert node == value_node
  
            # node is guaranteed not None because it is in self.cache
            assert node is not None
            self.list.add(UpperCAmelCase   )
            return node.val
          self.miss += 1
          return None
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self				,						UpperCAmelCase				,						UpperCAmelCase   )       ->   None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          if key not in self.cache:
            if self.num_keys >= self.capacity:
              # delete first node when over capacity
              __snake_case   :				Optional[Any]        =       self.list.head.next
  
              # guaranteed to have a non-None first node when num_keys > 0
              # explain to type checker via assertions
              assert first_node is not None
              assert first_node.key is not None
              assert self.list.remove(UpperCAmelCase   ) is not None
              # first_node guaranteed to be in list
  
              del self.cache[first_node.key]
              self.num_keys -= 1
            __snake_case   :				Union[str, Any]        =       DoubleLinkedListNode(UpperCAmelCase				,						UpperCAmelCase   )
            self.list.add(self.cache[key]   )
            self.num_keys += 1
  
          else:
            __snake_case   :				Union[str, Any]        =       self.list.remove(self.cache[key]   )
            assert node is not None  # node guaranteed to be in list
            __snake_case   :				Optional[Any]        =       value
            self.list.add(UpperCAmelCase   )
  
  
  
  
  
  
  
        @classmethod
        def 						UpperCAmelCase		( cls				,						UpperCAmelCase = 128   )       ->   Callable[[Callable[[T], U]], Callable[..., U]]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          def cache_decorator_inner(UpperCAmelCase   ) -> Callable[..., U]:
            def cache_decorator_wrapper(*UpperCAmelCase   ) -> U:
              if func not in cls.decorator_function_to_instance_map:
                __snake_case   :				str        =       LFUCache(UpperCAmelCase   )
  
              __snake_case   :				Dict        =       cls.decorator_function_to_instance_map[func].get(args[0]   )
              if result is None:
                __snake_case   :				Optional[int]        =       func(*UpperCAmelCase   )
                cls.decorator_function_to_instance_map[func].put(args[0]				,						UpperCAmelCase   )
              return result
  
            def cache_info() -> LFUCache[T, U]:
              return cls.decorator_function_to_instance_map[func]
  
            setattr(UpperCAmelCase				,						"cache_info"				,						UpperCAmelCase   )  # noqa: B010
  
            return cache_decorator_wrapper
  
          return cache_decorator_inner
  
  
  if __name__ == "__main__":
       import doctest
  
       doctest.testmod()
  
  