

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 						a_			:



      """simple docstring"""







      def __init__( self	:				str     ,snake_case	:				int     ,):
           SCREAMING_SNAKE_CASE 		=parent
           SCREAMING_SNAKE_CASE 		=13
           SCREAMING_SNAKE_CASE 		=7
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=False
           SCREAMING_SNAKE_CASE 		=False
           SCREAMING_SNAKE_CASE 		=False
           SCREAMING_SNAKE_CASE 		=2
           SCREAMING_SNAKE_CASE 		=99
           SCREAMING_SNAKE_CASE 		=0
           SCREAMING_SNAKE_CASE 		=32
           SCREAMING_SNAKE_CASE 		=2
           SCREAMING_SNAKE_CASE 		=4
           SCREAMING_SNAKE_CASE 		=0.1
           SCREAMING_SNAKE_CASE 		=0.1
           SCREAMING_SNAKE_CASE 		=512
           SCREAMING_SNAKE_CASE 		=16
           SCREAMING_SNAKE_CASE 		=2
           SCREAMING_SNAKE_CASE 		=0.02
           SCREAMING_SNAKE_CASE 		=3
           SCREAMING_SNAKE_CASE 		=4
           SCREAMING_SNAKE_CASE 		='last'
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=None
           SCREAMING_SNAKE_CASE 		=0
      def 			_lowerCAmelCase	( self	:				Tuple							):
           SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size, self.seq_length]     ,self.vocab_size							)
           SCREAMING_SNAKE_CASE 		=random_attention_mask([self.batch_size, self.seq_length]     ,dtype=tf.floataa							)

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

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

           SCREAMING_SNAKE_CASE 		=None
           SCREAMING_SNAKE_CASE 		=None
           SCREAMING_SNAKE_CASE 		=None
           if self.use_labels:
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size]     ,self.type_sequence_label_size							)
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size, self.seq_length]     ,self.num_labels							)
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size]     ,2     ,dtype=tf.floataa							)
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size]     ,self.num_choices							)

           SCREAMING_SNAKE_CASE 		=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 			_lowerCAmelCase	( self	:				List[Any]     ,snake_case	:				int     ,snake_case	:				List[Any]     ,snake_case	:				List[Any]     ,snake_case	:				Tuple     ,snake_case	:				int     ,snake_case	:				int     ,snake_case	:				Any     ,snake_case	:				Optional[int]     ,snake_case	:				int     ,):
           SCREAMING_SNAKE_CASE 		=TFXLMModel(config=snake_case							)
           SCREAMING_SNAKE_CASE 		={'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
           SCREAMING_SNAKE_CASE 		=model(snake_case							)

           SCREAMING_SNAKE_CASE 		=[input_ids, input_mask]
           SCREAMING_SNAKE_CASE 		=model(snake_case							)
           self.parent.assertEqual(result.last_hidden_state.shape     ,(self.batch_size, self.seq_length, self.hidden_size)							)
      def 			_lowerCAmelCase	( self	:				int     ,snake_case	:				Any     ,snake_case	:				Any     ,snake_case	:				Tuple     ,snake_case	:				int     ,snake_case	:				Optional[Any]     ,snake_case	:				List[Any]     ,snake_case	:				Optional[Any]     ,snake_case	:				int     ,snake_case	:				str     ,):
           SCREAMING_SNAKE_CASE 		=TFXLMWithLMHeadModel(snake_case							)

           SCREAMING_SNAKE_CASE 		={'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
           SCREAMING_SNAKE_CASE 		=model(snake_case							)

           SCREAMING_SNAKE_CASE 		=outputs

           self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.seq_length, self.vocab_size)							)
      def 			_lowerCAmelCase	( self	:				Optional[int]     ,snake_case	:				str     ,snake_case	:				int     ,snake_case	:				Optional[int]     ,snake_case	:				int     ,snake_case	:				Dict     ,snake_case	:				int     ,snake_case	:				List[Any]     ,snake_case	:				Tuple     ,snake_case	:				Union[str, Any]     ,):
           SCREAMING_SNAKE_CASE 		=TFXLMForQuestionAnsweringSimple(snake_case							)

           SCREAMING_SNAKE_CASE 		={'input_ids': input_ids, 'lengths': input_lengths}

           SCREAMING_SNAKE_CASE 		=model(snake_case							)

           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 			_lowerCAmelCase	( self	:				List[str]     ,snake_case	:				int     ,snake_case	:				Union[str, Any]     ,snake_case	:				Dict     ,snake_case	:				Dict     ,snake_case	:				List[Any]     ,snake_case	:				Dict     ,snake_case	:				Any     ,snake_case	:				Tuple     ,snake_case	:				str     ,):
           SCREAMING_SNAKE_CASE 		=TFXLMForSequenceClassification(snake_case							)

           SCREAMING_SNAKE_CASE 		={'input_ids': input_ids, 'lengths': input_lengths}

           SCREAMING_SNAKE_CASE 		=model(snake_case							)

           self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size)							)
      def 			_lowerCAmelCase	( self	:				int     ,snake_case	:				Dict     ,snake_case	:				Any     ,snake_case	:				Tuple     ,snake_case	:				List[str]     ,snake_case	:				List[str]     ,snake_case	:				Optional[Any]     ,snake_case	:				Dict     ,snake_case	:				Any     ,snake_case	:				List[str]     ,):
           SCREAMING_SNAKE_CASE 		=self.num_labels
           SCREAMING_SNAKE_CASE 		=TFXLMForTokenClassification(config=snake_case							)
           SCREAMING_SNAKE_CASE 		={'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
           SCREAMING_SNAKE_CASE 		=model(snake_case							)
           self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.seq_length, self.num_labels)							)
      def 			_lowerCAmelCase	( self	:				int     ,snake_case	:				List[Any]     ,snake_case	:				Dict     ,snake_case	:				Optional[Any]     ,snake_case	:				Dict     ,snake_case	:				Dict     ,snake_case	:				Optional[int]     ,snake_case	:				int     ,snake_case	:				Dict     ,snake_case	:				List[Any]     ,):
           SCREAMING_SNAKE_CASE 		=self.num_choices
           SCREAMING_SNAKE_CASE 		=TFXLMForMultipleChoice(config=snake_case							)
           SCREAMING_SNAKE_CASE 		=tf.tile(tf.expand_dims(snake_case     ,1							)     ,(1, self.num_choices, 1)							)
           SCREAMING_SNAKE_CASE 		=tf.tile(tf.expand_dims(snake_case     ,1							)     ,(1, self.num_choices, 1)							)
           SCREAMING_SNAKE_CASE 		=tf.tile(tf.expand_dims(snake_case     ,1							)     ,(1, self.num_choices, 1)							)
           SCREAMING_SNAKE_CASE 		={
               'input_ids': multiple_choice_inputs_ids,
               'attention_mask': multiple_choice_input_mask,
               'token_type_ids': multiple_choice_token_type_ids,
           }
           SCREAMING_SNAKE_CASE 		=model(snake_case							)
           self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_choices)							)


      def 			_lowerCAmelCase	( self	:				Tuple							):
           SCREAMING_SNAKE_CASE 		=self.prepare_config_and_inputs()
           (
               (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    
           ) 		=config_and_inputs
           SCREAMING_SNAKE_CASE 		={
               'input_ids': input_ids,
               'token_type_ids': token_type_ids,
               'langs': token_type_ids,
               'lengths': input_lengths,
           }
           return config, inputs_dict







@require_tf
class 						a_			(				lowerCamelCase_					,     lowerCamelCase_					,     unittest.TestCase	):



      """simple docstring"""







      __UpperCAmelCase     						= (
          (
              TFXLMModel,
              TFXLMWithLMHeadModel,
              TFXLMForSequenceClassification,
              TFXLMForQuestionAnsweringSimple,
              TFXLMForTokenClassification,
              TFXLMForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      __UpperCAmelCase     						= (
          (TFXLMWithLMHeadModel,) if is_tf_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      __UpperCAmelCase     						= (
          {
              '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     						= False
      __UpperCAmelCase     						= False
      def 			_lowerCAmelCase	( self	:				Optional[int]     ,snake_case	:				List[Any]     ,snake_case	:				Optional[int]     ,snake_case	:				str     ,snake_case	:				Optional[int]     ,snake_case	:				int							):
           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 			_lowerCAmelCase	( self	:				List[Any]							):
           SCREAMING_SNAKE_CASE 		=TFXLMModelTester(self							)
           SCREAMING_SNAKE_CASE 		=ConfigTester(self     ,config_class=snake_case     ,emb_dim=37							)
      def 			_lowerCAmelCase	( self	:				Dict							):
           self.config_tester.run_common_tests()
      def 			_lowerCAmelCase	( self	:				List[str]							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_model(*snake_case							)
      def 			_lowerCAmelCase	( self	:				str							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_lm_head(*snake_case							)
      def 			_lowerCAmelCase	( self	:				List[Any]							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_qa(*snake_case							)
      def 			_lowerCAmelCase	( self	:				Any							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_sequence_classif(*snake_case							)
      def 			_lowerCAmelCase	( self	:				int							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_token_classification(*snake_case							)
      def 			_lowerCAmelCase	( self	:				int							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case							)


      @slow
      def 			_lowerCAmelCase	( self	:				List[str]							):
           for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                SCREAMING_SNAKE_CASE 		=TFXLMModel.from_pretrained(snake_case							)
                self.assertIsNotNone(snake_case							)







@require_tf
class 						a_			(				unittest.TestCase	):



      """simple docstring"""







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




import math



class 						a_			:



      """simple docstring"""







      def __init__( self	:				str     ,snake_case	:				List[Any]     ,snake_case	:				Union[str, Any]     ,snake_case	:				Optional[int]							):
           SCREAMING_SNAKE_CASE 		=x
           SCREAMING_SNAKE_CASE 		=y
           SCREAMING_SNAKE_CASE 		=z


      def __repr__( self	:				Any							):
           return f'Point({self.x}, {self.y}, {self.z})'







def      snake_case__							(  lowerCAmelCase_,       lowerCAmelCase_     ):





     """simple docstring"""







     return math.sqrt(abs((b.x - a.x) ** 2 + (b.y - a.y) ** 2 + (b.z - a.z) ** 2     )     )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

