





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	:






			def __init__(self ,							__magic_name__ ,							)					->       str:


							'''simple docstring'''



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






			def       lowerCamelCase  (self   )					->       Union[str, Any]:


							'''simple docstring'''



							snake_case_						:   Dict           =  ids_tensor([self.batch_size, self.seq_length] ,							self.vocab_size   )
							snake_case_						:   Union[str, Any]           =  random_attention_mask([self.batch_size, self.seq_length] ,							dtype=tf.floataa   )

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

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

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

							snake_case_						:   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       lowerCamelCase  (self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							)					->       Optional[int]:


							'''simple docstring'''



							snake_case_						:   Any           =  TFFlaubertModel(config=__magic_name__   )
							snake_case_						:   List[Any]           =  {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
							snake_case_						:   Dict           =  model(__magic_name__   )

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






			def       lowerCamelCase  (self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							)					->       Dict:


							'''simple docstring'''



							snake_case_						:   Dict           =  TFFlaubertWithLMHeadModel(__magic_name__   )

							snake_case_						:   Optional[int]           =  {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
							snake_case_						:   Dict           =  model(__magic_name__   )

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






			def       lowerCamelCase  (self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							)					->       Union[str, Any]:


							'''simple docstring'''



							snake_case_						:   Tuple           =  TFFlaubertForQuestionAnsweringSimple(__magic_name__   )

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

							snake_case_						:   List[Any]           =  model(__magic_name__   )

							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 ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							)					->       Union[str, Any]:


							'''simple docstring'''



							snake_case_						:   Dict           =  TFFlaubertForSequenceClassification(__magic_name__   )

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

							snake_case_						:   Dict           =  model(__magic_name__   )

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






			def       lowerCamelCase  (self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							)					->       List[str]:


							'''simple docstring'''



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






			def       lowerCamelCase  (self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							)					->       int:


							'''simple docstring'''



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






			def       lowerCamelCase  (self   )					->       Dict:


							'''simple docstring'''



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






			def       lowerCamelCase  (self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__   )					->       Union[str, 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   )					->       Union[str, Any]:


							'''simple docstring'''



							snake_case_						:   str           =  TFFlaubertModelTester(self   )
							snake_case_						:   int           =  ConfigTester(self ,							config_class=__magic_name__ ,							emb_dim=37   )






			def       lowerCamelCase  (self   )					->       Dict:


							'''simple docstring'''



							self.config_tester.run_common_tests()






			def       lowerCamelCase  (self   )					->       Optional[Any]:


							'''simple docstring'''



							snake_case_						:   Dict           =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_model(*__magic_name__   )






			def       lowerCamelCase  (self   )					->       List[str]:


							'''simple docstring'''



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






			def       lowerCamelCase  (self   )					->       Dict:


							'''simple docstring'''



							snake_case_						:   List[Any]           =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_qa(*__magic_name__   )






			def       lowerCamelCase  (self   )					->       Tuple:


							'''simple docstring'''



							snake_case_						:   Tuple           =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_sequence_classif(*__magic_name__   )






			def       lowerCamelCase  (self   )					->       str:


							'''simple docstring'''



							snake_case_						:   Any           =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_for_token_classification(*__magic_name__   )






			def       lowerCamelCase  (self   )					->       Optional[int]:


							'''simple docstring'''



							snake_case_						:   List[str]           =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_for_multiple_choice(*__magic_name__   )






			@slow
			def       lowerCamelCase  (self   )					->       int:


							'''simple docstring'''



							for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											snake_case_						:   Optional[Any]           =  TFFlaubertModel.from_pretrained(__magic_name__   )
											self.assertIsNotNone(__magic_name__   )




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






			@slow
			def       lowerCamelCase  (self   )					->       Optional[Any]:


							'''simple docstring'''



							snake_case_						:   Optional[int]           =  TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased'''   )

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

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







def 					lowerCamelCase_						(    _UpperCamelCase			)		->						str:






				"""simple docstring"""


				if number > 0:
								raise ValueError('''input must be a negative integer'''			)
				snake_case_						:   List[str]           =  len(bin(_UpperCamelCase			)[3:]			)
				snake_case_						:   str           =  bin(abs(_UpperCamelCase			) - (1 << binary_number_length)			)[3:]
				snake_case_						:   Dict           =  (
				    (
				        '''1'''
				        + '''0''' * (binary_number_length - len(_UpperCamelCase			))
				        + twos_complement_number
				    )
				    if number < 0
				    else '''0'''
				)
				return "0b" + twos_complement_number


if __name__ == "__main__":
	import doctest

	doctest.testmod()
