



'''simple docstring'''





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				,			__a				,			__a=13				,			__a=7				,			__a=True				,			__a=True				,			__a=True				,			__a=True				,			__a=True				,			__a=False				,			__a=False				,			__a=False				,			__a=2				,			__a=99				,			__a=0				,			__a=32				,			__a=5				,			__a=4				,			__a=0.1				,			__a=0.1				,			__a=5_12				,			__a=2				,			__a=0.02				,			__a=2				,			__a=4				,			__a="last"				,			__a=True				,			__a=None				,			__a=0				,			):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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

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

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

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

           lowerCamelCase								=		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    ):






           '''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				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			):






           '''simple docstring'''



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







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			):






           '''simple docstring'''



           lowerCamelCase								=		XLMWithLMHeadModel(__a    )
           model.to(__a    )
           model.eval()

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







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			):






           '''simple docstring'''



           lowerCamelCase								=		XLMForQuestionAnsweringSimple(__a    )
           model.to(__a    )
           model.eval()

           lowerCamelCase								=		model(__a    )

           lowerCamelCase								=		model(__a				,			start_positions=__a				,			end_positions=__a    )
           lowerCamelCase								=		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				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			):






           '''simple docstring'''



           lowerCamelCase								=		XLMForQuestionAnswering(__a    )
           model.to(__a    )
           model.eval()

           lowerCamelCase								=		model(__a    )

           lowerCamelCase								=		model(
               __a				,			start_positions=__a				,			end_positions=__a				,			cls_index=__a				,			is_impossible=__a				,			p_mask=__a				,			)

           lowerCamelCase								=		model(
               __a				,			start_positions=__a				,			end_positions=__a				,			cls_index=__a				,			is_impossible=__a				,			)

           ((lowerCamelCase							)			,														)								=		result_with_labels.to_tuple()

           lowerCamelCase								=		model(__a				,			start_positions=__a				,			end_positions=__a    )

           ((lowerCamelCase							)			,														)								=		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				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			):






           '''simple docstring'''



           lowerCamelCase								=		XLMForSequenceClassification(__a    )
           model.to(__a    )
           model.eval()

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







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			):






           '''simple docstring'''



           lowerCamelCase								=		self.num_labels
           lowerCamelCase								=		XLMForTokenClassification(__a    )
           model.to(__a    )
           model.eval()

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







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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





@require_torch
class    lowerCamelCase__  (						UpperCAmelCase_       ,    UpperCAmelCase_       ,    UpperCAmelCase_       ,    unittest.TestCase):
     """simple docstring"""



     _A       =			(
         (
             XLMModel,
             XLMWithLMHeadModel,
             XLMForQuestionAnswering,
             XLMForSequenceClassification,
             XLMForQuestionAnsweringSimple,
             XLMForTokenClassification,
             XLMForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     _A       =			(
         (XLMWithLMHeadModel,) if is_torch_available() else ()
     )  # TODO (PVP): Check other models whether language generation is also applicable
     _A       =			(
         {
             '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				,			__a				,			__a				,			__a				,			__a				,			__a    ):






           '''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				,			__a				,			__a				,			__a=False    ):






           '''simple docstring'''



           lowerCamelCase								=		super()._prepare_for_class(__a				,			__a				,			return_labels=__a    )

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

           return inputs_dict







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		XLMModelTester(self    )
           lowerCamelCase								=		ConfigTester(self				,			config_class=__a				,			emb_dim=37    )







     def 						_a      (self    ):






           '''simple docstring'''



           self.config_tester.run_common_tests()







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_model(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_lm_head(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_simple_qa(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_qa(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_sequence_classif(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_token_classif(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_multiple_choice(*__a    )







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a=False				,			__a=1    ):






           '''simple docstring'''



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

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

                 lowerCamelCase								=		(
                     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(__a    )    )







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a=False				,			__a=1    ):






           '''simple docstring'''



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

           for idx, iter_hidden_states in enumerate(__a    ):
                 # adds PAD dummy token
                 lowerCamelCase								=		min_length + idx + 1
                 lowerCamelCase								=		(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(__a    )				,			)
           pass







     @slow
     def 						_a      (self    ):






           '''simple docstring'''



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





@require_torch
class    lowerCamelCase__  (						unittest.TestCase):
     """simple docstring"""



     @slow
     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"    )
           model.to(__a    )
           lowerCamelCase								=		torch.tensor([[14, 4_47]]				,			dtype=torch.long				,			device=__a    )  # the president
           lowerCamelCase								=		[
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
           ]  # 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
           lowerCamelCase								=		model.generate(__a				,			do_sample=__a    )
           self.assertListEqual(output_ids[0].cpu().numpy().tolist()				,			__a    )




import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      return x + 2






class    lowerCamelCase__  (						unittest.TestCase):
     """simple docstring"""



     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"x = 3"
           lowerCamelCase								=		{}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           assert result == 3
           self.assertDictEqual(__a				,			{"x": 3}    )

           lowerCamelCase								=		"x = y"
           lowerCamelCase								=		{"y": 5}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           # evaluate returns the value of the last assignment.
           assert result == 5
           self.assertDictEqual(__a				,			{"x": 5, "y": 5}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"y = add_two(x)"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{"add_two": add_two}				,			state=__a    )
           assert result == 5
           self.assertDictEqual(__a				,			{"x": 3, "y": 5}    )

           # Won't work without the tool
           with CaptureStdout() as out:
                 lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           assert result is None
           assert "tried to execute add_two" in out.out







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"x = 3"
           lowerCamelCase								=		{}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           assert result == 3
           self.assertDictEqual(__a				,			{"x": 3}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"test_dict = {'x': x, 'y': add_two(x)}"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{"add_two": add_two}				,			state=__a    )
           self.assertDictEqual(__a				,			{"x": 3, "y": 5}    )
           self.assertDictEqual(__a				,			{"x": 3, "test_dict": {"x": 3, "y": 5}}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"x = 3\ny = 5"
           lowerCamelCase								=		{}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           # evaluate returns the value of the last assignment.
           assert result == 5
           self.assertDictEqual(__a				,			{"x": 3, "y": 5}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"text = f'This is x: {x}.'"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           # evaluate returns the value of the last assignment.
           assert result == "This is x: 3."
           self.assertDictEqual(__a				,			{"x": 3, "text": "This is x: 3."}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"if x <= 3:\n    y = 2\nelse:\n    y = 5"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           # evaluate returns the value of the last assignment.
           assert result == 2
           self.assertDictEqual(__a				,			{"x": 3, "y": 2}    )

           lowerCamelCase								=		{"x": 8}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           # evaluate returns the value of the last assignment.
           assert result == 5
           self.assertDictEqual(__a				,			{"x": 8, "y": 5}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"test_list = [x, add_two(x)]"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{"add_two": add_two}				,			state=__a    )
           self.assertListEqual(__a				,			[3, 5]    )
           self.assertDictEqual(__a				,			{"x": 3, "test_list": [3, 5]}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"y = x"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{}				,			state=__a    )
           assert result == 3
           self.assertDictEqual(__a				,			{"x": 3, "y": 3}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"test_list = [x, add_two(x)]\ntest_list[1]"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{"add_two": add_two}				,			state=__a    )
           assert result == 5
           self.assertDictEqual(__a				,			{"x": 3, "test_list": [3, 5]}    )

           lowerCamelCase								=		"test_dict = {'x': x, 'y': add_two(x)}\ntest_dict['y']"
           lowerCamelCase								=		{"x": 3}
           lowerCamelCase								=		evaluate(__a				,			{"add_two": add_two}				,			state=__a    )
           assert result == 5
           self.assertDictEqual(__a				,			{"x": 3, "test_dict": {"x": 3, "y": 5}}    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		"x = 0\nfor i in range(3):\n    x = i"
           lowerCamelCase								=		{}
           lowerCamelCase								=		evaluate(__a				,			{"range": range}				,			state=__a    )
           assert result == 2
           self.assertDictEqual(__a				,			{"x": 2, "i": 2}    )