


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






    '''simple docstring'''





    def __init__(	self				:   Optional[Any]       ,   __snake_case				:   List[str]       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      Any						=   parent
       UpperCAmelCase_							:      Dict						=   13
       UpperCAmelCase_							:      Any						=   7
       UpperCAmelCase_							:      str						=   True
       UpperCAmelCase_							:      str						=   True
       UpperCAmelCase_							:      Dict						=   True
       UpperCAmelCase_							:      Optional[Any]						=   True
       UpperCAmelCase_							:      Union[str, Any]						=   True
       UpperCAmelCase_							:      Optional[Any]						=   False
       UpperCAmelCase_							:      Tuple						=   False
       UpperCAmelCase_							:      Any						=   False
       UpperCAmelCase_							:      Any						=   2
       UpperCAmelCase_							:      List[Any]						=   99
       UpperCAmelCase_							:      Optional[int]						=   0
       UpperCAmelCase_							:      Optional[int]						=   32
       UpperCAmelCase_							:      Tuple						=   2
       UpperCAmelCase_							:      List[str]						=   4
       UpperCAmelCase_							:      List[Any]						=   0.1
       UpperCAmelCase_							:      Union[str, Any]						=   0.1
       UpperCAmelCase_							:      Union[str, Any]						=   512
       UpperCAmelCase_							:      Any						=   16
       UpperCAmelCase_							:      Dict						=   2
       UpperCAmelCase_							:      Union[str, Any]						=   0.02
       UpperCAmelCase_							:      Any						=   3
       UpperCAmelCase_							:      str						=   4
       UpperCAmelCase_							:      Any						=   '''last'''
       UpperCAmelCase_							:      List[str]						=   True
       UpperCAmelCase_							:      int						=   None
       UpperCAmelCase_							:      Optional[Any]						=   0





    def 					_lowerCamelCase (	self				:   List[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      str						=   ids_tensor([self.batch_size, self.seq_length]       ,   self.vocab_size	)
       UpperCAmelCase_							:      Dict						=   random_attention_mask([self.batch_size, self.seq_length]       ,   dtype=tf.floataa	)

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

       UpperCAmelCase_							:      Optional[int]						=   None
       if self.use_token_type_ids:
          UpperCAmelCase_							:      Dict						=   ids_tensor([self.batch_size, self.seq_length]       ,   self.n_langs	)

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

       UpperCAmelCase_							:      Union[str, Any]						=   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 					_lowerCamelCase (	self				:   List[Any]       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   List[Any]       ,   __snake_case				:   Tuple       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   int       ,   __snake_case				:   List[Any]       ,   __snake_case				:   str       ,   __snake_case				:   List[Any]       ,   __snake_case				:   Tuple       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      Any						=   TFFlaubertModel(config=__snake_case	)
       UpperCAmelCase_							:      Any						=   {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
       UpperCAmelCase_							:      Union[str, Any]						=   model(__snake_case	)

       UpperCAmelCase_							:      str						=   [input_ids, input_mask]
       UpperCAmelCase_							:      List[str]						=   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				:   Optional[int]       ,   __snake_case				:   int       ,   __snake_case				:   Any       ,   __snake_case				:   Dict       ,   __snake_case				:   List[str]       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   int       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Optional[int]       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      int						=   TFFlaubertWithLMHeadModel(__snake_case	)

       UpperCAmelCase_							:      Optional[int]						=   {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
       UpperCAmelCase_							:      int						=   model(__snake_case	)

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





    def 					_lowerCamelCase (	self				:   Optional[Any]       ,   __snake_case				:   Tuple       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   List[str]       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Dict       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      str						=   TFFlaubertForQuestionAnsweringSimple(__snake_case	)

       UpperCAmelCase_							:      List[str]						=   {'''input_ids''': input_ids, '''lengths''': input_lengths}

       UpperCAmelCase_							:      int						=   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				:   str       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   int       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Union[str, Any]       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   Dict       ,   __snake_case				:   Union[str, Any]       ,   __snake_case				:   int       ,   __snake_case				:   Any       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      List[Any]						=   TFFlaubertForSequenceClassification(__snake_case	)

       UpperCAmelCase_							:      Tuple						=   {'''input_ids''': input_ids, '''lengths''': input_lengths}

       UpperCAmelCase_							:      Tuple						=   model(__snake_case	)

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





    def 					_lowerCamelCase (	self				:   Tuple       ,   __snake_case				:   Dict       ,   __snake_case				:   str       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Tuple       ,   __snake_case				:   Any       ,   __snake_case				:   List[str]       ,   __snake_case				:   List[str]       ,   __snake_case				:   Dict       ,   __snake_case				:   List[Any]       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      int						=   self.num_labels
       UpperCAmelCase_							:      Tuple						=   TFFlaubertForTokenClassification(config=__snake_case	)
       UpperCAmelCase_							:      List[str]						=   {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
       UpperCAmelCase_							:      List[str]						=   model(__snake_case	)
       self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.seq_length, self.num_labels)	)





    def 					_lowerCamelCase (	self				:   Optional[Any]       ,   __snake_case				:   List[str]       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   List[Any]       ,   __snake_case				:   Any       ,   __snake_case				:   Tuple       ,   __snake_case				:   Optional[Any]       ,   __snake_case				:   int       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Any       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   self.num_choices
       UpperCAmelCase_							:      List[str]						=   TFFlaubertForMultipleChoice(config=__snake_case	)
       UpperCAmelCase_							:      List[str]						=   tf.tile(tf.expand_dims(__snake_case       ,   1	)       ,   (1, self.num_choices, 1)	)
       UpperCAmelCase_							:      Optional[int]						=   tf.tile(tf.expand_dims(__snake_case       ,   1	)       ,   (1, self.num_choices, 1)	)
       UpperCAmelCase_							:      List[Any]						=   tf.tile(tf.expand_dims(__snake_case       ,   1	)       ,   (1, self.num_choices, 1)	)
       UpperCAmelCase_							:      str						=   {
           '''input_ids''': multiple_choice_inputs_ids,
           '''attention_mask''': multiple_choice_input_mask,
           '''token_type_ids''': multiple_choice_token_type_ids,
       }
       UpperCAmelCase_							:      Dict						=   model(__snake_case	)
       self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_choices)	)





    def 					_lowerCamelCase (	self				:   List[str]	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[Any]						=   self.prepare_config_and_inputs()
       (
           UpperCAmelCase_      
       )							:      Optional[int]						=   config_and_inputs
       UpperCAmelCase_							:      Optional[int]						=   {
           '''input_ids''': input_ids,
           '''token_type_ids''': token_type_ids,
           '''langs''': token_type_ids,
           '''lengths''': input_lengths,
       }
       return config, inputs_dict





@require_tf
class  lowerCAmelCase__(    snake_case__    ,    snake_case__    ,    unittest.TestCase						):






    '''simple docstring'''





    A_  :     Dict			= (
        (
            TFFlaubertModel,
            TFFlaubertWithLMHeadModel,
            TFFlaubertForSequenceClassification,
            TFFlaubertForQuestionAnsweringSimple,
            TFFlaubertForTokenClassification,
            TFFlaubertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    A_  :     List[Any]			= (
        (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Check other models whether language generation is also applicable
    A_  :     str			= (
        {
            'feature-extraction': TFFlaubertModel,
            'fill-mask': TFFlaubertWithLMHeadModel,
            'question-answering': TFFlaubertForQuestionAnsweringSimple,
            'text-classification': TFFlaubertForSequenceClassification,
            'token-classification': TFFlaubertForTokenClassification,
            'zero-shot': TFFlaubertForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    A_  :     Any			= False
    A_  :     Any			= False





    def 					_lowerCamelCase (	self				:   Tuple       ,   __snake_case				:   Tuple       ,   __snake_case				:   Any       ,   __snake_case				:   str       ,   __snake_case				:   int       ,   __snake_case				:   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 					_lowerCamelCase (	self				:   List[str]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[Any]						=   TFFlaubertModelTester(self	)
       UpperCAmelCase_							:      Union[str, Any]						=   ConfigTester(self       ,   config_class=__snake_case       ,   emb_dim=37	)





    def 					_lowerCamelCase (	self				:   List[str]	):





       '''simple docstring'''
       self.config_tester.run_common_tests()





    def 					_lowerCamelCase (	self				:   Any	):





       '''simple docstring'''
       UpperCAmelCase_							:      str						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_model(*__snake_case	)





    def 					_lowerCamelCase (	self				:   Optional[int]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_lm_head(*__snake_case	)





    def 					_lowerCamelCase (	self				:   Optional[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_qa(*__snake_case	)





    def 					_lowerCamelCase (	self				:   Any	):





       '''simple docstring'''
       UpperCAmelCase_							:      str						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_sequence_classif(*__snake_case	)





    def 					_lowerCamelCase (	self				:   Dict	):





       '''simple docstring'''
       UpperCAmelCase_							:      int						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_token_classification(*__snake_case	)





    def 					_lowerCamelCase (	self				:   Union[str, Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_multiple_choice(*__snake_case	)





    @slow
    def 					_lowerCamelCase (	self				:   int	):





       '''simple docstring'''
       for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          UpperCAmelCase_							:      Dict						=   TFFlaubertModel.from_pretrained(__snake_case	)
          self.assertIsNotNone(__snake_case	)





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






    '''simple docstring'''





    @slow
    def 					_lowerCamelCase (	self				:   Dict	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[Any]						=   TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased'''	)

       UpperCAmelCase_							:      int						=   tf.convert_to_tensor(
           [[0, 158, 735, 2_592, 1_424, 6_727, 82, 1]]       ,   dtype=tf.intaa       ,   )  # "J'aime flaubert !"

       UpperCAmelCase_							:      Any						=   model(__snake_case	)[0]
       UpperCAmelCase_							:      Dict						=   tf.TensorShape((1, 8, 512)	)
       self.assertEqual(output.shape       ,   __snake_case	)
       # compare the actual values for a slice.
       UpperCAmelCase_							:      List[str]						=   tf.convert_to_tensor(
           [
               [
                   [-1.8_768_773, -1.566_555, 0.27_072_418],
                   [-1.6_920_038, -0.5_873_505, 1.9_329_599],
                   [-2.9_563_985, -1.6_993_835, 1.7_972_052],
               ]
           ]       ,   dtype=tf.floataa       ,   )

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




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__UpperCamelCase				:  List[Any]      					=							{
    'configuration_vivit': ['VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VivitConfig'],
}
try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __UpperCamelCase				:  Optional[Any]      					=							['VivitImageProcessor']


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __UpperCamelCase				:  List[Any]      					=							[
           'VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'VivitModel',
           'VivitPreTrainedModel',
           'VivitForVideoClassification',
       ]


if TYPE_CHECKING:
       from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .image_processing_vivit import VivitImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_vivit import (
                  VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  VivitForVideoClassification,
                  VivitModel,
                  VivitPreTrainedModel,
              )


else:
       import sys

       __UpperCamelCase				:  str      					=							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)