




import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput

@dataclass
class 			_lowerCamelCase    (      _SCREAMING_SNAKE_CASE ):

      """simple docstring"""

      lowerCAmelCase__      :			float
      lowerCAmelCase__      :			Optional[float]     =       None
      lowerCAmelCase__      :			Optional[float]     =       None







class 			_lowerCamelCase    (      unittest.TestCase ):

      """simple docstring"""

      def    snake_case						(  self       :			str					):
          __UpperCamelCase			=    ModelOutputTest(a=30					)
          self.assertEqual(x.a			,							30					)
          self.assertIsNone(x.b					)
          self.assertIsNone(x.c					)
          with self.assertRaises(snake_case					):
              __UpperCamelCase			=    x.d







      def    snake_case						(  self       :			Tuple					):
          __UpperCamelCase			=    ModelOutputTest(a=30			,							b=10					)
          self.assertEqual(x[0]			,							30					)
          self.assertEqual(x[1]			,							10					)
          self.assertEqual(x[:2]			,							(30, 10)					)
          self.assertEqual(x[:]			,							(30, 10)					)

          __UpperCamelCase			=    ModelOutputTest(a=30			,							c=10					)
          self.assertEqual(x[0]			,							30					)
          self.assertEqual(x[1]			,							10					)
          self.assertEqual(x[:2]			,							(30, 10)					)
          self.assertEqual(x[:]			,							(30, 10)					)







      def    snake_case						(  self       :			List[str]					):
          __UpperCamelCase			=    ModelOutputTest(a=30			,							b=10					)
          self.assertEqual(x['''a''']			,							30					)
          self.assertEqual(x['''b''']			,							10					)
          with self.assertRaises(snake_case					):
              __UpperCamelCase			=    x['''c''']

          __UpperCamelCase			=    ModelOutputTest(a=30			,							c=10					)
          self.assertEqual(x['''a''']			,							30					)
          self.assertEqual(x['''c''']			,							10					)
          with self.assertRaises(snake_case					):
              __UpperCamelCase			=    x['''b''']







      def    snake_case						(  self       :			Tuple					):
          __UpperCamelCase			=    ModelOutputTest(a=30					)
          self.assertEqual(list(x.keys()					)			,							['''a''']					)
          self.assertEqual(list(x.values()					)			,							[30]					)
          self.assertEqual(list(x.items()					)			,							[('''a''', 30)]					)
          self.assertEqual(list(snake_case					)			,							['''a''']					)

          __UpperCamelCase			=    ModelOutputTest(a=30			,							b=10					)
          self.assertEqual(list(x.keys()					)			,							['''a''', '''b''']					)
          self.assertEqual(list(x.values()					)			,							[30, 10]					)
          self.assertEqual(list(x.items()					)			,							[('''a''', 30), ('''b''', 10)]					)
          self.assertEqual(list(snake_case					)			,							['''a''', '''b''']					)

          __UpperCamelCase			=    ModelOutputTest(a=30			,							c=10					)
          self.assertEqual(list(x.keys()					)			,							['''a''', '''c''']					)
          self.assertEqual(list(x.values()					)			,							[30, 10]					)
          self.assertEqual(list(x.items()					)			,							[('''a''', 30), ('''c''', 10)]					)
          self.assertEqual(list(snake_case					)			,							['''a''', '''c''']					)

          with self.assertRaises(snake_case					):
              __UpperCamelCase			=    x.update({'''d''': 20}					)
          with self.assertRaises(snake_case					):
              del x["a"]
          with self.assertRaises(snake_case					):
              __UpperCamelCase			=    x.pop('''a'''					)
          with self.assertRaises(snake_case					):
              __UpperCamelCase			=    x.setdefault('''d'''			,							32					)







      def    snake_case						(  self       :			Optional[Any]					):
          __UpperCamelCase			=    ModelOutputTest(a=30					)
          __UpperCamelCase			=    10
          self.assertEqual(x.a			,							10					)
          self.assertEqual(x['''a''']			,							10					)







      def    snake_case						(  self       :			Optional[int]					):
          __UpperCamelCase			=    ModelOutputTest(a=30					)
          __UpperCamelCase			=    10
          self.assertEqual(x.a			,							10					)
          self.assertEqual(x['''a''']			,							10					)







      def    snake_case						(  self       :			Optional[Any]					):
          __UpperCamelCase			=    ModelOutputTest({'''a''': 30, '''b''': 10}					)
          self.assertEqual(list(x.keys()					)			,							['''a''', '''b''']					)
          self.assertEqual(x.a			,							30					)
          self.assertEqual(x.b			,							10					)







      def    snake_case						(  self       :			Any					):
          __UpperCamelCase			=    ModelOutputTest([('''a''', 30), ('''b''', 10)]					)
          self.assertEqual(list(x.keys()					)			,							['''a''', '''b''']					)
          self.assertEqual(x.a			,							30					)
          self.assertEqual(x.b			,							10					)

          with self.assertRaises(snake_case					):
              __UpperCamelCase			=    ModelOutputTest([('''a''', 30), (10, 10)]					)

          __UpperCamelCase			=    ModelOutputTest(a=(30, 30)					)
          self.assertEqual(list(x.keys()					)			,							['''a''']					)
          self.assertEqual(x.a			,							(30, 30)					)








