


import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    XLMForMultipleChoice,
	    XLMForQuestionAnswering,
	    XLMForQuestionAnsweringSimple,
	    XLMForSequenceClassification,
	    XLMForTokenClassification,
	    XLMModel,
	    XLMWithLMHeadModel,
	)
	from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST
class       lowerCamelCase_       :



					'''simple docstring'''







					def __init__(				self ,       snake_case_ ,       snake_case_=1_3 ,       snake_case_=7 ,       snake_case_=True ,       snake_case_=True ,       snake_case_=True ,       snake_case_=True ,       snake_case_=True ,       snake_case_=False ,       snake_case_=False ,       snake_case_=False ,       snake_case_=2 ,       snake_case_=9_9 ,       snake_case_=0 ,       snake_case_=3_2 ,       snake_case_=5 ,       snake_case_=4 ,       snake_case_=0.1 ,       snake_case_=0.1 ,       snake_case_=5_1_2 ,       snake_case_=2 ,       snake_case_=0.0_2 ,       snake_case_=2 ,       snake_case_=4 ,       snake_case_="last" ,       snake_case_=True ,       snake_case_=None ,       snake_case_=0 ,       )   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   parent
								__lowercase 					=   batch_size
								__lowercase 					=   seq_length
								__lowercase 					=   is_training
								__lowercase 					=   use_input_lengths
								__lowercase 					=   use_token_type_ids
								__lowercase 					=   use_labels
								__lowercase 					=   gelu_activation
								__lowercase 					=   sinusoidal_embeddings
								__lowercase 					=   causal
								__lowercase 					=   asm
								__lowercase 					=   n_langs
								__lowercase 					=   vocab_size
								__lowercase 					=   n_special
								__lowercase 					=   hidden_size
								__lowercase 					=   num_hidden_layers
								__lowercase 					=   num_attention_heads
								__lowercase 					=   hidden_dropout_prob
								__lowercase 					=   attention_probs_dropout_prob
								__lowercase 					=   max_position_embeddings
								__lowercase 					=   type_sequence_label_size
								__lowercase 					=   initializer_range
								__lowercase 					=   num_labels
								__lowercase 					=   num_choices
								__lowercase 					=   summary_type
								__lowercase 					=   use_proj
								__lowercase 					=   scope
								__lowercase 					=   bos_token_id






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.vocab_size						)
								__lowercase 					=   random_attention_mask([self.batch_size, self.seq_length]						)

								__lowercase 					=   None
								if self.use_input_lengths:
											__lowercase 					=   (
											    ids_tensor([self.batch_size] ,       vocab_size=2						) + self.seq_length - 2
											)  # small variation of seq_length

								__lowercase 					=   None
								if self.use_token_type_ids:
											__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.n_langs						)

								__lowercase 					=   None
								__lowercase 					=   None
								__lowercase 					=   None
								if self.use_labels:
											__lowercase 					=   ids_tensor([self.batch_size] ,       self.type_sequence_label_size						)
											__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.num_labels						)
											__lowercase 					=   ids_tensor([self.batch_size] ,       2						).float()
											__lowercase 					=   ids_tensor([self.batch_size] ,       self.num_choices						)

								__lowercase 					=   self.get_config()

								return (
								    config,
								    input_ids,
								    token_type_ids,
								    input_lengths,
								    sequence_labels,
								    token_labels,
								    is_impossible_labels,
								    choice_labels,
								    input_mask,
								)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								return XLMConfig(
								    vocab_size=self.vocab_size ,       n_special=self.n_special ,       emb_dim=self.hidden_size ,       n_layers=self.num_hidden_layers ,       n_heads=self.num_attention_heads ,       dropout=self.hidden_dropout_prob ,       attention_dropout=self.attention_probs_dropout_prob ,       gelu_activation=self.gelu_activation ,       sinusoidal_embeddings=self.sinusoidal_embeddings ,       asm=self.asm ,       causal=self.causal ,       n_langs=self.n_langs ,       max_position_embeddings=self.max_position_embeddings ,       initializer_range=self.initializer_range ,       summary_type=self.summary_type ,       use_proj=self.use_proj ,       num_labels=self.num_labels ,       bos_token_id=self.bos_token_id ,       )






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   XLMModel(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_ ,       lengths=snake_case_ ,       langs=snake_case_						)
								__lowercase 					=   model(snake_case_ ,       langs=snake_case_						)
								__lowercase 					=   model(snake_case_						)
								self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, self.seq_length, self.hidden_size)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   XLMWithLMHeadModel(snake_case_						)
								model.to(snake_case_						)
								model.eval()

								__lowercase 					=   model(snake_case_ ,       token_type_ids=snake_case_ ,       labels=snake_case_						)
								self.parent.assertEqual(result.loss.shape ,       ()						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.vocab_size)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			Tuple:







								'''simple docstring'''

								__lowercase 					=   XLMForQuestionAnsweringSimple(snake_case_						)
								model.to(snake_case_						)
								model.eval()

								__lowercase 					=   model(snake_case_						)

								__lowercase 					=   model(snake_case_ ,       start_positions=snake_case_ ,       end_positions=snake_case_						)
								__lowercase 					=   outputs
								self.parent.assertEqual(result.start_logits.shape ,       (self.batch_size, self.seq_length)						)
								self.parent.assertEqual(result.end_logits.shape ,       (self.batch_size, self.seq_length)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   XLMForQuestionAnswering(snake_case_						)
								model.to(snake_case_						)
								model.eval()

								__lowercase 					=   model(snake_case_						)

								__lowercase 					=   model(
								    snake_case_ ,       start_positions=snake_case_ ,       end_positions=snake_case_ ,       cls_index=snake_case_ ,       is_impossible=snake_case_ ,       p_mask=snake_case_ ,       )

								__lowercase 					=   model(
								    snake_case_ ,       start_positions=snake_case_ ,       end_positions=snake_case_ ,       cls_index=snake_case_ ,       is_impossible=snake_case_ ,       )

								((__lowercase )					,  ) 					=   result_with_labels.to_tuple()

								__lowercase 					=   model(snake_case_ ,       start_positions=snake_case_ ,       end_positions=snake_case_						)

								((__lowercase )					,  ) 					=   result_with_labels.to_tuple()

								self.parent.assertEqual(result_with_labels.loss.shape ,       ()						)
								self.parent.assertEqual(result.start_top_log_probs.shape ,       (self.batch_size, model.config.start_n_top)						)
								self.parent.assertEqual(result.start_top_index.shape ,       (self.batch_size, model.config.start_n_top)						)
								self.parent.assertEqual(
								    result.end_top_log_probs.shape ,       (self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
								self.parent.assertEqual(
								    result.end_top_index.shape ,       (self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
								self.parent.assertEqual(result.cls_logits.shape ,       (self.batch_size,)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   XLMForSequenceClassification(snake_case_						)
								model.to(snake_case_						)
								model.eval()

								__lowercase 					=   model(snake_case_						)
								__lowercase 					=   model(snake_case_ ,       labels=snake_case_						)
								self.parent.assertEqual(result.loss.shape ,       ()						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   self.num_labels
								__lowercase 					=   XLMForTokenClassification(snake_case_						)
								model.to(snake_case_						)
								model.eval()

								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_ ,       labels=snake_case_						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.num_labels)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			Union[str, Any]:







								'''simple docstring'''

								__lowercase 					=   self.num_choices
								__lowercase 					=   XLMForMultipleChoice(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   input_ids.unsqueeze(1						).expand(-1 ,       self.num_choices ,       -1						).contiguous()
								__lowercase 					=   token_type_ids.unsqueeze(1						).expand(-1 ,       self.num_choices ,       -1						).contiguous()
								__lowercase 					=   input_mask.unsqueeze(1						).expand(-1 ,       self.num_choices ,       -1						).contiguous()
								__lowercase 					=   model(
								    snake_case_ ,       attention_mask=snake_case_ ,       token_type_ids=snake_case_ ,       labels=snake_case_ ,       )
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_choices)						)






					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   self.prepare_config_and_inputs()
								(
								    (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					,  
								) 					=   config_and_inputs
								__lowercase 					=   {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''lengths''': input_lengths}
								return config, inputs_dict




@require_torch
class       lowerCamelCase_       (				lowerCAmelCase__     ,     lowerCAmelCase__     ,     lowerCAmelCase__     ,     unittest.TestCase				):



					'''simple docstring'''







					__UpperCAmelCase            =				(
					    (
					        XLMModel,
					        XLMWithLMHeadModel,
					        XLMForQuestionAnswering,
					        XLMForSequenceClassification,
					        XLMForQuestionAnsweringSimple,
					        XLMForTokenClassification,
					        XLMForMultipleChoice,
					    )
					    if is_torch_available()
					    else ()
					)
					__UpperCAmelCase            =				(
					    (XLMWithLMHeadModel,) if is_torch_available() else ()
					)  # TODO (PVP): Check other models whether language generation is also applicable
					__UpperCAmelCase            =				(
					    {
					        "feature-extraction": XLMModel,
					        "fill-mask": XLMWithLMHeadModel,
					        "question-answering": XLMForQuestionAnsweringSimple,
					        "text-classification": XLMForSequenceClassification,
					        "text-generation": XLMWithLMHeadModel,
					        "token-classification": XLMForTokenClassification,
					        "zero-shot": XLMForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			List[str]:







								'''simple docstring'''

								if (
								    pipeline_test_casse_name == "QAPipelineTests"
								    and tokenizer_name is not None
								    and not tokenizer_name.endswith('''Fast'''						)
								):
											# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
											# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
											# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
											return True

								return False






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_=False						)   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   super()._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)

								if return_labels:
											if model_class.__name__ == "XLMForQuestionAnswering":
														__lowercase 					=   torch.zeros(
														    self.model_tester.batch_size ,       dtype=torch.long ,       device=snake_case_						)
														__lowercase 					=   torch.zeros(
														    self.model_tester.batch_size ,       dtype=torch.long ,       device=snake_case_						)

								return inputs_dict






					def A      (				self						)   ->			str:







								'''simple docstring'''

								__lowercase 					=   XLMModelTester(self						)
								__lowercase 					=   ConfigTester(self ,       config_class=snake_case_ ,       emb_dim=3_7						)






					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								self.config_tester.run_common_tests()






					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_model(*snake_case_						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_lm_head(*snake_case_						)






					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_simple_qa(*snake_case_						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_qa(*snake_case_						)






					def A      (				self						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_sequence_classif(*snake_case_						)






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_token_classif(*snake_case_						)






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







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case_						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_=False ,       snake_case_=1						)   ->			str:







								'''simple docstring'''

								self.assertIsInstance(snake_case_ ,       snake_case_						)
								self.assertListEqual(
								    [isinstance(snake_case_ ,       snake_case_						) for iter_attentions in attentions] ,       [True] * len(snake_case_						)						)
								self.assertEqual(len(snake_case_						) ,       (max_length - min_length) * num_beam_groups						)

								for idx, iter_attentions in enumerate(snake_case_						):
											# adds PAD dummy token
											__lowercase 					=   min_length + idx + 1
											__lowercase 					=   min_length + idx + 1

											__lowercase 					=   (
											    batch_size * num_beam_groups,
											    config.num_attention_heads,
											    tgt_len,
											    src_len,
											)
											# check attn size
											self.assertListEqual(
											    [layer_attention.shape for layer_attention in iter_attentions] ,       [expected_shape] * len(snake_case_						)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_=False ,       snake_case_=1						)   ->			Tuple:







								'''simple docstring'''

								self.assertIsInstance(snake_case_ ,       snake_case_						)
								self.assertListEqual(
								    [isinstance(snake_case_ ,       snake_case_						) for iter_hidden_states in hidden_states] ,       [True] * len(snake_case_						) ,       )
								self.assertEqual(len(snake_case_						) ,       (max_length - min_length) * num_beam_groups						)

								for idx, iter_hidden_states in enumerate(snake_case_						):
											# adds PAD dummy token
											__lowercase 					=   min_length + idx + 1
											__lowercase 					=   (batch_size * num_beam_groups, seq_len, config.hidden_size)
											# check hidden size
											self.assertListEqual(
											    [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states] ,       [expected_shape] * len(snake_case_						) ,       )
								pass






					@slow
					def A      (				self						)   ->			Any:







								'''simple docstring'''

								for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 					=   XLMModel.from_pretrained(snake_case_						)
											self.assertIsNotNone(snake_case_						)




@require_torch
class       lowerCamelCase_       (				unittest.TestCase				):



					'''simple docstring'''







					@slow
					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   XLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''						)
								model.to(snake_case_						)
								__lowercase 					=   torch.tensor([[1_4, 4_4_7]] ,       dtype=torch.long ,       device=snake_case_						)  # the president
								__lowercase 					=   [
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								    1_4,
								    4_4_7,
								]  # the president the president the president the president the president the president the president the president the president the president
								# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
								__lowercase 					=   model.generate(snake_case_ ,       do_sample=snake_case_						)
								self.assertListEqual(output_ids[0].cpu().numpy().tolist() ,       snake_case_						)






def 		lowercase_  (     _UpperCamelCase       ,			_UpperCamelCase  ):


			'''simple docstring'''







			return price * (1 + tax_rate)


if __name__ == "__main__":
	print(f'''{price_plus_tax(100, 0.25) = }''')
	print(f'''{price_plus_tax(125.50, 0.05) = }''')


