import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


__lowercase										= logging.get_logger(__name__)


class      lowerCamelCase_					(       UpperCAmelCase_			):






    '''simple docstring'''






    a__     :						str      =				["""input_values""", """attention_mask"""]







    def __init__(     self			,			__lowercase = 1			,			__lowercase = 16_000			,			__lowercase = 0.0			,			__lowercase = False			,			__lowercase = 80			,			__lowercase = 16			,			__lowercase = 64			,			__lowercase = "hann_window"			,			__lowercase = 1.0			,			__lowercase = 80			,			__lowercase = 7_600			,			__lowercase = 1E-1_0			,			__lowercase = 2			,			__lowercase = True			,			**__lowercase			,			)	->     int:
        super().__init__(feature_size=__lowercase			,			sampling_rate=__lowercase			,			padding_value=__lowercase			,			**__lowercase)
        __UpperCamelCase					:Optional[int]        =		do_normalize
        __UpperCamelCase					:Tuple        =		return_attention_mask

        __UpperCamelCase					:Optional[int]        =		num_mel_bins
        __UpperCamelCase					:Optional[Any]        =		hop_length
        __UpperCamelCase					:List[str]        =		win_length
        __UpperCamelCase					:str        =		win_function
        __UpperCamelCase					:List[Any]        =		frame_signal_scale
        __UpperCamelCase					:Optional[Any]        =		fmin
        __UpperCamelCase					:int        =		fmax
        __UpperCamelCase					:str        =		mel_floor
        __UpperCamelCase					:str        =		reduction_factor

        __UpperCamelCase					:int        =		win_length * sampling_rate // 1_000
        __UpperCamelCase					:Optional[Any]        =		hop_length * sampling_rate // 1_000
        __UpperCamelCase					:Union[str, Any]        =		optimal_fft_length(self.sample_size)
        __UpperCamelCase					:str        =		(self.n_fft // 2) + 1

        __UpperCamelCase					:str        =		window_function(window_length=self.sample_size			,			name=self.win_function			,			periodic=__lowercase)

        __UpperCamelCase					:Optional[Any]        =		mel_filter_bank(
            num_frequency_bins=self.n_freqs			,			num_mel_filters=self.num_mel_bins			,			min_frequency=self.fmin			,			max_frequency=self.fmax			,			sampling_rate=self.sampling_rate			,			norm='''slaney'''			,			mel_scale='''slaney'''			,			)

        if frame_signal_scale != 1.0:
            warnings.warn(
                '''The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'''			,			__lowercase			,			)
        if reduction_factor != 2.0:
            warnings.warn(
                '''The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'''			,			__lowercase			,			)







    @staticmethod
    # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
    def       UpperCamelCase__       (     __lowercase			,			__lowercase			,			__lowercase = 0.0)	->     List[np.ndarray]:
        if attention_mask is not None:
            __UpperCamelCase					:Union[str, Any]        =		np.array(__lowercase			,			np.intaa)
            __UpperCamelCase					:Any        =		[]

            for vector, length in zip(__lowercase			,			attention_mask.sum(-1)):
                __UpperCamelCase					:Dict        =		(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7)
                if length < normed_slice.shape[0]:
                    __UpperCamelCase					:Tuple        =		padding_value

                normed_input_values.append(__lowercase)
        else:
            __UpperCamelCase					:Dict        =		[(x - x.mean()) / np.sqrt(x.var() + 1E-7) for x in input_values]

        return normed_input_values







    def       UpperCamelCase__       (     self			,			__lowercase			,			)	->     np.ndarray:
        __UpperCamelCase					:Optional[Any]        =		spectrogram(
            __lowercase			,			window=self.window			,			frame_length=self.sample_size			,			hop_length=self.sample_stride			,			fft_length=self.n_fft			,			mel_filters=self.mel_filters			,			mel_floor=self.mel_floor			,			log_mel='''log10'''			,			)
        return log_mel_spec.T







    def __call__(     self			,			__lowercase = None			,			__lowercase = None			,			__lowercase = False			,			__lowercase = None			,			__lowercase = False			,			__lowercase = None			,			__lowercase = None			,			__lowercase = None			,			__lowercase = None			,			**__lowercase			,			)	->     BatchFeature:
        if audio is None and audio_target is None:
            raise ValueError('''You must provide either `audio` or `audio_target` values.''')

        if sampling_rate is not None:
            if sampling_rate != self.sampling_rate:
                raise ValueError(
                    f"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
                    f""" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"""
                    f""" {self.sampling_rate} and not {sampling_rate}.""")
        else:
            logger.warning(
                '''It is strongly recommended to pass the ``sampling_rate`` argument to this function. '''
                '''Failing to do so can result in silent errors that might be hard to debug.''')

        if audio is not None:
            __UpperCamelCase					:Union[str, Any]        =		self._process_audio(
                __lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			**__lowercase			,			)
        else:
            __UpperCamelCase					:Tuple        =		None

        if audio_target is not None:
            __UpperCamelCase					:Optional[Any]        =		self._process_audio(
                __lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			**__lowercase			,			)

            if inputs is None:
                return inputs_target
            else:
                __UpperCamelCase					:Union[str, Any]        =		inputs_target['''input_values''']
                __UpperCamelCase					:str        =		inputs_target.get('''attention_mask''')
                if decoder_attention_mask is not None:
                    __UpperCamelCase					:Union[str, Any]        =		decoder_attention_mask

        return inputs







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase = False			,			__lowercase = False			,			__lowercase = None			,			__lowercase = False			,			__lowercase = None			,			__lowercase = None			,			__lowercase = None			,			**__lowercase			,			)	->     BatchFeature:
        __UpperCamelCase					:Union[str, Any]        =		isinstance(__lowercase			,			np.ndarray) and len(speech.shape) > 1
        if is_batched_numpy and len(speech.shape) > 2:
            raise ValueError(f"""Only mono-channel audio is supported for input to {self}""")
        __UpperCamelCase					:Dict        =		is_batched_numpy or (
            isinstance(__lowercase			,			(list, tuple)) and (isinstance(speech[0]			,			(np.ndarray, tuple, list)))
        )

        if is_batched:
            __UpperCamelCase					:Dict        =		[np.asarray(__lowercase			,			dtype=np.floataa) for speech in speech]
        elif not is_batched and not isinstance(__lowercase			,			np.ndarray):
            __UpperCamelCase					:Union[str, Any]        =		np.asarray(__lowercase			,			dtype=np.floataa)
        elif isinstance(__lowercase			,			np.ndarray) and speech.dtype is np.dtype(np.floataa):
            __UpperCamelCase					:List[str]        =		speech.astype(np.floataa)

        # always return batch
        if not is_batched:
            __UpperCamelCase					:Union[str, Any]        =		[speech]

        # needed to make pad() work on spectrogram inputs
        __UpperCamelCase					:List[Any]        =		self.feature_size

        # convert into correct format for padding
        if is_target:
            __UpperCamelCase					:int        =		[self._extract_mel_features(__lowercase) for waveform in speech]
            __UpperCamelCase					:Optional[int]        =		BatchFeature({'''input_values''': features})
            __UpperCamelCase					:str        =		self.num_mel_bins
        else:
            __UpperCamelCase					:List[str]        =		BatchFeature({'''input_values''': speech})

        __UpperCamelCase					:Tuple        =		self.pad(
            __lowercase			,			padding=__lowercase			,			max_length=__lowercase			,			truncation=__lowercase			,			pad_to_multiple_of=__lowercase			,			return_attention_mask=__lowercase			,			**__lowercase			,			)

        __UpperCamelCase					:Optional[Any]        =		feature_size_hack

        # convert input values to correct format
        __UpperCamelCase					:Any        =		padded_inputs['''input_values''']
        if not isinstance(input_values[0]			,			np.ndarray):
            __UpperCamelCase					:Tuple        =		[np.asarray(__lowercase			,			dtype=np.floataa) for array in input_values]
        elif (
            not isinstance(__lowercase			,			np.ndarray)
            and isinstance(input_values[0]			,			np.ndarray)
            and input_values[0].dtype is np.dtype(np.floataa)
        ):
            __UpperCamelCase					:Tuple        =		[array.astype(np.floataa) for array in input_values]
        elif isinstance(__lowercase			,			np.ndarray) and input_values.dtype is np.dtype(np.floataa):
            __UpperCamelCase					:Tuple        =		input_values.astype(np.floataa)

        # convert attention_mask to correct format
        __UpperCamelCase					:List[Any]        =		padded_inputs.get('''attention_mask''')
        if attention_mask is not None:
            __UpperCamelCase					:Tuple        =		[np.asarray(__lowercase			,			dtype=np.intaa) for array in attention_mask]

        # zero-mean and unit-variance normalization
        if not is_target and self.do_normalize:
            __UpperCamelCase					:Optional[Any]        =		(
                attention_mask
                if self._get_padding_strategies(__lowercase			,			max_length=__lowercase) is not PaddingStrategy.DO_NOT_PAD
                else None
            )
            __UpperCamelCase					:Union[str, Any]        =		self.zero_mean_unit_var_norm(
                padded_inputs['''input_values''']			,			attention_mask=__lowercase			,			padding_value=self.padding_value)

        if return_tensors is not None:
            __UpperCamelCase					:Optional[Any]        =		padded_inputs.convert_to_tensors(__lowercase)

        return padded_inputs







    def       UpperCamelCase__       (     self)	->     Dict[str, Any]:
        __UpperCamelCase					:Any        =		super().to_dict()

        # Don't serialize these as they are derived from the other properties.
        __UpperCamelCase					:Union[str, Any]        =		['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs''']
        for name in names:
            if name in output:
                del output[name]

        return output






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			,			__lowercase			,			)	->     Optional[Any]:
        __UpperCamelCase					:Optional[int]        =		parent
        __UpperCamelCase					:Optional[int]        =		13
        __UpperCamelCase					:Dict        =		7
        __UpperCamelCase					:Optional[int]        =		True
        __UpperCamelCase					:List[str]        =		True
        __UpperCamelCase					:List[Any]        =		True
        __UpperCamelCase					:Union[str, Any]        =		True
        __UpperCamelCase					:Any        =		True
        __UpperCamelCase					:Optional[int]        =		False
        __UpperCamelCase					:Any        =		False
        __UpperCamelCase					:str        =		False
        __UpperCamelCase					:Optional[Any]        =		2
        __UpperCamelCase					:Optional[int]        =		99
        __UpperCamelCase					:Any        =		0
        __UpperCamelCase					:List[Any]        =		32
        __UpperCamelCase					:int        =		2
        __UpperCamelCase					:Optional[Any]        =		4
        __UpperCamelCase					:Dict        =		0.1
        __UpperCamelCase					:Optional[Any]        =		0.1
        __UpperCamelCase					:str        =		512
        __UpperCamelCase					:Any        =		16
        __UpperCamelCase					:str        =		2
        __UpperCamelCase					:Dict        =		0.02
        __UpperCamelCase					:List[Any]        =		3
        __UpperCamelCase					:Optional[int]        =		4
        __UpperCamelCase					:Tuple        =		'''last'''
        __UpperCamelCase					:Any        =		True
        __UpperCamelCase					:Union[str, Any]        =		None
        __UpperCamelCase					:Tuple        =		0







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:List[str]        =		ids_tensor([self.batch_size, self.seq_length]			,			self.vocab_size)
        __UpperCamelCase					:Any        =		random_attention_mask([self.batch_size, self.seq_length]			,			dtype=tf.floataa)

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

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

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

        __UpperCamelCase					:Optional[int]        =		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       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Optional[Any]:
        __UpperCamelCase					:str        =		TFFlaubertModel(config=__lowercase)
        __UpperCamelCase					:List[str]        =		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
        __UpperCamelCase					:Optional[int]        =		model(__lowercase)

        __UpperCamelCase					:Optional[int]        =		[input_ids, input_mask]
        __UpperCamelCase					:Union[str, Any]        =		model(__lowercase)
        self.parent.assertEqual(result.last_hidden_state.shape			,			(self.batch_size, self.seq_length, self.hidden_size))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     int:
        __UpperCamelCase					:str        =		TFFlaubertWithLMHeadModel(__lowercase)

        __UpperCamelCase					:List[str]        =		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
        __UpperCamelCase					:Optional[int]        =		model(__lowercase)

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







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Any:
        __UpperCamelCase					:Any        =		TFFlaubertForQuestionAnsweringSimple(__lowercase)

        __UpperCamelCase					:str        =		{'''input_ids''': input_ids, '''lengths''': input_lengths}

        __UpperCamelCase					:int        =		model(__lowercase)

        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       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Any:
        __UpperCamelCase					:int        =		TFFlaubertForSequenceClassification(__lowercase)

        __UpperCamelCase					:List[Any]        =		{'''input_ids''': input_ids, '''lengths''': input_lengths}

        __UpperCamelCase					:Any        =		model(__lowercase)

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







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Tuple:
        __UpperCamelCase					:Optional[int]        =		self.num_labels
        __UpperCamelCase					:int        =		TFFlaubertForTokenClassification(config=__lowercase)
        __UpperCamelCase					:Union[str, Any]        =		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
        __UpperCamelCase					:Optional[Any]        =		model(__lowercase)
        self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.seq_length, self.num_labels))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     List[Any]:
        __UpperCamelCase					:Any        =		self.num_choices
        __UpperCamelCase					:Any        =		TFFlaubertForMultipleChoice(config=__lowercase)
        __UpperCamelCase					:List[str]        =		tf.tile(tf.expand_dims(__lowercase			,			1)			,			(1, self.num_choices, 1))
        __UpperCamelCase					:Optional[Any]        =		tf.tile(tf.expand_dims(__lowercase			,			1)			,			(1, self.num_choices, 1))
        __UpperCamelCase					:Tuple        =		tf.tile(tf.expand_dims(__lowercase			,			1)			,			(1, self.num_choices, 1))
        __UpperCamelCase					:Any        =		{
            '''input_ids''': multiple_choice_inputs_ids,
            '''attention_mask''': multiple_choice_input_mask,
            '''token_type_ids''': multiple_choice_token_type_ids,
        }
        __UpperCamelCase					:List[Any]        =		model(__lowercase)
        self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.num_choices))







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:Optional[int]        =		self.prepare_config_and_inputs()
        (
            (
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	
        )					:Any        =		config_and_inputs
        __UpperCamelCase					: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_					(       UpperCAmelCase_						,     UpperCAmelCase_						,     unittest.TestCase			):






    '''simple docstring'''






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







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase)	->     Any:
        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       UpperCamelCase__       (     self)	->     Union[str, Any]:
        __UpperCamelCase					:int        =		TFFlaubertModelTester(self)
        __UpperCamelCase					:Dict        =		ConfigTester(self			,			config_class=__lowercase			,			emb_dim=37)







    def       UpperCamelCase__       (     self)	->     str:
        self.config_tester.run_common_tests()







    def       UpperCamelCase__       (     self)	->     Any:
        __UpperCamelCase					:int        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_model(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        __UpperCamelCase					:Optional[int]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_lm_head(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:Optional[Any]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_qa(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Tuple:
        __UpperCamelCase					:Optional[Any]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_sequence_classif(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:Dict        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_for_token_classification(*__lowercase)







    def       UpperCamelCase__       (     self)	->     str:
        __UpperCamelCase					:Union[str, Any]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_for_multiple_choice(*__lowercase)







    @slow
    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCamelCase					:Any        =		TFFlaubertModel.from_pretrained(__lowercase)
            self.assertIsNotNone(__lowercase)


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






    '''simple docstring'''






    @slow
    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:List[Any]        =		TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased''')

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

        __UpperCamelCase					:Union[str, Any]        =		model(__lowercase)[0]
        __UpperCamelCase					:str        =		tf.TensorShape((1, 8, 512))
        self.assertEqual(output.shape			,			__lowercase)
        # compare the actual values for a slice.
        __UpperCamelCase					:Optional[int]        =		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))





