

'''simple docstring'''
from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, 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 numpy as np
     import tensorflow as tf

     from transformers import (
         TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
         FlaubertConfig,
         TFFlaubertForMultipleChoice,
         TFFlaubertForQuestionAnsweringSimple,
         TFFlaubertForSequenceClassification,
         TFFlaubertForTokenClassification,
         TFFlaubertModel,
         TFFlaubertWithLMHeadModel,
     )







class 							A__   :





  def __init__(		self				:     Any							, _a				:     List[str]							, )     ->   List[Any]:





       '''simple docstring'''






       _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 						A  (		self				:     List[Any]			)     ->   int:





       '''simple docstring'''






       _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							   =FlaubertConfig(
           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							, _a				:     Optional[int]							, _a				:     int							, _a				:     Any							, _a				:     Optional[int]							, _a				:     List[str]							, _a				:     List[Any]							, _a				:     Tuple							, _a				:     Any							, _a				:     List[Any]							, )     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFFlaubertModel(config=_a			)
       _SCREAMING_SNAKE_CASE							   ={'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
       _SCREAMING_SNAKE_CASE							   =model(_a			)

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





  def 						A  (		self				:     Optional[Any]							, _a				:     Any							, _a				:     List[str]							, _a				:     int							, _a				:     List[str]							, _a				:     List[Any]							, _a				:     Dict							, _a				:     List[Any]							, _a				:     Dict							, _a				:     Any							, )     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFFlaubertWithLMHeadModel(_a			)

       _SCREAMING_SNAKE_CASE							   ={'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
       _SCREAMING_SNAKE_CASE							   =model(_a			)

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





  def 						A  (		self				:     Tuple							, _a				:     Dict							, _a				:     Any							, _a				:     Optional[int]							, _a				:     Union[str, Any]							, _a				:     Any							, _a				:     Tuple							, _a				:     List[str]							, _a				:     Tuple							, _a				:     Union[str, Any]							, )     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFFlaubertForQuestionAnsweringSimple(_a			)

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

       _SCREAMING_SNAKE_CASE							   =model(_a			)

       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				:     List[Any]							, _a				:     Optional[int]							, _a				:     Dict							, _a				:     Union[str, Any]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     Optional[int]							, _a				:     str							, _a				:     Union[str, Any]							, _a				:     Dict							, )     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFFlaubertForSequenceClassification(_a			)

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

       _SCREAMING_SNAKE_CASE							   =model(_a			)

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





  def 						A  (		self				:     Dict							, _a				:     Union[str, Any]							, _a				:     str							, _a				:     List[str]							, _a				:     str							, _a				:     Optional[Any]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     Union[str, Any]							, _a				:     Optional[Any]							, )     ->   Any:





       '''simple docstring'''






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





  def 						A  (		self				:     Union[str, Any]							, _a				:     List[Any]							, _a				:     Optional[int]							, _a				:     List[Any]							, _a				:     List[Any]							, _a				:     Optional[int]							, _a				:     List[Any]							, _a				:     str							, _a				:     Optional[Any]							, _a				:     Tuple							, )     ->   Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.num_choices
       _SCREAMING_SNAKE_CASE							   =TFFlaubertForMultipleChoice(config=_a			)
       _SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
       _SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
       _SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 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(_a			)
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_choices)			)





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





       '''simple docstring'''






       _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__   (	A__					,       A__					,       unittest.TestCase  ):
  A__					=    (
      (
          TFFlaubertModel,
          TFFlaubertWithLMHeadModel,
          TFFlaubertForSequenceClassification,
          TFFlaubertForQuestionAnsweringSimple,
          TFFlaubertForTokenClassification,
          TFFlaubertForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  A__					=    (
      (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
  )  # TODO (PVP): Check other models whether language generation is also applicable
  A__					=    (
      {
          'feature-extraction': TFFlaubertModel,
          'fill-mask': TFFlaubertWithLMHeadModel,
          'question-answering': TFFlaubertForQuestionAnsweringSimple,
          'text-classification': TFFlaubertForSequenceClassification,
          'token-classification': TFFlaubertForTokenClassification,
          'zero-shot': TFFlaubertForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  A__					=    False
  A__					=    False





  def 						A  (		self				:     Optional[Any]							, _a				:     Tuple							, _a				:     Any							, _a				:     List[Any]							, _a				:     str							, _a				:     Optional[int]			)     ->   Optional[Any]:





       '''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				:     Optional[int]			)     ->   List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFFlaubertModelTester(self			)
       _SCREAMING_SNAKE_CASE							   =ConfigTester(self							, config_class=_a							, emb_dim=37			)





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





       '''simple docstring'''






       self.config_tester.run_common_tests()





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_model(*_a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_lm_head(*_a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_qa(*_a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_sequence_classif(*_a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_token_classification(*_a			)





  def 						A  (		self				:     int			)     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_multiple_choice(*_a			)





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





       '''simple docstring'''






       for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            _SCREAMING_SNAKE_CASE							   =TFFlaubertModel.from_pretrained(_a			)
            self.assertIsNotNone(_a			)







@require_tf
@require_sentencepiece
@require_tokenizers
class 							A__   (	unittest.TestCase  ):





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFFlaubertModel.from_pretrained('jplu/tf-flaubert-small-cased'			)

       _SCREAMING_SNAKE_CASE							   =tf.convert_to_tensor(
           [[0, 158, 735, 2592, 1424, 6727, 82, 1]]							, dtype=tf.intaa							, )  # "J'aime flaubert !"

       _SCREAMING_SNAKE_CASE							   =model(_a			)[0]
       _SCREAMING_SNAKE_CASE							   =tf.TensorShape((1, 8, 512)			)
       self.assertEqual(output.shape							, _a			)
       # compare the actual values for a slice.
       _SCREAMING_SNAKE_CASE							   =tf.convert_to_tensor(
           [
               [
                   [-1.8_76_87_73, -1.56_65_55, 0.27_07_24_18],
                   [-1.6_92_00_38, -0.5_87_35_05, 1.9_32_95_99],
                   [-2.9_56_39_85, -1.6_99_38_35, 1.7_97_20_52],
               ]
           ]							, dtype=tf.floataa							, )

       self.assertTrue(np.allclose(output[:, :3, :3].numpy()							, expected_slice.numpy()							, atol=1e-4			)			)



'''simple docstring'''
from ...utils import logging
from ..ta.modeling_tf_ta import TFTaEncoderModel, TFTaForConditionalGeneration, TFTaModel
from .configuration_mta import MTaConfig


lowerCamelCase			:				Optional[Any] 			=					logging.get_logger(__name__)

lowerCamelCase			:				Optional[Any] 			=					"T5Config"







class 							A__   (	A__  ):
  A__					=    'mt5'
  A__					=    MTaConfig







class 							A__   (	A__  ):
  A__					=    'mt5'
  A__					=    MTaConfig







class 							A__   (	A__  ):
  A__					=    'mt5'
  A__					=    MTaConfig
