code: 
  
  
  
  
  """simple docstring"""
  
  
  
  import unittest
  
  from cer import CER
  
  
  SCREAMING_SNAKE_CASE       = CER()
  
  
  
  
  class 			UpperCAmelCase_						(		unittest.TestCase							):
  
  
  
  
      def 							__magic_name__							(					self		: List[str]   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["White House"]
       A__ =       ["white house"]
       # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.18_1818_1818   ) < 1e-6   )
  
  
  
  
      def 							__magic_name__							(					self		: Any   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["were wolf"]
       A__ =       ["werewolf"]
       # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.111_1111   ) < 1e-6   )
  
       A__ =       ["werewolf"]
       A__ =       ["weae     wolf"]
       # S = 1, D = 1, I = 0, N = 8, CER = 0.25
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       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=snake_case_			,				references=snake_case_   )
       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=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.0   ) < 1e-6   )
  
  
  
  
      def 							__magic_name__							(					self		: int   )   ->							List[Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["werewolf"]
       A__ =       ["weaewolf"]
       # S = 1, D = 0, I = 0, N = 8, CER = 0.125
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )
  
  
  
  
      def 							__magic_name__							(					self		: str   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["werewolf"]
       A__ =       ["wereawolf"]
       # S = 0, D = 1, I = 0, N = 8, CER = 0.125
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )
  
  
  
  
      def 							__magic_name__							(					self		: Tuple   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["werewolf"]
       A__ =       ["wereolf"]
       # S = 0, D = 0, I = 1, N = 8, CER = 0.125
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )
  
  
  
  
      def 							__magic_name__							(					self		: str   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["werewolf"]
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertEqual(snake_case_			,				0.0   )
  
  
  
  
      def 							__magic_name__							(					self		: Optional[int]   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["werewolf", "I am your father"]
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertEqual(snake_case_			,				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=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.0357_1428   ) < 1e-6   )
  
  
  
  
      def 							__magic_name__							(					self		: Any   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       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=snake_case_			,				references=snake_case_			,				concatenate_texts=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.07_1428   ) < 1e-6   )
  
  
  
  
      def 							__magic_name__							(					self		: Optional[Any]   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       ["我能吞下玻璃而不伤身体"]
       A__ =       [" 能吞虾玻璃而 不霜身体啦"]
       # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.45_4545_4545   ) < 1e-6   )
  
       A__ =       ["我能吞下玻璃", "而不伤身体"]
       A__ =       ["我    能 吞 下 玻 璃", "而不伤身体"]
       # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertTrue(abs(char_error_rate - 0.4545_4545_4545   ) < 1e-6   )
  
       A__ =       ["我能吞下玻璃而不伤身体"]
       A__ =       cer.compute(predictions=snake_case_			,				references=snake_case_   )
       self.assertFalse(snake_case_			,				0.0   )
  
  
  
  
      def 							__magic_name__							(					self		: Union[str, Any]   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       A__ =       [""]
       A__ =       ["Hypothesis"]
       with self.assertRaises(snake_case_   ):
        cer.compute(predictions=snake_case_			,				references=snake_case_   )
  
  
  if __name__ == "__main__":
        unittest.main()
  
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import _LazyModule
  
  
  SCREAMING_SNAKE_CASE       = {"tokenization_bert_japanese": ["BertJapaneseTokenizer", "CharacterTokenizer", "MecabTokenizer"]}
  
  
  if TYPE_CHECKING:
        from .tokenization_bert_japanese import BertJapaneseTokenizer, CharacterTokenizer, MecabTokenizer
  
  else:
        import sys
  
        SCREAMING_SNAKE_CASE       = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  
  
  
  
  