




"""simple docstring"""





import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
							import os

							# The slow tests are often failing with OOM error on GPU
							# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
							# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
							_lowercase						   =     """platform"""

							import jax
							import jax.numpy as jnp

							from transformers import AutoTokenizer
							from transformers.models.mbart.modeling_flax_mbart import (
							    FlaxMBartForConditionalGeneration,
							    FlaxMBartForQuestionAnswering,
							    FlaxMBartForSequenceClassification,
							    FlaxMBartModel,
							    shift_tokens_right,
							)

def 		lowerCAmelCase				(			lowerCamelCase   ,      lowerCamelCase   ,      lowerCamelCase=None   ,      lowerCamelCase=None   ,      lowerCamelCase=None   ,      lowerCamelCase=None   ,      lowerCamelCase=None   ,      lowerCamelCase=None   ,      ):
						'''simple docstring'''


						if attention_mask is None:
												snake_case__							:       Optional[int]				      =       np.where(input_ids != config.pad_token_id   ,      1   ,      0		)
						if decoder_attention_mask is None:
												snake_case__							:       Tuple				      =       np.where(decoder_input_ids != config.pad_token_id   ,      1   ,      0		)
						if head_mask is None:
												snake_case__							:       Optional[Any]				      =       np.ones((config.encoder_layers, config.encoder_attention_heads)		)
						if decoder_head_mask is None:
												snake_case__							:       Dict				      =       np.ones((config.decoder_layers, config.decoder_attention_heads)		)
						if cross_attn_head_mask is None:
												snake_case__							:       List[str]				      =       np.ones((config.decoder_layers, config.decoder_attention_heads)		)
						return {
						    "input_ids": input_ids,
						    "decoder_input_ids": decoder_input_ids,
						    "attention_mask": attention_mask,
						    "decoder_attention_mask": decoder_attention_mask,
						}

