




from __future__ import annotations

import unittest

from transformers import BlenderbotConfig, BlenderbotTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotForConditionalGeneration, TFBlenderbotModel







@require_tf
class 				lowerCAmelCase_       :
				__a     :       Optional[Any]						=     BlenderbotConfig
				__a     :       Any						=     {}
				__a     :       Union[str, Any]						=     "gelu"






				def __init__(			self      ,snake_case__      ,snake_case__=13      ,snake_case__=7      ,snake_case__=True      ,snake_case__=False      ,snake_case__=99      ,snake_case__=32      ,snake_case__=2      ,snake_case__=4      ,snake_case__=37      ,snake_case__=0.1      ,snake_case__=0.1      ,snake_case__=20      ,snake_case__=2      ,snake_case__=1      ,snake_case__=0      ,):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      parent
							SCREAMING_SNAKE_CASE_   : str					  =      batch_size
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      seq_length
							SCREAMING_SNAKE_CASE_   : int					  =      is_training
							SCREAMING_SNAKE_CASE_   : str					  =      use_labels
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      vocab_size
							SCREAMING_SNAKE_CASE_   : int					  =      hidden_size
							SCREAMING_SNAKE_CASE_   : int					  =      num_hidden_layers
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      num_attention_heads
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      intermediate_size

							SCREAMING_SNAKE_CASE_   : Tuple					  =      hidden_dropout_prob
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE_   : Tuple					  =      max_position_embeddings
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      eos_token_id
							SCREAMING_SNAKE_CASE_   : Dict					  =      pad_token_id
							SCREAMING_SNAKE_CASE_   : List[str]					  =      bos_token_id






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      ids_tensor([self.batch_size, self.seq_length - 1]      ,self.vocab_size )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size )      ,1 )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      tf.concat([input_ids, eos_tensor]      ,axis=1 )

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size )

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      self.config_cls(
							    vocab_size=self.vocab_size      ,d_model=self.hidden_size      ,encoder_layers=self.num_hidden_layers      ,decoder_layers=self.num_hidden_layers      ,encoder_attention_heads=self.num_attention_heads      ,decoder_attention_heads=self.num_attention_heads      ,encoder_ffn_dim=self.intermediate_size      ,decoder_ffn_dim=self.intermediate_size      ,dropout=self.hidden_dropout_prob      ,attention_dropout=self.attention_probs_dropout_prob      ,max_position_embeddings=self.max_position_embeddings      ,eos_token_ids=[2]      ,bos_token_id=self.bos_token_id      ,pad_token_id=self.pad_token_id      ,decoder_start_token_id=self.pad_token_id      ,**self.config_updates      ,)
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      prepare_blenderbot_inputs_dict(lowercase_      ,lowercase_      ,lowercase_ )
							return config, inputs_dict






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : str					  =      TFBlenderbotModel(config=lowercase_ ).get_decoder()
							SCREAMING_SNAKE_CASE_   : Any					  =      inputs_dict['input_ids']

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      input_ids[:1, :]
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      inputs_dict['attention_mask'][:1, :]
							SCREAMING_SNAKE_CASE_   : List[str]					  =      inputs_dict['head_mask']
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      1

							# first forward pass
							SCREAMING_SNAKE_CASE_   : int					  =      model(lowercase_      ,attention_mask=lowercase_      ,head_mask=lowercase_      ,use_cache=lowercase_ )

							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Tuple					  =      outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							SCREAMING_SNAKE_CASE_   : Tuple					  =      ids_tensor((self.batch_size, 3)      ,config.vocab_size )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      tf.cast(ids_tensor((self.batch_size, 3)      ,2 )      ,tf.inta )

							# append to next input_ids and
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tf.concat([input_ids, next_tokens]      ,axis=-1 )
							SCREAMING_SNAKE_CASE_   : int					  =      tf.concat([attention_mask, next_attn_mask]      ,axis=-1 )

							SCREAMING_SNAKE_CASE_   : Any					  =      model(lowercase_      ,attention_mask=lowercase_ )[0]
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      model(lowercase_      ,attention_mask=lowercase_      ,past_key_values=lowercase_ )[0]

							self.parent.assertEqual(next_tokens.shape[1]      ,output_from_past.shape[1] )

							# select random slice
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      int(ids_tensor((1,)      ,output_from_past.shape[-1] ) )
							SCREAMING_SNAKE_CASE_   : Any					  =      output_from_no_past[:, -3:, random_slice_idx]
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      output_from_past[:, :, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(lowercase_      ,lowercase_      ,rtol=1E-3 )





def        __UpperCAmelCase						(							lowerCamelCase_ :     Union[str, Any]  ,							lowerCamelCase_ :     Union[str, Any]  ,							lowerCamelCase_ :     List[Any]  ,							lowerCamelCase_ :     Optional[Any]=None  ,							lowerCamelCase_ :     Dict=None  ,							lowerCamelCase_ :     List[str]=None  ,							lowerCamelCase_ :     Union[str, Any]=None  ,							lowerCamelCase_ :     Dict=None  ,							)       ->  int:







			"""simple docstring"""





			if attention_mask is None:
						SCREAMING_SNAKE_CASE_   : int					  =      tf.cast(tf.math.not_equal(__UpperCAmelCase  ,							config.pad_token_id  )  ,							tf.inta  )
			if decoder_attention_mask is None:
						SCREAMING_SNAKE_CASE_   : str					  =      tf.concat(
						    [
						        tf.ones(decoder_input_ids[:, :1].shape  ,							dtype=tf.inta  ),
						        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]  ,							config.pad_token_id  )  ,							tf.inta  ),
						    ]  ,							axis=-1  ,							)
			if head_mask is None:
						SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tf.ones((config.encoder_layers, config.encoder_attention_heads)  )
			if decoder_head_mask is None:
						SCREAMING_SNAKE_CASE_   : str					  =      tf.ones((config.decoder_layers, config.decoder_attention_heads)  )
			if cross_attn_head_mask is None:
						SCREAMING_SNAKE_CASE_   : List[str]					  =      tf.ones((config.decoder_layers, config.decoder_attention_heads)  )
			return {
			    "input_ids": input_ids,
			    "decoder_input_ids": decoder_input_ids,
			    "attention_mask": attention_mask,
			    "decoder_attention_mask": decoder_attention_mask,
			    "head_mask": head_mask,
			    "decoder_head_mask": decoder_head_mask,
			    "cross_attn_head_mask": cross_attn_head_mask,
			}







