






'''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      __SCREAMING_SNAKE_CASE					:


  """simple docstring"""


  def __init__( self      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = parent
         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_	    = 2
         a_	    = 4
         a_	    = 0.1
         a_	    = 0.1
         a_	    = 512
         a_	    = 16
         a_	    = 2
         a_	    = 0.02
         a_	    = 3
         a_	    = 4
         a_	    = 'last'
         a_	    = True
         a_	    = None
         a_	    = 0







  def       _a					( self  ):






         """simple docstring"""


         a_	    = ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size  )
         a_	    = random_attention_mask([self.batch_size, self.seq_length]      ,  dtype=tf.floataa  )

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

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

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

         a_	    = 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      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = TFXLMModel(config=UpperCamelCase__  )
         a_	    = {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
         a_	    = model(UpperCamelCase__  )

         a_	    = [input_ids, input_mask]
         a_	    = model(UpperCamelCase__  )
         self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = TFXLMWithLMHeadModel(UpperCamelCase__  )

         a_	    = {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
         a_	    = model(UpperCamelCase__  )

         a_	    = outputs

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







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = TFXLMForQuestionAnsweringSimple(UpperCamelCase__  )

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

         a_	    = 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      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = TFXLMForSequenceClassification(UpperCamelCase__  )

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

         a_	    = model(UpperCamelCase__  )

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







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = self.num_labels
         a_	    = TFXLMForTokenClassification(config=UpperCamelCase__  )
         a_	    = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         a_	    = model(UpperCamelCase__  )
         self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.num_labels)  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = self.num_choices
         a_	    = TFXLMForMultipleChoice(config=UpperCamelCase__  )
         a_	    = tf.tile(tf.expand_dims(UpperCamelCase__      ,  1  )      ,  (1, self.num_choices, 1)  )
         a_	    = tf.tile(tf.expand_dims(UpperCamelCase__      ,  1  )      ,  (1, self.num_choices, 1)  )
         a_	    = tf.tile(tf.expand_dims(UpperCamelCase__      ,  1  )      ,  (1, self.num_choices, 1)  )
         a_	    = {
             'input_ids': multiple_choice_inputs_ids,
             'attention_mask': multiple_choice_input_mask,
             'token_type_ids': multiple_choice_token_type_ids,
         }
         a_	    = model(UpperCamelCase__  )
         self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_choices)  )







  def       _a					( self  ):






         """simple docstring"""


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





@require_tf
class      __SCREAMING_SNAKE_CASE					(__A       ,					__A       ,					unittest.TestCase					):


  """simple docstring"""


  _a     :   Tuple			 =    (
      (
          TFXLMModel,
          TFXLMWithLMHeadModel,
          TFXLMForSequenceClassification,
          TFXLMForQuestionAnsweringSimple,
          TFXLMForTokenClassification,
          TFXLMForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  _a     :   Optional[int]			 =    (
      (TFXLMWithLMHeadModel,) if is_tf_available() else ()
  )  # TODO (PVP): Check other models whether language generation is also applicable
  _a     :   Optional[int]			 =    (
      {
          '''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 {}
  )
  _a     :   str			 =    False
  _a     :   Any			 =    False







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """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  ):






         """simple docstring"""


         a_	    = TFXLMModelTester(self  )
         a_	    = ConfigTester(self      ,  config_class=UpperCamelCase__      ,  emb_dim=37  )







  def       _a					( self  ):






         """simple docstring"""


         self.config_tester.run_common_tests()







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_token_classification(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCamelCase__  )







  @slow
  def       _a					( self  ):






         """simple docstring"""


         for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                a_	    = TFXLMModel.from_pretrained(UpperCamelCase__  )
                self.assertIsNotNone(UpperCamelCase__  )





@require_tf
class      __SCREAMING_SNAKE_CASE					(unittest.TestCase					):


  """simple docstring"""


  @slow
  def       _a					( self  ):






         """simple docstring"""


         a_	    = TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'  )
         a_	    = tf.convert_to_tensor([[14, 447]]      ,  dtype=tf.intaa  )  # the president
         a_	    = [
             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
         a_	    = model.generate(UpperCamelCase__      ,  do_sample=UpperCamelCase__  )
         self.assertListEqual(output_ids[0].numpy().tolist()      ,  UpperCamelCase__  )












'''simple docstring'''







import re


def 			__UpperCamelCase				(			lowercase_					:     int      ):
       """simple docstring"""




       def docstring_decorator(lowercase_					:     int      ):
              a_	    = fn.__doc__
              a_	    = func_doc.split('\n'      )
              a_	    = 0
              while i < len(lowercase_      ) and re.search(R'^\s*Examples?:\s*$'      ,					lines[i]      ) is None:
                     i += 1
              if i < len(lowercase_      ):
                     a_	    = example_docstring
                     a_	    = '\n'.join(lowercase_      )
              else:
                     raise ValueError(
                         F'The function {fn} should have an empty \'Examples:\' in its docstring as placeholder, '
                         F'current docstring is:\n{func_doc}'      )
              a_	    = func_doc
              return fn

       return docstring_decorator