class    __lowercase							(      unittest.TestCase						):


				'''simple docstring'''


				def __init__( self :  int   ,SCREAMING_SNAKE_CASE_ :  int   ,SCREAMING_SNAKE_CASE_ :  Optional[int]=1_3   ,SCREAMING_SNAKE_CASE_ :  str=7   ,SCREAMING_SNAKE_CASE_ :  Tuple=True   ,SCREAMING_SNAKE_CASE_ :  List[str]=False   ,SCREAMING_SNAKE_CASE_ :  Any=9_9   ,SCREAMING_SNAKE_CASE_ :  Any=1_6   ,SCREAMING_SNAKE_CASE_ :  List[str]=2   ,SCREAMING_SNAKE_CASE_ :  Optional[int]=4   ,SCREAMING_SNAKE_CASE_ :  Union[str, Any]=4   ,SCREAMING_SNAKE_CASE_ :  Dict="gelu"   ,SCREAMING_SNAKE_CASE_ :  Optional[int]=0.1   ,SCREAMING_SNAKE_CASE_ :  int=0.1   ,SCREAMING_SNAKE_CASE_ :  Optional[Any]=3_2   ,SCREAMING_SNAKE_CASE_ :  List[Any]=2   ,SCREAMING_SNAKE_CASE_ :  Optional[int]=1   ,SCREAMING_SNAKE_CASE_ :  Any=0   ,SCREAMING_SNAKE_CASE_ :  int=2   ,SCREAMING_SNAKE_CASE_ :  List[str]=0.02   ,):
										snake_case__							:       Any				      =       parent
										snake_case__							:       str				      =       batch_size
										snake_case__							:       Any				      =       seq_length
										snake_case__							:       str				      =       is_training
										snake_case__							:       List[Any]				      =       use_labels
										snake_case__							:       Tuple				      =       vocab_size
										snake_case__							:       List[Any]				      =       hidden_size
										snake_case__							:       Union[str, Any]				      =       num_hidden_layers
										snake_case__							:       Tuple				      =       num_attention_heads
										snake_case__							:       Union[str, Any]				      =       intermediate_size
										snake_case__							:       Any				      =       hidden_act
										snake_case__							:       Optional[Any]				      =       hidden_dropout_prob
										snake_case__							:       Tuple				      =       attention_probs_dropout_prob
										snake_case__							:       Any				      =       max_position_embeddings
										snake_case__							:       int				      =       eos_token_id
										snake_case__							:       Tuple				      =       pad_token_id
										snake_case__							:       Tuple				      =       bos_token_id
										snake_case__							:       List[Any]				      =       decoder_start_token_id
										snake_case__							:       List[str]				      =       initializer_range

				def    _lowerCamelCase       ( self :  List[str]   ):
										snake_case__							:       str				      =       np.clip(ids_tensor([self.batch_size, self.seq_length - 1]   ,self.vocab_size   )   ,3   ,self.vocab_size   )
										snake_case__							:       Dict				      =       np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)   ,dtype=np.intaa   ))   ,-1   )

										snake_case__							:       List[str]				      =       shift_tokens_right(lowercase_   ,1   )

										snake_case__							:       List[str]				      =       MBartConfig(
										    vocab_size=self.vocab_size   ,d_model=self.hidden_size   ,encoder_layers=self.num_hidden_layers   ,decoder_layers=self.num_hidden_layers   ,encoder_attention_heads=self.num_attention_heads   ,decoder_attention_heads=self.num_attention_heads   ,encoder_ffn_dim=self.intermediate_size   ,decoder_ffn_dim=self.intermediate_size   ,dropout=self.hidden_dropout_prob   ,attention_dropout=self.attention_probs_dropout_prob   ,max_position_embeddings=self.max_position_embeddings   ,eos_token_id=self.eos_token_id   ,bos_token_id=self.bos_token_id   ,pad_token_id=self.pad_token_id   ,decoder_start_token_id=self.decoder_start_token_id   ,initializer_range=self.initializer_range   ,use_cache=lowercase_   ,)
										snake_case__							:       str				      =       prepare_mbart_inputs_dict(lowercase_   ,lowercase_   ,lowercase_   )
										return config, inputs_dict

				def    _lowerCamelCase       ( self :  Union[str, Any]   ):
										snake_case__      ,						snake_case__							:       List[Any]				      =       self.prepare_config_and_inputs()
										return config, inputs_dict

				def    _lowerCamelCase       ( self :  List[str]   ,SCREAMING_SNAKE_CASE_ :  Union[str, Any]   ,SCREAMING_SNAKE_CASE_ :  List[str]   ,SCREAMING_SNAKE_CASE_ :  str   ):
										snake_case__							:       Tuple				      =       2_0
										snake_case__							:       Tuple				      =       model_class_name(lowercase_   )

										snake_case__							:       int				      =       model.encode(inputs_dict['''input_ids''']   )

										snake_case__      ,						snake_case__							:       List[str]				      =       (
										    inputs_dict['''decoder_input_ids'''],
										    inputs_dict['''decoder_attention_mask'''],
										)

										snake_case__							:       Any				      =       model.init_cache(decoder_input_ids.shape[0]   ,lowercase_   ,lowercase_   )
										snake_case__							:       int				      =       jnp.ones((decoder_input_ids.shape[0], max_decoder_length)   ,dtype='''i4'''   )

										snake_case__							:       str				      =       jnp.broadcast_to(
										    jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]   ,(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)   ,)
										snake_case__							:       Any				      =       model.decode(
										    decoder_input_ids[:, :-1]   ,lowercase_   ,decoder_attention_mask=lowercase_   ,past_key_values=lowercase_   ,decoder_position_ids=lowercase_   ,)

										snake_case__							:       Dict				      =       jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   ,dtype='''i4'''   )
										snake_case__							:       Optional[Any]				      =       model.decode(
										    decoder_input_ids[:, -1:]   ,lowercase_   ,decoder_attention_mask=lowercase_   ,past_key_values=outputs_cache.past_key_values   ,decoder_position_ids=lowercase_   ,)

										snake_case__							:       Union[str, Any]				      =       model.decode(lowercase_   ,lowercase_   )

										snake_case__							:       Union[str, Any]				      =       np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
										self.parent.assertTrue(diff < 1E-3   ,msg=F'''Max diff is {diff}'''   )





				def    _lowerCamelCase       ( self :  Tuple   ,SCREAMING_SNAKE_CASE_ :  str   ,SCREAMING_SNAKE_CASE_ :  Optional[Any]   ,SCREAMING_SNAKE_CASE_ :  Optional[int]   ):
										snake_case__							:       int				      =       2_0
										snake_case__							:       Dict				      =       model_class_name(lowercase_   )

										snake_case__							:       int				      =       model.encode(inputs_dict['''input_ids''']   )

										snake_case__      ,						snake_case__							:       List[Any]				      =       (
										    inputs_dict['''decoder_input_ids'''],
										    inputs_dict['''decoder_attention_mask'''],
										)

										snake_case__							:       Any				      =       jnp.concatenate(
										    [
										        decoder_attention_mask,
										        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])   ),
										    ]   ,axis=-1   ,)

										snake_case__							:       Union[str, Any]				      =       model.init_cache(decoder_input_ids.shape[0]   ,lowercase_   ,lowercase_   )
										snake_case__							:       Tuple				      =       jnp.broadcast_to(
										    jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]   ,(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)   ,)

										snake_case__							:       int				      =       model.decode(
										    decoder_input_ids[:, :-1]   ,lowercase_   ,decoder_attention_mask=lowercase_   ,past_key_values=lowercase_   ,decoder_position_ids=lowercase_   ,)
										snake_case__							:       List[Any]				      =       jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   ,dtype='''i4'''   )
										snake_case__							:       List[Any]				      =       model.decode(
										    decoder_input_ids[:, -1:]   ,lowercase_   ,past_key_values=outputs_cache.past_key_values   ,decoder_attention_mask=lowercase_   ,decoder_position_ids=lowercase_   ,)

										snake_case__							:       str				      =       model.decode(lowercase_   ,lowercase_   ,decoder_attention_mask=lowercase_   )

										snake_case__							:       List[str]				      =       np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
										self.parent.assertTrue(diff < 1E-3   ,msg=F'''Max diff is {diff}'''   )







