



"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A    =	{'configuration_qdqbert': ['QDQBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'QDQBertConfig']}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A    =	[
							    'QDQBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'QDQBertForMaskedLM',
							    'QDQBertForMultipleChoice',
							    'QDQBertForNextSentencePrediction',
							    'QDQBertForQuestionAnswering',
							    'QDQBertForSequenceClassification',
							    'QDQBertForTokenClassification',
							    'QDQBertLayer',
							    'QDQBertLMHeadModel',
							    'QDQBertModel',
							    'QDQBertPreTrainedModel',
							    'load_tf_weights_in_qdqbert',
							]


if TYPE_CHECKING:
							from .configuration_qdqbert import QDQBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, QDQBertConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_qdqbert import (
														    QDQBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    QDQBertForMaskedLM,
														    QDQBertForMultipleChoice,
														    QDQBertForNextSentencePrediction,
														    QDQBertForQuestionAnswering,
														    QDQBertForSequenceClassification,
														    QDQBertForTokenClassification,
														    QDQBertLayer,
														    QDQBertLMHeadModel,
														    QDQBertModel,
														    QDQBertPreTrainedModel,
														    load_tf_weights_in_qdqbert,
														)


else:
							import sys

							A    =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)








"""simple docstring"""







import unittest

from cer import CER


A    =	CER()

class 			_a     (   unittest.TestCase):



			def 							__lowercase				( self       :							Optional[Any]		)       ->				Tuple:
									snake_case      : Union[str, Any]							=   ["White House"]
									snake_case      : Tuple							=   ["white house"]
									# S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
									snake_case      : int							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.1818181818		) < 1E-6		)



			def 							__lowercase				( self       :							Optional[Any]		)       ->				Dict:
									snake_case      : Tuple							=   ["were wolf"]
									snake_case      : Union[str, Any]							=   ["werewolf"]
									# S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
									snake_case      : List[str]							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.1111111		) < 1E-6		)

									snake_case      : List[str]							=   ["werewolf"]
									snake_case      : Optional[Any]							=   ["weae     wolf"]
									# S = 1, D = 1, I = 0, N = 8, CER = 0.25
									snake_case      : Optional[int]							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.25		) < 1E-6		)

									# consecutive whitespaces case 1
									snake_case      : Optional[int]							=   ["were wolf"]
									snake_case      : Dict							=   ["were               wolf"]
									# S = 0, D = 0, I = 0, N = 9, CER = 0
									snake_case      : Dict							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.0		) < 1E-6		)

									# consecutive whitespaces case 2
									snake_case      : Dict							=   ["were   wolf"]
									snake_case      : Dict							=   ["were               wolf"]
									# S = 0, D = 0, I = 0, N = 9, CER = 0
									snake_case      : Optional[int]							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.0		) < 1E-6		)



			def 							__lowercase				( self       :							List[Any]		)       ->				Union[str, Any]:
									snake_case      : str							=   ["werewolf"]
									snake_case      : List[Any]							=   ["weaewolf"]
									# S = 1, D = 0, I = 0, N = 8, CER = 0.125
									snake_case      : str							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.125		) < 1E-6		)



			def 							__lowercase				( self       :							int		)       ->				int:
									snake_case      : Dict							=   ["werewolf"]
									snake_case      : Optional[Any]							=   ["wereawolf"]
									# S = 0, D = 1, I = 0, N = 8, CER = 0.125
									snake_case      : List[str]							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.125		) < 1E-6		)



			def 							__lowercase				( self       :							Union[str, Any]		)       ->				List[Any]:
									snake_case      : Tuple							=   ["werewolf"]
									snake_case      : Union[str, Any]							=   ["wereolf"]
									# S = 0, D = 0, I = 1, N = 8, CER = 0.125
									snake_case      : str							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.125		) < 1E-6		)



			def 							__lowercase				( self       :							int		)       ->				List[str]:
									snake_case      : int							=   ["werewolf"]
									snake_case      : Optional[Any]							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertEqual(_lowercase      ,  0.0		)



			def 							__lowercase				( self       :							List[Any]		)       ->				Optional[Any]:
									snake_case      : str							=   ["werewolf", "I am your father"]
									snake_case      : str							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertEqual(_lowercase      ,  0.0		)

									snake_case      : Union[str, Any]							=   ["werewolf", "I am your father", "doge"]
									snake_case      : str							=   ["werxwolf", "I       am your father", "doge"]
									# S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
									snake_case      : Dict							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.03571428		) < 1E-6		)



			def 							__lowercase				( self       :							Any		)       ->				Union[str, Any]:
									snake_case      : Union[str, Any]							=   ["My hovercraft", "is full of eels"]
									snake_case      : List[str]							=   ["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
									snake_case      : int							=   cer.compute(predictions=_lowercase      ,  references=_lowercase      ,  concatenate_texts=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.071428		) < 1E-6		)



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

									snake_case      : List[Any]							=   ["我能吞下玻璃", "而不伤身体"]
									snake_case      : int							=   ["我    能 吞 下 玻 璃", "而不伤身体"]
									# S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
									snake_case      : Dict							=   cer.compute(predictions=_lowercase      ,  references=_lowercase		)
									self.assertTrue(abs(char_error_rate - 0.454545454545		) < 1E-6		)

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



			def 							__lowercase				( self       :							List[Any]		)       ->				List[Any]:
									snake_case      : int							=   [""]
									snake_case      : Optional[int]							=   ["Hypothesis"]
									with self.assertRaises(_lowercase		):
															cer.compute(predictions=_lowercase      ,  references=_lowercase		)


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



