






"""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  :      Dict     ,		__snake_case  :      Dict     ,		)			->							Tuple:
											__magic_name__:	List[str]							=       parent
											__magic_name__:	Union[str, Any]							=       1_3
											__magic_name__:	Tuple							=       7
											__magic_name__:	Optional[int]							=       True
											__magic_name__:	List[str]							=       True
											__magic_name__:	Optional[Any]							=       True
											__magic_name__:	Dict							=       True
											__magic_name__:	List[Any]							=       True
											__magic_name__:	Any							=       False
											__magic_name__:	Optional[int]							=       False
											__magic_name__:	Any							=       False
											__magic_name__:	str							=       2
											__magic_name__:	Tuple							=       9_9
											__magic_name__:	Union[str, Any]							=       0
											__magic_name__:	Any							=       3_2
											__magic_name__:	Optional[int]							=       2
											__magic_name__:	Dict							=       4
											__magic_name__:	str							=       0.1
											__magic_name__:	List[str]							=       0.1
											__magic_name__:	Tuple							=       5_1_2
											__magic_name__:	List[str]							=       1_6
											__magic_name__:	Optional[int]							=       2
											__magic_name__:	int							=       0.02
											__magic_name__:	Any							=       3
											__magic_name__:	str							=       4
											__magic_name__:	Any							=       """last"""
											__magic_name__:	str							=       True
											__magic_name__:	Any							=       None
											__magic_name__:	Optional[Any]							=       0

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Optional[int]:
											__magic_name__:	Optional[int]							=       ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size					)
											__magic_name__:	Dict							=       random_attention_mask([self.batch_size, self.seq_length]     ,		dtype=tf.floataa					)

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

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

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

											__magic_name__:	str							=       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[str]     ,		__snake_case  :      Any     ,		__snake_case  :      Tuple     ,		__snake_case  :      Dict     ,		__snake_case  :      Tuple     ,		__snake_case  :      Any     ,		__snake_case  :      Union[str, Any]     ,		__snake_case  :      Dict     ,		__snake_case  :      Union[str, Any]     ,		__snake_case  :      int     ,		)			->							Dict:
											__magic_name__:	Union[str, Any]							=       TFFlaubertModel(config=__snake_case					)
											__magic_name__:	List[str]							=       {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
											__magic_name__:	List[str]							=       model(__snake_case					)

											__magic_name__:	str							=       [input_ids, input_mask]
											__magic_name__:	Dict							=       model(__snake_case					)
											self.parent.assertEqual(result.last_hidden_state.shape     ,		(self.batch_size, self.seq_length, self.hidden_size)					)

					def   lowerCamelCase__   (			self  :      List[Any]     ,		__snake_case  :      List[str]     ,		__snake_case  :      List[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      Optional[int]     ,		__snake_case  :      int     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      int     ,		__snake_case  :      Any     ,		__snake_case  :      Tuple     ,		)			->							Any:
											__magic_name__:	Optional[Any]							=       TFFlaubertWithLMHeadModel(__snake_case					)

											__magic_name__:	Tuple							=       {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
											__magic_name__:	Optional[Any]							=       model(__snake_case					)

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

					def   lowerCamelCase__   (			self  :      Optional[int]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      List[Any]     ,		__snake_case  :      Optional[int]     ,		__snake_case  :      Dict     ,		__snake_case  :      Any     ,		__snake_case  :      Tuple     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Union[str, Any]     ,		__snake_case  :      Tuple     ,		)			->							Union[str, Any]:
											__magic_name__:	str							=       TFFlaubertForQuestionAnsweringSimple(__snake_case					)

											__magic_name__:	int							=       {"""input_ids""": input_ids, """lengths""": input_lengths}

											__magic_name__:	Union[str, Any]							=       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  :      Any     ,		__snake_case  :      Dict     ,		__snake_case  :      int     ,		__snake_case  :      int     ,		__snake_case  :      List[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      Union[str, Any]     ,		__snake_case  :      List[Any]     ,		__snake_case  :      str     ,		__snake_case  :      Any     ,		)			->							List[Any]:
											__magic_name__:	str							=       TFFlaubertForSequenceClassification(__snake_case					)

											__magic_name__:	Dict							=       {"""input_ids""": input_ids, """lengths""": input_lengths}

											__magic_name__:	Any							=       model(__snake_case					)

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

					def   lowerCamelCase__   (			self  :      Any     ,		__snake_case  :      Any     ,		__snake_case  :      List[str]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Optional[int]     ,		__snake_case  :      List[str]     ,		__snake_case  :      List[str]     ,		__snake_case  :      List[str]     ,		__snake_case  :      int     ,		__snake_case  :      List[str]     ,		)			->							Optional[int]:
											__magic_name__:	str							=       self.num_labels
											__magic_name__:	List[Any]							=       TFFlaubertForTokenClassification(config=__snake_case					)
											__magic_name__:	List[str]							=       {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
											__magic_name__:	Optional[Any]							=       model(__snake_case					)
											self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.seq_length, self.num_labels)					)

					def   lowerCamelCase__   (			self  :      Tuple     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Dict     ,		__snake_case  :      Tuple     ,		__snake_case  :      Optional[int]     ,		__snake_case  :      Union[str, Any]     ,		__snake_case  :      List[Any]     ,		__snake_case  :      Union[str, Any]     ,		__snake_case  :      int     ,		)			->							Optional[Any]:
											__magic_name__:	Optional[int]							=       self.num_choices
											__magic_name__:	List[str]							=       TFFlaubertForMultipleChoice(config=__snake_case					)
											__magic_name__:	List[Any]							=       tf.tile(tf.expand_dims(__snake_case     ,		1					)     ,		(1, self.num_choices, 1)					)
											__magic_name__:	Optional[int]							=       tf.tile(tf.expand_dims(__snake_case     ,		1					)     ,		(1, self.num_choices, 1)					)
											__magic_name__:	Tuple							=       tf.tile(tf.expand_dims(__snake_case     ,		1					)     ,		(1, self.num_choices, 1)					)
											__magic_name__:	Any							=       {
											    """input_ids""": multiple_choice_inputs_ids,
											    """attention_mask""": multiple_choice_input_mask,
											    """token_type_ids""": multiple_choice_token_type_ids,
											}
											__magic_name__:	str							=       model(__snake_case					)
											self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_choices)					)






					def   lowerCamelCase__   (			self  :      Dict					)			->							List[str]:
											__magic_name__:	str							=       self.prepare_config_and_inputs()
											(
											    (
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			
											):	Optional[Any]							=       config_and_inputs
											__magic_name__:	Tuple							=       {
											    """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		(   SCREAMING_SNAKE_CASE_     ,SCREAMING_SNAKE_CASE_     ,unittest.TestCase			):
					UpperCAmelCase__								=				(
					    (
					        TFFlaubertModel,
					        TFFlaubertWithLMHeadModel,
					        TFFlaubertForSequenceClassification,
					        TFFlaubertForQuestionAnsweringSimple,
					        TFFlaubertForTokenClassification,
					        TFFlaubertForMultipleChoice,
					    )
					    if is_tf_available()
					    else ()
					)
					UpperCAmelCase__								=				(
					    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
					)  # TODO (PVP): Check other models whether language generation is also applicable
					UpperCAmelCase__								=				(
					    {
					        "feature-extraction": TFFlaubertModel,
					        "fill-mask": TFFlaubertWithLMHeadModel,
					        "question-answering": TFFlaubertForQuestionAnsweringSimple,
					        "text-classification": TFFlaubertForSequenceClassification,
					        "token-classification": TFFlaubertForTokenClassification,
					        "zero-shot": TFFlaubertForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)
					UpperCAmelCase__								=				False
					UpperCAmelCase__								=				False

					def   lowerCamelCase__   (			self  :      Optional[Any]     ,		__snake_case  :      Dict     ,		__snake_case  :      Any     ,		__snake_case  :      Optional[int]     ,		__snake_case  :      Tuple     ,		__snake_case  :      Dict					)			->							str:
											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  :      str					)			->							Optional[Any]:
											__magic_name__:	List[Any]							=       TFFlaubertModelTester(self					)
											__magic_name__:	Any							=       ConfigTester(self     ,		config_class=__snake_case     ,		emb_dim=3_7					)

					def   lowerCamelCase__   (			self  :      Any					)			->							List[str]:
											self.config_tester.run_common_tests()

					def   lowerCamelCase__   (			self  :      str					)			->							Any:
											__magic_name__:	Tuple							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_flaubert_model(*__snake_case					)

					def   lowerCamelCase__   (			self  :      List[str]					)			->							int:
											__magic_name__:	Tuple							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_flaubert_lm_head(*__snake_case					)

					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							Dict:
											__magic_name__:	Dict							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_flaubert_qa(*__snake_case					)

					def   lowerCamelCase__   (			self  :      str					)			->							Dict:
											__magic_name__:	List[str]							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_flaubert_sequence_classif(*__snake_case					)

					def   lowerCamelCase__   (			self  :      List[str]					)			->							Tuple:
											__magic_name__:	Any							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_flaubert_for_token_classification(*__snake_case					)

					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Optional[int]:
											__magic_name__:	str							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_flaubert_for_multiple_choice(*__snake_case					)






					@slow
					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							Optional[int]:
											for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	__magic_name__:	List[Any]							=       TFFlaubertModel.from_pretrained(__snake_case					)
																	self.assertIsNotNone(__snake_case					)



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

					@slow
					def   lowerCamelCase__   (			self  :      int					)			->							Tuple:
											__magic_name__:	Optional[int]							=       TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased"""					)

											__magic_name__:	Tuple							=       tf.convert_to_tensor(
											    [[0, 1_5_8, 7_3_5, 2_5_9_2, 1_4_2_4, 6_7_2_7, 8_2, 1]]     ,		dtype=tf.intaa     ,		)  # "J'aime flaubert !"

											__magic_name__:	int							=       model(__snake_case					)[0]
											__magic_name__:	List[str]							=       tf.TensorShape((1, 8, 5_1_2)					)
											self.assertEqual(output.shape     ,		__snake_case					)
											# compare the actual values for a slice.
											__magic_name__:	Any							=       tf.convert_to_tensor(
											    [
											        [
											            [-1.8768773, -1.566555, 0.27072418],
											            [-1.6920038, -0.5873505, 1.9329599],
											            [-2.9563985, -1.6993835, 1.7972052],
											        ]
											    ]     ,		dtype=tf.floataa     ,		)

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











"""simple docstring"""





def   a    (     __UpperCAmelCase      :    list[int]  )    ->							float:
						if not nums:  # Makes sure that the list is not empty
												raise ValueError("""List is empty"""  )

						__magic_name__:	Dict							=       sum(__UpperCAmelCase  ) / len(__UpperCAmelCase  )  # Calculate the average
						return sum(abs(x - average  ) for x in nums  ) / len(__UpperCAmelCase  )


if __name__ == "__main__":
							import doctest

							doctest.testmod()