@require_flax
class    __lowercase							(      unittest.TestCase						):


				'''simple docstring'''


				_lowerCAmelCase						      =99

				def    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__							:       Any				      =       np.array(
										    [
										        [7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2],
										        [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2],
										        [5, 9_7, 1_7, 3_9, 9_4, 4_0, 2],
										        [7_6, 8_3, 9_4, 2_5, 7_0, 7_8, 2],
										        [8_7, 5_9, 4_1, 3_5, 4_8, 6_6, 2],
										        [5_5, 1_3, 1_6, 5_8, 5, 2, 1],  # note padding
										        [6_4, 2_7, 3_1, 5_1, 1_2, 7_5, 2],
										        [5_2, 6_4, 8_6, 1_7, 8_3, 3_9, 2],
										        [4_8, 6_1, 9, 2_4, 7_1, 8_2, 2],
										        [2_6, 1, 6_0, 4_8, 2_2, 1_3, 2],
										        [2_1, 5, 6_2, 2_8, 1_4, 7_6, 2],
										        [4_5, 9_8, 3_7, 8_6, 5_9, 4_8, 2],
										        [7_0, 7_0, 5_0, 9, 2_8, 0, 2],
										    ]   ,dtype=np.intaa   ,)

										snake_case__							:       Optional[int]				      =       input_ids.shape[0]
										snake_case__							:       str				      =       MBartConfig(
										    vocab_size=self.vocab_size   ,d_model=2_4   ,encoder_layers=2   ,decoder_layers=2   ,encoder_attention_heads=2   ,decoder_attention_heads=2   ,encoder_ffn_dim=3_2   ,decoder_ffn_dim=3_2   ,max_position_embeddings=4_8   ,eos_token_id=2   ,pad_token_id=1   ,bos_token_id=0   ,)
										return config, input_ids, batch_size

				def    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__      ,						snake_case__      ,						snake_case__							:       Optional[Any]				      =       self._get_config_and_data()
										snake_case__							:       Union[str, Any]				      =       FlaxMBartForSequenceClassification(lowercase_   )
										snake_case__							:       str				      =       model(input_ids=lowercase_   ,decoder_input_ids=lowercase_   )
										snake_case__							:       str				      =       (batch_size, config.num_labels)
										self.assertEqual(outputs['''logits'''].shape   ,lowercase_   )

				def    _lowerCamelCase       ( self :  Dict   ):
										snake_case__      ,						snake_case__      ,						snake_case__							:       Any				      =       self._get_config_and_data()
										snake_case__							:       Tuple				      =       FlaxMBartForQuestionAnswering(lowercase_   )
										snake_case__							:       List[str]				      =       model(input_ids=lowercase_   )

										self.assertEqual(outputs['''start_logits'''].shape   ,input_ids.shape   )
										self.assertEqual(outputs['''end_logits'''].shape   ,input_ids.shape   )

				def    _lowerCamelCase       ( self :  Dict   ):
										snake_case__      ,						snake_case__      ,						snake_case__							:       Any				      =       self._get_config_and_data()
										snake_case__							:       Union[str, Any]				      =       FlaxMBartForConditionalGeneration(lowercase_   )
										snake_case__							:       Optional[Any]				      =       lm_model(input_ids=lowercase_   )
										snake_case__							:       Tuple				      =       (batch_size, input_ids.shape[1], config.vocab_size)
										self.assertEqual(outputs['''logits'''].shape   ,lowercase_   )

				def    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__							:       int				      =       MBartConfig(
										    vocab_size=self.vocab_size   ,d_model=1_4   ,encoder_layers=2   ,decoder_layers=2   ,encoder_attention_heads=2   ,decoder_attention_heads=2   ,encoder_ffn_dim=8   ,decoder_ffn_dim=8   ,max_position_embeddings=4_8   ,)
										snake_case__							:       str				      =       FlaxMBartForConditionalGeneration(lowercase_   )
										snake_case__							:       Optional[int]				      =       np.array([[7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2], [6_8, 3_4, 2_6, 5_8, 3_0, 2, 1]]   ,dtype=np.intaa   )
										snake_case__							:       str				      =       np.array([[8_2, 7_1, 8_2, 1_8, 2], [5_8, 6_8, 2, 1, 1]]   ,dtype=np.intaa   )
										snake_case__							:       str				      =       lm_model(input_ids=lowercase_   ,decoder_input_ids=lowercase_   )
										snake_case__							:       Union[str, Any]				      =       (*summary.shape, config.vocab_size)
										self.assertEqual(outputs['''logits'''].shape   ,lowercase_   )





				def    _lowerCamelCase       ( self :  List[str]   ):
										snake_case__							:       List[Any]				      =       np.array([[7_1, 8_2, 1_8, 3_3, 2, 1, 1], [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2]]   ,dtype=np.intaa   )
										snake_case__							:       Optional[Any]				      =       shift_tokens_right(lowercase_   ,1   )
										snake_case__							:       List[str]				      =       np.equal(lowercase_   ,1   ).astype(np.floataa   ).sum()
										snake_case__							:       Union[str, Any]				      =       np.equal(lowercase_   ,1   ).astype(np.floataa   ).sum()
										self.assertEqual(shifted.shape   ,input_ids.shape   )
										self.assertEqual(lowercase_   ,n_pad_before - 1   )
										self.assertTrue(np.equal(shifted[:, 0]   ,2   ).all()   )







