import unittest

from cer import CER


_SCREAMING_SNAKE_CASE   						=    CER()







class 					UpperCAmelCase_				(							unittest.TestCase    ):




    def 						__lowerCamelCase (					self  :   List[str]   )	-> int:
      a__     		=     ["White House"]
      a__     		=     ["white house"]
      # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.1_818_181_818   ) < 1e-6   )




    def 						__lowerCamelCase (					self  :   Optional[int]   )	-> Dict:
      a__     		=     ["were wolf"]
      a__     		=     ["werewolf"]
      # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.1_111_111   ) < 1e-6   )

      a__     		=     ["werewolf"]
      a__     		=     ["weae     wolf"]
      # S = 1, D = 1, I = 0, N = 8, CER = 0.25
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.25   ) < 1e-6   )

      # consecutive whitespaces case 1
      a__     		=     ["were wolf"]
      a__     		=     ["were               wolf"]
      # S = 0, D = 0, I = 0, N = 9, CER = 0
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.0   ) < 1e-6   )

      # consecutive whitespaces case 2
      a__     		=     ["were   wolf"]
      a__     		=     ["were               wolf"]
      # S = 0, D = 0, I = 0, N = 9, CER = 0
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.0   ) < 1e-6   )




    def 						__lowerCamelCase (					self  :   Optional[Any]   )	-> Union[str, Any]:
      a__     		=     ["werewolf"]
      a__     		=     ["weaewolf"]
      # S = 1, D = 0, I = 0, N = 8, CER = 0.125
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




    def 						__lowerCamelCase (					self  :   List[Any]   )	-> Dict:
      a__     		=     ["werewolf"]
      a__     		=     ["wereawolf"]
      # S = 0, D = 1, I = 0, N = 8, CER = 0.125
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




    def 						__lowerCamelCase (					self  :   Tuple   )	-> str:
      a__     		=     ["werewolf"]
      a__     		=     ["wereolf"]
      # S = 0, D = 0, I = 1, N = 8, CER = 0.125
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




    def 						__lowerCamelCase (					self  :   Union[str, Any]   )	-> Tuple:
      a__     		=     ["werewolf"]
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertEqual(lowerCAmelCase      ,      0.0   )




    def 						__lowerCamelCase (					self  :   Optional[Any]   )	-> Optional[Any]:
      a__     		=     ["werewolf", "I am your father"]
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertEqual(lowerCAmelCase      ,      0.0   )

      a__     		=     ["werewolf", "I am your father", "doge"]
      a__     		=     ["werxwolf", "I       am your father", "doge"]
      # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.03_571_428   ) < 1e-6   )




    def 						__lowerCamelCase (					self  :   List[Any]   )	-> List[str]:
      a__     		=     ["My hovercraft", "is full of eels"]
      a__     		=     ["My hovercraft is full", " of eels"]
      # S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
      # whitespace at the front of " of eels" will be strip during preporcessing
      # so need to insert 2 whitespaces
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase      ,      concatenate_texts=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.071_428   ) < 1e-6   )




    def 						__lowerCamelCase (					self  :   List[Any]   )	-> List[str]:
      a__     		=     ["我能吞下玻璃而不伤身体"]
      a__     		=     [" 能吞虾玻璃而 不霜身体啦"]
      # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.4_545_454_545   ) < 1e-6   )

      a__     		=     ["我能吞下玻璃", "而不伤身体"]
      a__     		=     ["我    能 吞 下 玻 璃", "而不伤身体"]
      # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertTrue(abs(char_error_rate - 0.454_545_454_545   ) < 1e-6   )

      a__     		=     ["我能吞下玻璃而不伤身体"]
      a__     		=     cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )
      self.assertFalse(lowerCAmelCase      ,      0.0   )




    def 						__lowerCamelCase (					self  :   str   )	-> List[Any]:
      a__     		=     [""]
      a__     		=     ["Hypothesis"]
      with self.assertRaises(lowerCAmelCase   ):
        cer.compute(predictions=lowerCAmelCase      ,      references=lowerCAmelCase   )


if __name__ == "__main__":
     unittest.main()


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


_SCREAMING_SNAKE_CASE   						=    {
    """configuration_open_llama""": ["""OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OpenLlamaConfig"""],
}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _SCREAMING_SNAKE_CASE   						=    ["""LlamaTokenizer"""]

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _SCREAMING_SNAKE_CASE   						=    ["""LlamaTokenizerFast"""]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _SCREAMING_SNAKE_CASE   						=    [
         """OpenLlamaForCausalLM""",
         """OpenLlamaModel""",
         """OpenLlamaPreTrainedModel""",
         """OpenLlamaForSequenceClassification""",
     ]


if TYPE_CHECKING:
     from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig

     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from transformers import LlamaTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from transformers import LlamaTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_open_llama import (
              OpenLlamaForCausalLM,
              OpenLlamaForSequenceClassification,
              OpenLlamaModel,
              OpenLlamaPreTrainedModel,
          )


else:
     import sys

     _SCREAMING_SNAKE_CASE   						=    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

