





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			,				A_			,				):
       '''simple docstring'''




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





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size  )
       UpperCamelCase      :   Tuple			      =  random_attention_mask([self.batch_size, self.seq_length]			,				dtype=tf.floataa  )

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

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

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

       UpperCamelCase      :   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 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  TFFlaubertModel(config=A_  )
       UpperCamelCase      :   List[str]			      =  {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
       UpperCamelCase      :   Union[str, Any]			      =  model(A_  )

       UpperCamelCase      :   List[str]			      =  [input_ids, input_mask]
       UpperCamelCase      :   Tuple			      =  model(A_  )
       self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)  )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  TFFlaubertWithLMHeadModel(A_  )

       UpperCamelCase      :   Optional[Any]			      =  {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
       UpperCamelCase      :   int			      =  model(A_  )

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





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  TFFlaubertForQuestionAnsweringSimple(A_  )

       UpperCamelCase      :   Any			      =  {"input_ids": input_ids, "lengths": input_lengths}

       UpperCamelCase      :   Dict			      =  model(A_  )

       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			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Optional[Any]			      =  TFFlaubertForSequenceClassification(A_  )

       UpperCamelCase      :   Optional[int]			      =  {"input_ids": input_ids, "lengths": input_lengths}

       UpperCamelCase      :   str			      =  model(A_  )

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





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  self.num_labels
       UpperCamelCase      :   Union[str, Any]			      =  TFFlaubertForTokenClassification(config=A_  )
       UpperCamelCase      :   Any			      =  {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       UpperCamelCase      :   Any			      =  model(A_  )
       self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.num_labels)  )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				):
       '''simple docstring'''




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





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




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





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_  ):
       '''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  ):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  TFFlaubertModelTester(self  )
       UpperCamelCase      :   Tuple			      =  ConfigTester(self			,				config_class=A_			,				emb_dim=37  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       self.config_tester.run_common_tests()





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_model(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_lm_head(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[Any]			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_qa(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Tuple			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_sequence_classif(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_token_classification(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Tuple			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_multiple_choice(*A_  )





      @slow
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCamelCase      :   Tuple			      =  TFFlaubertModel.from_pretrained(A_  )
        self.assertIsNotNone(A_  )



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





      @slow
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   str			      =  TFFlaubertModel.from_pretrained("jplu/tf-flaubert-small-cased"  )

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

       UpperCamelCase      :   int			      =  model(A_  )[0]
       UpperCamelCase      :   Any			      =  tf.TensorShape((1, 8, 512)  )
       self.assertEqual(output.shape			,				A_  )
       # compare the actual values for a slice.
       UpperCamelCase      :   Optional[int]			      =  tf.convert_to_tensor(
           [
               [
                   [-1.8_76_87_73, -1.56_65_55, 0.27_07_24_18],
                   [-1.6_92_00_38, -0.5_87_35_05, 1.9_32_95_99],
                   [-2.9_56_39_85, -1.6_99_38_35, 1.7_97_20_52],
               ]
           ]			,				dtype=tf.floataa			,				)

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







# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

__lowerCamelCase			:	str					    =	TypeVar("""T""")



class    A__  (			Generic[T]     ):





      def __init__(					self			,				A_ = True  ):
       '''simple docstring'''




       UpperCamelCase      :   dict[T, list[T]]			      =  {}  # dictionary of lists
       UpperCamelCase      :   Union[str, Any]			      =  directed





      def 			__UpperCamelCase(					self			,				A_			,				A_  ):
       '''simple docstring'''




       if not self.directed:  # For undirected graphs
        # if both source vertex and destination vertex are both present in the
        # adjacency list, add destination vertex to source vertex list of adjacent
        # vertices and add source vertex to destination vertex list of adjacent
        # vertices.
        if source_vertex in self.adj_list and destination_vertex in self.adj_list:
         self.adj_list[source_vertex].append(A_  )
         self.adj_list[destination_vertex].append(A_  )
        # if only source vertex is present in adjacency list, add destination vertex
        # to source vertex list of adjacent vertices, then create a new vertex with
        # destination vertex as key and assign a list containing the source vertex
        # as it's first adjacent vertex.
        elif source_vertex in self.adj_list:
         self.adj_list[source_vertex].append(A_  )
         UpperCamelCase      :   Any			      =  [source_vertex]
        # if only destination vertex is present in adjacency list, add source vertex
        # to destination vertex list of adjacent vertices, then create a new vertex
        # with source vertex as key and assign a list containing the source vertex
        # as it's first adjacent vertex.
        elif destination_vertex in self.adj_list:
         self.adj_list[destination_vertex].append(A_  )
         UpperCamelCase      :   Any			      =  [destination_vertex]
        # if both source vertex and destination vertex are not present in adjacency
        # list, create a new vertex with source vertex as key and assign a list
        # containing the destination vertex as it's first adjacent vertex also
        # create a new vertex with destination vertex as key and assign a list
        # containing the source vertex as it's first adjacent vertex.
        else:
         UpperCamelCase      :   Union[str, Any]			      =  [destination_vertex]
         UpperCamelCase      :   List[str]			      =  [source_vertex]
       else:  # For directed graphs
        # if both source vertex and destination vertex are present in adjacency
        # list, add destination vertex to source vertex list of adjacent vertices.
        if source_vertex in self.adj_list and destination_vertex in self.adj_list:
         self.adj_list[source_vertex].append(A_  )
        # if only source vertex is present in adjacency list, add destination
        # vertex to source vertex list of adjacent vertices and create a new vertex
        # with destination vertex as key, which has no adjacent vertex
        elif source_vertex in self.adj_list:
         self.adj_list[source_vertex].append(A_  )
         UpperCamelCase      :   List[str]			      =  []
        # if only destination vertex is present in adjacency list, create a new
        # vertex with source vertex as key and assign a list containing destination
        # vertex as first adjacent vertex
        elif destination_vertex in self.adj_list:
         UpperCamelCase      :   Union[str, Any]			      =  [destination_vertex]
        # if both source vertex and destination vertex are not present in adjacency
        # list, create a new vertex with source vertex as key and a list containing
        # destination vertex as it's first adjacent vertex. Then create a new vertex
        # with destination vertex as key, which has no adjacent vertex
        else:
         UpperCamelCase      :   Union[str, Any]			      =  [destination_vertex]
         UpperCamelCase      :   Dict			      =  []

       return self





      def __repr__(					self  ):
       '''simple docstring'''




       return pformat(self.adj_list  )