@require_tf
class 				lowerCAmelCase_       (					_lowerCamelCase						,     _lowerCamelCase						,     unittest.TestCase							):
				__a     :       Optional[Any]						=     (TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
				__a     :       Dict						=     (TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
				__a     :       Optional[int]						=     (
				    {
				        "conversational": TFBlenderbotForConditionalGeneration,
				        "feature-extraction": TFBlenderbotModel,
				        "summarization": TFBlenderbotForConditionalGeneration,
				        "text2text-generation": TFBlenderbotForConditionalGeneration,
				        "translation": TFBlenderbotForConditionalGeneration,
				    }
				    if is_tf_available()
				    else {}
				)
				__a     :       Tuple						=     True
				__a     :       Tuple						=     False
				__a     :       Optional[int]						=     False






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      TFBlenderbotModelTester(self )
							SCREAMING_SNAKE_CASE_   : Dict					  =      ConfigTester(self      ,config_class=lowercase_ )






				def 		snake_case	(			self ):
							self.config_tester.run_common_tests()






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*lowercase_ )







@require_tokenizers
@require_tf
class 				lowerCAmelCase_       (					unittest.TestCase							):
				__a     :       List[Any]						=     ["My friends are cool but they eat too many carbs."]
				__a     :       Optional[int]						=     "facebook/blenderbot-400M-distill"






				@cached_property
				def 		snake_case	(			self ):
							return BlenderbotTokenizer.from_pretrained(self.model_name )






				@cached_property
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name )
							return model






				@slow
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : int					  =      self.tokenizer(self.src_text      ,return_tensors='tf' )
							SCREAMING_SNAKE_CASE_   : List[str]					  =      self.model.generate(
							    model_inputs.input_ids      ,)
							SCREAMING_SNAKE_CASE_   : int					  =      self.tokenizer.batch_decode(generated_ids.numpy()      ,skip_special_tokens=lowercase_ )[0]
							assert (
							    generated_words
							    == " That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?"
							)









