





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






							def __init__(						self  , __lowerCAmelCase  , ):
														UpperCamelCase__				     =			parent
														UpperCamelCase__				     =			13
														UpperCamelCase__				     =			7
														UpperCamelCase__				     =			True
														UpperCamelCase__				     =			True
														UpperCamelCase__				     =			True
														UpperCamelCase__				     =			True
														UpperCamelCase__				     =			True
														UpperCamelCase__				     =			False
														UpperCamelCase__				     =			False
														UpperCamelCase__				     =			False
														UpperCamelCase__				     =			2
														UpperCamelCase__				     =			99
														UpperCamelCase__				     =			0
														UpperCamelCase__				     =			32
														UpperCamelCase__				     =			2
														UpperCamelCase__				     =			4
														UpperCamelCase__				     =			0.1
														UpperCamelCase__				     =			0.1
														UpperCamelCase__				     =			512
														UpperCamelCase__				     =			16
														UpperCamelCase__				     =			2
														UpperCamelCase__				     =			0.02
														UpperCamelCase__				     =			3
														UpperCamelCase__				     =			4
														UpperCamelCase__				     =			"""last"""
														UpperCamelCase__				     =			True
														UpperCamelCase__				     =			None
														UpperCamelCase__				     =			0






							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			ids_tensor([self.batch_size, self.seq_length]  , self.vocab_size  )
														UpperCamelCase__				     =			random_attention_mask([self.batch_size, self.seq_length]  , dtype=tf.floataa  )

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

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

														UpperCamelCase__				     =			None
														UpperCamelCase__				     =			None
														UpperCamelCase__				     =			None
														if self.use_labels:
																					UpperCamelCase__				     =			ids_tensor([self.batch_size]  , self.type_sequence_label_size  )
																					UpperCamelCase__				     =			ids_tensor([self.batch_size, self.seq_length]  , self.num_labels  )
																					UpperCamelCase__				     =			ids_tensor([self.batch_size]  , 2  , dtype=tf.floataa  )
																					UpperCamelCase__				     =			ids_tensor([self.batch_size]  , self.num_choices  )

														UpperCamelCase__				     =			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  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , ):
														UpperCamelCase__				     =			TFFlaubertModel(config=__lowerCAmelCase  )
														UpperCamelCase__				     =			{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
														UpperCamelCase__				     =			model(__lowerCAmelCase  )

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






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , ):
														UpperCamelCase__				     =			TFFlaubertWithLMHeadModel(__lowerCAmelCase  )

														UpperCamelCase__				     =			{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
														UpperCamelCase__				     =			model(__lowerCAmelCase  )

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






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , ):
														UpperCamelCase__				     =			TFFlaubertForQuestionAnsweringSimple(__lowerCAmelCase  )

														UpperCamelCase__				     =			{"""input_ids""": input_ids, """lengths""": input_lengths}

														UpperCamelCase__				     =			model(__lowerCAmelCase  )

														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  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , ):
														UpperCamelCase__				     =			TFFlaubertForSequenceClassification(__lowerCAmelCase  )

														UpperCamelCase__				     =			{"""input_ids""": input_ids, """lengths""": input_lengths}

														UpperCamelCase__				     =			model(__lowerCAmelCase  )

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






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , ):
														UpperCamelCase__				     =			self.num_labels
														UpperCamelCase__				     =			TFFlaubertForTokenClassification(config=__lowerCAmelCase  )
														UpperCamelCase__				     =			{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
														UpperCamelCase__				     =			model(__lowerCAmelCase  )
														self.parent.assertEqual(result.logits.shape  , (self.batch_size, self.seq_length, self.num_labels)  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , ):
														UpperCamelCase__				     =			self.num_choices
														UpperCamelCase__				     =			TFFlaubertForMultipleChoice(config=__lowerCAmelCase  )
														UpperCamelCase__				     =			tf.tile(tf.expand_dims(__lowerCAmelCase  , 1  )  , (1, self.num_choices, 1)  )
														UpperCamelCase__				     =			tf.tile(tf.expand_dims(__lowerCAmelCase  , 1  )  , (1, self.num_choices, 1)  )
														UpperCamelCase__				     =			tf.tile(tf.expand_dims(__lowerCAmelCase  , 1  )  , (1, self.num_choices, 1)  )
														UpperCamelCase__				     =			{
														    """input_ids""": multiple_choice_inputs_ids,
														    """attention_mask""": multiple_choice_input_mask,
														    """token_type_ids""": multiple_choice_token_type_ids,
														}
														UpperCamelCase__				     =			model(__lowerCAmelCase  )
														self.parent.assertEqual(result.logits.shape  , (self.batch_size, self.num_choices)  )







							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.prepare_config_and_inputs()
														(
														    (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     (
														    UpperCamelCase__
														)     ,     
														)				     =			config_and_inputs
														UpperCamelCase__				     =			{
														    """input_ids""": input_ids,
														    """token_type_ids""": token_type_ids,
														    """langs""": token_type_ids,
														    """lengths""": input_lengths,
														}
														return config, inputs_dict






@require_tf
class        __SCREAMING_SNAKE_CASE					(     _a   ,		_a   ,		unittest.TestCase       ):
							snake_case     :      str						     =       (
							    (
							        TFFlaubertModel,
							        TFFlaubertWithLMHeadModel,
							        TFFlaubertForSequenceClassification,
							        TFFlaubertForQuestionAnsweringSimple,
							        TFFlaubertForTokenClassification,
							        TFFlaubertForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							snake_case     :      int						     =       (
							    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							snake_case     :      int						     =       (
							    {
							        """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     :      Union[str, Any]						     =       False
							snake_case     :      Tuple						     =       False






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  ):
														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  ):
														UpperCamelCase__				     =			TFFlaubertModelTester(self  )
														UpperCamelCase__				     =			ConfigTester(self  , config_class=__lowerCAmelCase  , emb_dim=37  )






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






							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_flaubert_model(*__lowerCAmelCase  )






							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_flaubert_lm_head(*__lowerCAmelCase  )






							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_flaubert_qa(*__lowerCAmelCase  )






							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_flaubert_sequence_classif(*__lowerCAmelCase  )






							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_flaubert_for_token_classification(*__lowerCAmelCase  )






							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_flaubert_for_multiple_choice(*__lowerCAmelCase  )







							@slow
							def 				_lowerCamelCase		(						self  ):
														for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					UpperCamelCase__				     =			TFFlaubertModel.from_pretrained(__lowerCAmelCase  )
																					self.assertIsNotNone(__lowerCAmelCase  )






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






							@slow
							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased"""  )

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

														UpperCamelCase__				     =			model(__lowerCAmelCase  )[0]
														UpperCamelCase__				     =			tf.TensorShape((1, 8, 512)  )
														self.assertEqual(output.shape  , __lowerCAmelCase  )
														# compare the actual values for a slice.
														UpperCamelCase__				     =			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  )  )











def     _UpperCamelCase     (a__   :int       ):






							"""simple docstring"""





							if divisor % 5 == 0 or divisor % 2 == 0:
														return 0
							UpperCamelCase__				     =			1
							UpperCamelCase__				     =			1
							while repunit:
														UpperCamelCase__				     =			(10 * repunit + 1) % divisor
														repunit_index += 1
							return repunit_index





def     _UpperCamelCase     (a__   :int = 100_0000       ):






							"""simple docstring"""





							UpperCamelCase__				     =			limit - 1
							if divisor % 2 == 0:
														divisor += 1
							while least_divisible_repunit(a__       ) <= limit:
														divisor += 2
							return divisor


if __name__ == "__main__":
					print(f"""{solution() = }""")