@require_flax
class    __lowercase							(      _UpperCAmelCase    , unittest.TestCase    , _UpperCAmelCase						):


				'''simple docstring'''


				_lowerCAmelCase						      =True
				_lowerCAmelCase						      =(
				    (
				        FlaxMBartModel,
				        FlaxMBartForConditionalGeneration,
				        FlaxMBartForSequenceClassification,
				        FlaxMBartForQuestionAnswering,
				    )
				    if is_flax_available()
				    else ()
				)
				_lowerCAmelCase						      =(FlaxMBartForConditionalGeneration,) if is_flax_available() else ()

				def    _lowerCamelCase       ( self :  Union[str, Any]   ):
										snake_case__							:       Tuple				      =       FlaxMBartModelTester(self   )

				def    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__      ,						snake_case__							:       Optional[Any]				      =       self.model_tester.prepare_config_and_inputs()
										for model_class in self.all_model_classes:
																self.model_tester.check_use_cache_forward(lowercase_   ,lowercase_   ,lowercase_   )

				def    _lowerCamelCase       ( self :  str   ):
										snake_case__      ,						snake_case__							:       int				      =       self.model_tester.prepare_config_and_inputs()
										for model_class in self.all_model_classes:
																self.model_tester.check_use_cache_forward_with_attn_mask(lowercase_   ,lowercase_   ,lowercase_   )

				def    _lowerCamelCase       ( self :  Optional[Any]   ):
										snake_case__      ,						snake_case__							:       Dict				      =       self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																with self.subTest(model_class.__name__   ):
																						snake_case__							:       Union[str, Any]				      =       self._prepare_for_class(lowercase_   ,lowercase_   )
																						snake_case__							:       Dict				      =       model_class(lowercase_   )

																						@jax.jit
																						def encode_jitted(SCREAMING_SNAKE_CASE_ :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  Tuple=None   ,**SCREAMING_SNAKE_CASE_ :  Tuple   ):
																												return model.encode(input_ids=lowercase_   ,attention_mask=lowercase_   )

																						with self.subTest('''JIT Enabled'''   ):
																												snake_case__							:       int				      =       encode_jitted(**lowercase_   ).to_tuple()

																						with self.subTest('''JIT Disabled'''   ):
																												with jax.disable_jit():
																																		snake_case__							:       Dict				      =       encode_jitted(**lowercase_   ).to_tuple()

																						self.assertEqual(len(lowercase_   )   ,len(lowercase_   )   )
																						for jitted_output, output in zip(lowercase_   ,lowercase_   ):
																												self.assertEqual(jitted_output.shape   ,output.shape   )

				def    _lowerCamelCase       ( self :  Tuple   ):
										snake_case__      ,						snake_case__							:       Union[str, Any]				      =       self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																with self.subTest(model_class.__name__   ):
																						snake_case__							:       Optional[Any]				      =       model_class(lowercase_   )
																						snake_case__							:       Optional[Any]				      =       model.encode(inputs_dict['''input_ids''']   ,inputs_dict['''attention_mask''']   )

																						snake_case__							:       List[Any]				      =       {
																						    '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
																						    '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
																						    '''encoder_outputs''': encoder_outputs,
																						}

																						@jax.jit
																						def decode_jitted(SCREAMING_SNAKE_CASE_ :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  List[str]   ):
																												return model.decode(
																												    decoder_input_ids=lowercase_   ,decoder_attention_mask=lowercase_   ,encoder_outputs=lowercase_   ,)

																						with self.subTest('''JIT Enabled'''   ):
																												snake_case__							:       Optional[Any]				      =       decode_jitted(**lowercase_   ).to_tuple()

																						with self.subTest('''JIT Disabled'''   ):
																												with jax.disable_jit():
																																		snake_case__							:       str				      =       decode_jitted(**lowercase_   ).to_tuple()

																						self.assertEqual(len(lowercase_   )   ,len(lowercase_   )   )
																						for jitted_output, output in zip(lowercase_   ,lowercase_   ):
																												self.assertEqual(jitted_output.shape   ,output.shape   )





				@slow
				def    _lowerCamelCase       ( self :  Optional[Any]   ):







										for model_class_name in self.all_model_classes:
																snake_case__							:       Dict				      =       model_class_name.from_pretrained('''facebook/mbart-large-cc25'''   ,from_pt=lowercase_   )
																# FlaxMBartForSequenceClassification expects eos token in input_ids
																snake_case__							:       Optional[Any]				      =       np.ones((1, 1)   ) * model.config.eos_token_id
																snake_case__							:       Dict				      =       model(lowercase_   )
																self.assertIsNotNone(lowercase_   )