'''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       :   Tuple			,							lowercase_       :   Any			,							):
									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_		     =							512
									snake_case_		     =							16
									snake_case_		     =							2
									snake_case_		     =							0.02
									snake_case_		     =							3
									snake_case_		     =							4
									snake_case_		     =							'''last'''
									snake_case_		     =							True
									snake_case_		     =							None
									snake_case_		     =							0


				def     A_					(						self       :   Union[str, Any]   ):
									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       :   List[Any]			,							lowercase_       :   Dict			,							lowercase_       :   Optional[int]			,							lowercase_       :   Any			,							lowercase_       :   List[Any]			,							lowercase_       :   Optional[int]			,							lowercase_       :   int			,							lowercase_       :   int			,							lowercase_       :   str			,							lowercase_       :   int			,							):
									snake_case_		     =							TFFlaubertModel(config=lowercase_   )
									snake_case_		     =							{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
									snake_case_		     =							model(lowercase_   )

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


				def     A_					(						self       :   List[str]			,							lowercase_       :   int			,							lowercase_       :   List[str]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   str			,							lowercase_       :   Tuple			,							lowercase_       :   Tuple			,							lowercase_       :   Any			,							lowercase_       :   Dict			,							lowercase_       :   List[Any]			,							):
									snake_case_		     =							TFFlaubertWithLMHeadModel(lowercase_   )

									snake_case_		     =							{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
									snake_case_		     =							model(lowercase_   )

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


				def     A_					(						self       :   str			,							lowercase_       :   Dict			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Dict			,							lowercase_       :   Any			,							lowercase_       :   str			,							lowercase_       :   List[str]			,							lowercase_       :   List[Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   str			,							):
									snake_case_		     =							TFFlaubertForQuestionAnsweringSimple(lowercase_   )

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

									snake_case_		     =							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     A_					(						self       :   Optional[Any]			,							lowercase_       :   Any			,							lowercase_       :   int			,							lowercase_       :   List[Any]			,							lowercase_       :   Any			,							lowercase_       :   Optional[Any]			,							lowercase_       :   str			,							lowercase_       :   int			,							lowercase_       :   int			,							lowercase_       :   Dict			,							):
									snake_case_		     =							TFFlaubertForSequenceClassification(lowercase_   )

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

									snake_case_		     =							model(lowercase_   )

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


				def     A_					(						self       :   List[Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Any			,							lowercase_       :   Any			,							lowercase_       :   List[Any]			,							lowercase_       :   List[Any]			,							lowercase_       :   Dict			,							lowercase_       :   int			,							lowercase_       :   Tuple			,							lowercase_       :   Union[str, Any]			,							):
									snake_case_		     =							self.num_labels
									snake_case_		     =							TFFlaubertForTokenClassification(config=lowercase_   )
									snake_case_		     =							{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.seq_length, self.num_labels)   )


				def     A_					(						self       :   Dict			,							lowercase_       :   Tuple			,							lowercase_       :   Optional[int]			,							lowercase_       :   Any			,							lowercase_       :   List[Any]			,							lowercase_       :   int			,							lowercase_       :   Tuple			,							lowercase_       :   List[str]			,							lowercase_       :   List[Any]			,							lowercase_       :   Any			,							):
									snake_case_		     =							self.num_choices
									snake_case_		     =							TFFlaubertForMultipleChoice(config=lowercase_   )
									snake_case_		     =							tf.tile(tf.expand_dims(lowercase_			,							1   )			,							(1, self.num_choices, 1)   )
									snake_case_		     =							tf.tile(tf.expand_dims(lowercase_			,							1   )			,							(1, self.num_choices, 1)   )
									snake_case_		     =							tf.tile(tf.expand_dims(lowercase_			,							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(lowercase_   )
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_choices)   )


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


				def     A_					(						self       :   str			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Optional[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     A_					(						self       :   int   ):
									snake_case_		     =							TFFlaubertModelTester(self   )
									snake_case_		     =							ConfigTester(self			,							config_class=lowercase_			,							emb_dim=37   )


				def     A_					(						self       :   List[str]   ):
									self.config_tester.run_common_tests()


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_model(*lowercase_   )


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_lm_head(*lowercase_   )


				def     A_					(						self       :   Tuple   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_qa(*lowercase_   )


				def     A_					(						self       :   Tuple   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_sequence_classif(*lowercase_   )


				def     A_					(						self       :   List[str]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_token_classification(*lowercase_   )


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_multiple_choice(*lowercase_   )


				@slow
				def     A_					(						self       :   Optional[int]   ):
									for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														snake_case_		     =							TFFlaubertModel.from_pretrained(lowercase_   )
														self.assertIsNotNone(lowercase_   )







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


				@slow
				def     A_					(						self       :   int   ):
									snake_case_		     =							TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased'''   )

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

									snake_case_		     =							model(lowercase_   )[0]
									snake_case_		     =							tf.TensorShape((1, 8, 512)   )
									self.assertEqual(output.shape			,							lowercase_   )
									# compare the actual values for a slice.
									snake_case_		     =							tf.convert_to_tensor(
									    [
									        [
									            [-1.876_8773, -1.56_6555, 0.2707_2418],
									            [-1.692_0038, -0.587_3505, 1.932_9599],
									            [-2.956_3985, -1.699_3835, 1.797_2052],
									        ]
									    ]			,							dtype=tf.floataa			,							)

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

