



"""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    SCREAMING_SNAKE_CASE__ :

    def __init__(				self			:				Optional[int] ,  lowerCAmelCase_			:				Tuple ,  ):







      """simple docstring"""







      lowercase_								= parent
      lowercase_								= 1_3
      lowercase_								= 7
      lowercase_								= True
      lowercase_								= True
      lowercase_								= True
      lowercase_								= True
      lowercase_								= True
      lowercase_								= False
      lowercase_								= False
      lowercase_								= False
      lowercase_								= 2
      lowercase_								= 9_9
      lowercase_								= 0
      lowercase_								= 3_2
      lowercase_								= 2
      lowercase_								= 4
      lowercase_								= 0.1
      lowercase_								= 0.1
      lowercase_								= 5_1_2
      lowercase_								= 1_6
      lowercase_								= 2
      lowercase_								= 0.02
      lowercase_								= 3
      lowercase_								= 4
      lowercase_								= """last"""
      lowercase_								= True
      lowercase_								= None
      lowercase_								= 0

    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size)
      lowercase_								= random_attention_mask([self.batch_size, self.seq_length] ,  dtype=tf.floataa)

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

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

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

      lowercase_								= 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			:				List[str] ,  lowerCAmelCase_			:				Optional[int] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Optional[int] ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				Union[str, Any] ,  ):







      """simple docstring"""







      lowercase_								= TFFlaubertModel(config=lowerCAmelCase_)
      lowercase_								= {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
      lowercase_								= model(lowerCAmelCase_)

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

    def 					_UpperCAmelCase	(				self			:				Optional[int] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				str ,  ):







      """simple docstring"""







      lowercase_								= TFFlaubertWithLMHeadModel(lowerCAmelCase_)

      lowercase_								= {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
      lowercase_								= model(lowerCAmelCase_)

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

    def 					_UpperCAmelCase	(				self			:				Optional[Any] ,  lowerCAmelCase_			:				Optional[int] ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Optional[int] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Optional[int] ,  lowerCAmelCase_			:				Any ,  ):







      """simple docstring"""







      lowercase_								= TFFlaubertForQuestionAnsweringSimple(lowerCAmelCase_)

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

      lowercase_								= 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 					_UpperCAmelCase	(				self			:				str ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				str ,  ):







      """simple docstring"""







      lowercase_								= TFFlaubertForSequenceClassification(lowerCAmelCase_)

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

      lowercase_								= model(lowerCAmelCase_)

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

    def 					_UpperCAmelCase	(				self			:				Any ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Tuple ,  ):







      """simple docstring"""







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

    def 					_UpperCAmelCase	(				self			:				Optional[int] ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				int ,  ):







      """simple docstring"""







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




    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







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

    def 					_UpperCAmelCase	(				self			:				Optional[int] ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				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 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_								= TFFlaubertModelTester(self)
      lowercase_								= ConfigTester(self ,  config_class=lowerCAmelCase_ ,  emb_dim=3_7)

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      self.config_tester.run_common_tests()

    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_model(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_lm_head(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_qa(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_sequence_classif(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_for_token_classification(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_for_multiple_choice(*lowerCAmelCase_)




    @slow
    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowercase_								= TFFlaubertModel.from_pretrained(lowerCAmelCase_)
        self.assertIsNotNone(lowerCAmelCase_)







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

    @slow
    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_								= TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""")

      lowercase_								= 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 !"

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






"""simple docstring"""
def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase							) ->						int:







  '''simple docstring'''


  while a != 0:
    lowercase_					,    lowercase_								= b % a, a
  return b


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase							) ->						int:







  '''simple docstring'''


  if gcd(__lowerCAmelCase ,  __lowerCAmelCase							) != 1:
    lowercase_								= F'''mod inverse of {a!r} and {m!r} does not exist'''
    raise ValueError(__lowerCAmelCase							)
  lowercase_					,    lowercase_					,    lowercase_								= 1, 0, a
  lowercase_					,    lowercase_					,    lowercase_								= 0, 1, m
  while va != 0:
    lowercase_								= ua // va
    lowercase_					,    lowercase_					,    lowercase_					,    lowercase_					,    lowercase_					,    lowercase_								= (ua - q * va), (ua - q * va), (ua - q * va), va, va, va
  return ua % m