@require_flax
@require_sentencepiece
@require_tokenizers
class    __lowercase							(      unittest.TestCase						):


				'''simple docstring'''


				_lowerCAmelCase						      =[
				    " UN Chief Says There Is No Military Solution in Syria",
				]
				_lowerCAmelCase						      =[
				    "Şeful ONU declară că nu există o soluţie militară în Siria",
				]
				_lowerCAmelCase						      ="facebook/mbart-large-en-ro"

				@cached_property
				def    _lowerCamelCase       ( self :  List[Any]   ):
										return AutoTokenizer.from_pretrained(self.model_name   )

				@cached_property
				def    _lowerCamelCase       ( self :  int   ):
										snake_case__							:       Optional[int]				      =       FlaxMBartForConditionalGeneration.from_pretrained(self.model_name   ,from_pt=lowercase_   )
										return model

				def    _lowerCamelCase       ( self :  List[Any]   ,**SCREAMING_SNAKE_CASE_ :  Dict   ):
										snake_case__							:       Optional[int]				      =       self.translate_src_text(**lowercase_   )
										self.assertListEqual(self.expected_text   ,lowercase_   )

				def    _lowerCamelCase       ( self :  List[str]   ,**SCREAMING_SNAKE_CASE_ :  str   ):
										snake_case__							:       List[str]				      =       self.tokenizer(self.src_text   ,**lowercase_   ,return_tensors='''np'''   )
										snake_case__							:       str				      =       self.model.generate(
										    model_inputs.input_ids   ,attention_mask=model_inputs.attention_mask   ,decoder_start_token_id=self.tokenizer.lang_code_to_id['''ro_RO''']   ,early_stopping=lowercase_   ,num_beams=2   ,).sequences
										snake_case__							:       List[str]				      =       self.tokenizer.batch_decode(lowercase_   ,skip_special_tokens=lowercase_   )
										return generated_words





				@slow
				def    _lowerCamelCase       ( self :  str   ):
										self._assert_generated_batch_equal_expected()





