
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        _SCREAMING_SNAKE_CASE	:
      def __init__(      self		,						lowerCamelCase		,						):
          snake_case__    =					parent
          snake_case__    =					13
          snake_case__    =					7
          snake_case__    =					True
          snake_case__    =					True
          snake_case__    =					True
          snake_case__    =					True
          snake_case__    =					True
          snake_case__    =					False
          snake_case__    =					False
          snake_case__    =					False
          snake_case__    =					2
          snake_case__    =					99
          snake_case__    =					0
          snake_case__    =					32
          snake_case__    =					2
          snake_case__    =					4
          snake_case__    =					0.1
          snake_case__    =					0.1
          snake_case__    =					5_12
          snake_case__    =					16
          snake_case__    =					2
          snake_case__    =					0.0_2
          snake_case__    =					3
          snake_case__    =					4
          snake_case__    =					"last"
          snake_case__    =					True
          snake_case__    =					None
          snake_case__    =					0
      def A_      (      self			):
          snake_case__    =					ids_tensor([self.batch_size, self.seq_length]		,						self.vocab_size			)
          snake_case__    =					random_attention_mask([self.batch_size, self.seq_length]		,						dtype=tf.floataa			)

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

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

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

          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		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					TFFlaubertModel(config=lowerCamelCase			)
          snake_case__    =					{"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
          snake_case__    =					model(lowerCamelCase			)

          snake_case__    =					[input_ids, input_mask]
          snake_case__    =					model(lowerCamelCase			)
          self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					TFFlaubertWithLMHeadModel(lowerCamelCase			)

          snake_case__    =					{"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
          snake_case__    =					model(lowerCamelCase			)

          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.vocab_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					TFFlaubertForQuestionAnsweringSimple(lowerCamelCase			)

          snake_case__    =					{"input_ids": input_ids, "lengths": input_lengths}

          snake_case__    =					model(lowerCamelCase			)

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

          snake_case__    =					{"input_ids": input_ids, "lengths": input_lengths}

          snake_case__    =					model(lowerCamelCase			)

          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.type_sequence_label_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					self.num_labels
          snake_case__    =					TFFlaubertForTokenClassification(config=lowerCamelCase			)
          snake_case__    =					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          snake_case__    =					model(lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.num_labels)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					self.num_choices
          snake_case__    =					TFFlaubertForMultipleChoice(config=lowerCamelCase			)
          snake_case__    =					tf.tile(tf.expand_dims(lowerCamelCase		,						1			)		,						(1, self.num_choices, 1)			)
          snake_case__    =					tf.tile(tf.expand_dims(lowerCamelCase		,						1			)		,						(1, self.num_choices, 1)			)
          snake_case__    =					tf.tile(tf.expand_dims(lowerCamelCase		,						1			)		,						(1, self.num_choices, 1)			)
          snake_case__    =					{
              "input_ids": multiple_choice_inputs_ids,
              "attention_mask": multiple_choice_input_mask,
              "token_type_ids": multiple_choice_token_type_ids,
          }
          snake_case__    =					model(lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_choices)			)



      def A_      (      self			):
          snake_case__    =					self.prepare_config_and_inputs()
          (
              (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       (
              snake_case__
          )    ,       
          )    =					config_and_inputs
          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        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       __UpperCamelCase							,       unittest.TestCase			):
      _A    :		Any     						=  (
          (
              TFFlaubertModel,
              TFFlaubertWithLMHeadModel,
              TFFlaubertForSequenceClassification,
              TFFlaubertForQuestionAnsweringSimple,
              TFFlaubertForTokenClassification,
              TFFlaubertForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      _A    :		str     						=  (
          (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      _A    :		Union[str, Any]     						=  (
          {
              'feature-extraction': TFFlaubertModel,
              'fill-mask': TFFlaubertWithLMHeadModel,
              'question-answering': TFFlaubertForQuestionAnsweringSimple,
              'text-classification': TFFlaubertForSequenceClassification,
              'token-classification': TFFlaubertForTokenClassification,
              'zero-shot': TFFlaubertForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      _A    :		Optional[Any]     						=  False
      _A    :		Union[str, Any]     						=  False
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          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			):
          snake_case__    =					TFFlaubertModelTester(self			)
          snake_case__    =					ConfigTester(self		,						config_class=lowerCamelCase		,						emb_dim=37			)
      def A_      (      self			):
          self.config_tester.run_common_tests()
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_flaubert_model(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_flaubert_lm_head(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_flaubert_qa(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_flaubert_sequence_classif(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_flaubert_for_token_classification(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_flaubert_for_multiple_choice(*lowerCamelCase			)



      @slow
      def A_      (      self			):
          for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case__    =					TFFlaubertModel.from_pretrained(lowerCamelCase			)
              self.assertIsNotNone(lowerCamelCase			)





@require_tf
@require_sentencepiece
@require_tokenizers
class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      @slow
      def A_      (      self			):
          snake_case__    =					TFFlaubertModel.from_pretrained("jplu/tf-flaubert-small-cased"			)

          snake_case__    =					tf.convert_to_tensor(
              [[0, 1_58, 7_35, 25_92, 14_24, 67_27, 82, 1]]		,						dtype=tf.intaa		,						)  # "J'aime flaubert !"

          snake_case__    =					model(lowerCamelCase			)[0]
          snake_case__    =					tf.TensorShape((1, 8, 5_12)			)
          self.assertEqual(output.shape		,						lowerCamelCase			)
          # compare the actual values for a slice.
          snake_case__    =					tf.convert_to_tensor(
              [
                  [
                      [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
                      [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
                      [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
                  ]
              ]		,						dtype=tf.floataa		,						)

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





import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import is_speech_available, is_vision_available
from transformers.testing_utils import require_torch


if is_vision_available():
     from transformers import TvltImageProcessor

if is_speech_available():
     from transformers import TvltFeatureExtractor

from transformers import TvltProcessor




@require_torch
class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      def A_      (      self			):
          snake_case__    =					"ZinengTang/tvlt-base"
          snake_case__    =					tempfile.mkdtemp()
      def A_      (      self		,						**lowerCamelCase			):
          return TvltImageProcessor.from_pretrained(self.checkpoint		,						**lowerCamelCase			)
      def A_      (      self		,						**lowerCamelCase			):
          return TvltFeatureExtractor.from_pretrained(self.checkpoint		,						**lowerCamelCase			)
      def A_      (      self			):
          shutil.rmtree(self.tmpdirname			)
      def A_      (      self			):
          snake_case__    =					self.get_image_processor()
          snake_case__    =					self.get_feature_extractor()

          snake_case__    =					TvltProcessor(image_processor=lowerCamelCase		,						feature_extractor=lowerCamelCase			)
          processor.save_pretrained(self.tmpdirname			)
          snake_case__    =					TvltProcessor.from_pretrained(self.tmpdirname			)

          self.assertIsInstance(processor.feature_extractor		,						lowerCamelCase			)
          self.assertIsInstance(processor.image_processor		,						lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.get_image_processor()
          snake_case__    =					self.get_feature_extractor()

          snake_case__    =					TvltProcessor(image_processor=lowerCamelCase		,						feature_extractor=lowerCamelCase			)

          snake_case__    =					np.ones([1_20_00]			)

          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="np"			)
          snake_case__    =					processor(audio=lowerCamelCase		,						return_tensors="np"			)

          for key in audio_dict.keys():
              self.assertAlmostEqual(audio_dict[key].sum()		,						input_processor[key].sum()		,						delta=1e-2			)
      def A_      (      self			):
          snake_case__    =					self.get_image_processor()
          snake_case__    =					self.get_feature_extractor()

          snake_case__    =					TvltProcessor(image_processor=lowerCamelCase		,						feature_extractor=lowerCamelCase			)

          snake_case__    =					np.ones([3, 2_24, 2_24]			)

          snake_case__    =					image_processor(lowerCamelCase		,						return_tensors="np"			)
          snake_case__    =					processor(images=lowerCamelCase		,						return_tensors="np"			)

          for key in image_dict.keys():
              self.assertAlmostEqual(image_dict[key].sum()		,						input_processor[key].sum()		,						delta=1e-2			)
      def A_      (      self			):
          snake_case__    =					self.get_image_processor()
          snake_case__    =					self.get_feature_extractor()

          snake_case__    =					TvltProcessor(image_processor=lowerCamelCase		,						feature_extractor=lowerCamelCase			)

          snake_case__    =					np.ones([1_20_00]			)
          snake_case__    =					np.ones([3, 2_24, 2_24]			)

          snake_case__    =					processor(audio=lowerCamelCase		,						images=lowerCamelCase			)

          self.assertListEqual(list(inputs.keys()			)		,						["audio_values", "audio_mask", "pixel_values", "pixel_mask"]			)

          # test if it raises when no input is passed
          with pytest.raises(lowerCamelCase			):
              processor()



      def A_      (      self			):
          snake_case__    =					self.get_image_processor()
          snake_case__    =					self.get_feature_extractor()

          snake_case__    =					TvltProcessor(image_processor=lowerCamelCase		,						feature_extractor=lowerCamelCase			)

          self.assertListEqual(
              processor.model_input_names		,						image_processor.model_input_names + feature_extractor.model_input_names		,						msg="`processor` and `image_processor`+`feature_extractor` model input names do not match"		,						)