'''simple docstring'''






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFXLMForMultipleChoice,
							    TFXLMForQuestionAnsweringSimple,
							    TFXLMForSequenceClassification,
							    TFXLMForTokenClassification,
							    TFXLMModel,
							    TFXLMWithLMHeadModel,
							    XLMConfig,
							)

class 							_snake_case     :
	"""simple docstring"""





	def __init__(						self				: str					,						UpperCamelCase_				: Union[str, Any]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=parent
			lowerCAmelCase_   :       Any    							=13
			lowerCAmelCase_   :       str    							=7
			lowerCAmelCase_   :       Optional[Any]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       List[str]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Dict    							=True
			lowerCAmelCase_   :       Union[str, Any]    							=False
			lowerCAmelCase_   :       List[Any]    							=False
			lowerCAmelCase_   :       Optional[int]    							=False
			lowerCAmelCase_   :       Union[str, Any]    							=2
			lowerCAmelCase_   :       List[str]    							=99
			lowerCAmelCase_   :       Optional[int]    							=0
			lowerCAmelCase_   :       Optional[int]    							=32
			lowerCAmelCase_   :       Dict    							=2
			lowerCAmelCase_   :       Dict    							=4
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=512
			lowerCAmelCase_   :       Dict    							=16
			lowerCAmelCase_   :       List[Any]    							=2
			lowerCAmelCase_   :       Optional[int]    							=0.0_2
			lowerCAmelCase_   :       int    							=3
			lowerCAmelCase_   :       int    							=4
			lowerCAmelCase_   :       Union[str, Any]    							='''last'''
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Any    							=None
			lowerCAmelCase_   :       int    							=0




	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       List[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size      )
			lowerCAmelCase_   :       Union[str, Any]    							=random_attention_mask([self.batch_size, self.seq_length]					,						dtype=tf.floataa      )

			lowerCAmelCase_   :       List[str]    							=None
			if self.use_input_lengths:
					lowerCAmelCase_   :       Optional[Any]    							=(
					    ids_tensor([self.batch_size]					,						vocab_size=2      ) + self.seq_length - 2
					)  # small variation of seq_length

			lowerCAmelCase_   :       str    							=None
			if self.use_token_type_ids:
					lowerCAmelCase_   :       Optional[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.n_langs      )

			lowerCAmelCase_   :       Optional[int]    							=None
			lowerCAmelCase_   :       str    							=None
			lowerCAmelCase_   :       Dict    							=None
			if self.use_labels:
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size]					,						self.type_sequence_label_size      )
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size, self.seq_length]					,						self.num_labels      )
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size]					,						2					,						dtype=tf.floataa      )
					lowerCAmelCase_   :       Optional[Any]    							=ids_tensor([self.batch_size]					,						self.num_choices      )

			lowerCAmelCase_   :       Tuple    							=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					,						bos_token_id=self.bos_token_id					,						)

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




	def 	__A      (						self				: Any					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Tuple					,						):
			lowerCAmelCase_   :       int    							=TFXLMModel(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Union[str, Any]    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       Union[str, Any]    							=[input_ids, input_mask]
			lowerCAmelCase_   :       List[Any]    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.last_hidden_state.shape					,						(self.batch_size, self.seq_length, self.hidden_size)      )




	def 	__A      (						self				: List[Any]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: List[Any]					,						):
			lowerCAmelCase_   :       List[str]    							=TFXLMWithLMHeadModel(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Tuple    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       int    							=outputs

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.vocab_size)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=TFXLMForQuestionAnsweringSimple(UpperCamelCase_      )

			lowerCAmelCase_   :       str    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       Optional[Any]    							=model(UpperCamelCase_      )

			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				: Tuple					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[Any]    							=TFXLMForSequenceClassification(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       int    							=model(UpperCamelCase_      )

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.type_sequence_label_size)      )




	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=self.num_labels
			lowerCAmelCase_   :       int    							=TFXLMForTokenClassification(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
			lowerCAmelCase_   :       str    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.num_labels)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[str]    							=self.num_choices
			lowerCAmelCase_   :       Tuple    							=TFXLMForMultipleChoice(config=UpperCamelCase_      )
			lowerCAmelCase_   :       str    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Union[str, Any]    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Any    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Optional[Any]    							={
			    '''input_ids''': multiple_choice_inputs_ids,
			    '''attention_mask''': multiple_choice_input_mask,
			    '''token_type_ids''': multiple_choice_token_type_ids,
			}
			lowerCAmelCase_   :       Any    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_choices)      )





	def 	__A      (						self				: Union[str, Any]      ):
			lowerCAmelCase_   :       List[Any]    							=self.prepare_config_and_inputs()
			(
			    (
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		
			)   :       List[str]    							=config_and_inputs
			lowerCAmelCase_   :       List[Any]    							={
			    '''input_ids''': input_ids,
			    '''token_type_ids''': token_type_ids,
			    '''langs''': token_type_ids,
			    '''lengths''': input_lengths,
			}
			return config, inputs_dict







@require_tf
class 							_snake_case     (  lowerCAmelCase_						,    lowerCAmelCase_						,    unittest.TestCase ):
	"""simple docstring"""





	_UpperCamelCase							:  Union[str, Any]								=		(
	    (
	        TFXLMModel,
	        TFXLMWithLMHeadModel,
	        TFXLMForSequenceClassification,
	        TFXLMForQuestionAnsweringSimple,
	        TFXLMForTokenClassification,
	        TFXLMForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	_UpperCamelCase							:  Union[str, Any]								=		(
	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	_UpperCamelCase							:  List[str]								=		(
	    {
	        '''feature-extraction''': TFXLMModel,
	        '''fill-mask''': TFXLMWithLMHeadModel,
	        '''question-answering''': TFXLMForQuestionAnsweringSimple,
	        '''text-classification''': TFXLMForSequenceClassification,
	        '''text-generation''': TFXLMWithLMHeadModel,
	        '''token-classification''': TFXLMForTokenClassification,
	        '''zero-shot''': TFXLMForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	_UpperCamelCase							:  Optional[int]								=		False
	_UpperCamelCase							:  int								=		False




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[str]      ):
			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				: List[Any]      ):
			lowerCAmelCase_   :       Union[str, Any]    							=TFXLMModelTester(self      )
			lowerCAmelCase_   :       Optional[Any]    							=ConfigTester(self					,						config_class=UpperCamelCase_					,						emb_dim=37      )




	def 	__A      (						self				: Union[str, Any]      ):
			self.config_tester.run_common_tests()




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_model(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_lm_head(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       int    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_qa(*UpperCamelCase_      )




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_sequence_classif(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_token_classification(*UpperCamelCase_      )




	def 	__A      (						self				: List[Any]      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCamelCase_      )





	@slow
	def 	__A      (						self				: List[Any]      ):
			for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCAmelCase_   :       List[str]    							=TFXLMModel.from_pretrained(UpperCamelCase_      )
					self.assertIsNotNone(UpperCamelCase_      )







@require_tf
class 							_snake_case     (  unittest.TestCase ):
	"""simple docstring"""





	@slow
	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       Any    							=TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''      )
			lowerCAmelCase_   :       List[str]    							=tf.convert_to_tensor([[14, 447]]					,						dtype=tf.intaa      )  # the president
			lowerCAmelCase_   :       List[Any]    							=[
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			]  # 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_   :       Optional[int]    							=model.generate(UpperCamelCase_					,						do_sample=UpperCamelCase_      )
			self.assertListEqual(output_ids[0].numpy().tolist()					,						UpperCamelCase_      )