import unittest

from cer import CER


lowercase_									=    CER()


class 					A		(				unittest.TestCase					):







    """simple docstring"""





    def 		snake_case__	( self					:			str						)->       Dict:





        '''simple docstring'''







        A__        =  ['White House']
        A__        =  ['white house']
        # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.1_818_181_818						) < 1E-6						)


    def 		snake_case__	( self					:			str						)->       Dict:





        '''simple docstring'''







        A__        =  ['were wolf']
        A__        =  ['werewolf']
        # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        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=lowercase_,references=lowercase_						)
        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=lowercase_,references=lowercase_						)
        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=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.0						) < 1E-6						)


    def 		snake_case__	( self					:			int						)->       str:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['weaewolf']
        # S = 1, D = 0, I = 0, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			Optional[int]						)->       Optional[int]:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['wereawolf']
        # S = 0, D = 1, I = 0, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			List[Any]						)->       Optional[Any]:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['wereolf']
        # S = 0, D = 0, I = 1, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			str						)->       Tuple:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertEqual(lowercase_,0.0						)


    def 		snake_case__	( self					:			Optional[int]						)->       Union[str, Any]:





        '''simple docstring'''







        A__        =  ['werewolf', 'I am your father']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertEqual(lowercase_,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=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.03_571_428						) < 1E-6						)


    def 		snake_case__	( self					:			List[str]						)->       Union[str, Any]:





        '''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=lowercase_,references=lowercase_,concatenate_texts=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.071_428						) < 1E-6						)


    def 		snake_case__	( self					:			Dict						)->       List[str]:





        '''simple docstring'''







        A__        =  ['我能吞下玻璃而不伤身体']
        A__        =  [' 能吞虾玻璃而 不霜身体啦']
        # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        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=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.454_545_454_545						) < 1E-6						)

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


    def 		snake_case__	( self					:			Any						)->       List[str]:





        '''simple docstring'''







        A__        =  ['']
        A__        =  ['Hypothesis']
        with self.assertRaises(lowercase_						):
            cer.compute(predictions=lowercase_,references=lowercase_						)


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

