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




   def __init__(   self      :    Optional[int]	,     _lowercase      :    int	,     ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				parent
     SCREAMING_SNAKE_CASE__      							=				13
     SCREAMING_SNAKE_CASE__      							=				7
     SCREAMING_SNAKE_CASE__      							=				True
     SCREAMING_SNAKE_CASE__      							=				True
     SCREAMING_SNAKE_CASE__      							=				True
     SCREAMING_SNAKE_CASE__      							=				True
     SCREAMING_SNAKE_CASE__      							=				True
     SCREAMING_SNAKE_CASE__      							=				False
     SCREAMING_SNAKE_CASE__      							=				False
     SCREAMING_SNAKE_CASE__      							=				False
     SCREAMING_SNAKE_CASE__      							=				2
     SCREAMING_SNAKE_CASE__      							=				99
     SCREAMING_SNAKE_CASE__      							=				0
     SCREAMING_SNAKE_CASE__      							=				32
     SCREAMING_SNAKE_CASE__      							=				2
     SCREAMING_SNAKE_CASE__      							=				4
     SCREAMING_SNAKE_CASE__      							=				0.1
     SCREAMING_SNAKE_CASE__      							=				0.1
     SCREAMING_SNAKE_CASE__      							=				5_12
     SCREAMING_SNAKE_CASE__      							=				16
     SCREAMING_SNAKE_CASE__      							=				2
     SCREAMING_SNAKE_CASE__      							=				0.02
     SCREAMING_SNAKE_CASE__      							=				3
     SCREAMING_SNAKE_CASE__      							=				4
     SCREAMING_SNAKE_CASE__      							=				"""last"""
     SCREAMING_SNAKE_CASE__      							=				True
     SCREAMING_SNAKE_CASE__      							=				None
     SCREAMING_SNAKE_CASE__      							=				0




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






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

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

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

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

     SCREAMING_SNAKE_CASE__      							=				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      __a						(   self      :    List[Any]	,     _lowercase      :    Any	,     _lowercase      :    Union[str, Any]	,     _lowercase      :    List[Any]	,     _lowercase      :    Dict	,     _lowercase      :    List[Any]	,     _lowercase      :    str	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Any	,     _lowercase      :    int	,     ):



     """simple docstring"""






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

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




   def      __a						(   self      :    Optional[Any]	,     _lowercase      :    List[str]	,     _lowercase      :    List[str]	,     _lowercase      :    Dict	,     _lowercase      :    str	,     _lowercase      :    Tuple	,     _lowercase      :    int	,     _lowercase      :    Tuple	,     _lowercase      :    str	,     _lowercase      :    List[Any]	,     ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				TFFlaubertWithLMHeadModel(_lowercase				)

     SCREAMING_SNAKE_CASE__      							=				{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
     SCREAMING_SNAKE_CASE__      							=				model(_lowercase				)

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




   def      __a						(   self      :    Any	,     _lowercase      :    int	,     _lowercase      :    List[Any]	,     _lowercase      :    Any	,     _lowercase      :    List[Any]	,     _lowercase      :    List[str]	,     _lowercase      :    str	,     _lowercase      :    Dict	,     _lowercase      :    List[str]	,     _lowercase      :    List[Any]	,     ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				TFFlaubertForQuestionAnsweringSimple(_lowercase				)

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

     SCREAMING_SNAKE_CASE__      							=				model(_lowercase				)

     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      __a						(   self      :    Tuple	,     _lowercase      :    List[str]	,     _lowercase      :    List[Any]	,     _lowercase      :    Tuple	,     _lowercase      :    int	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[Any]	,     _lowercase      :    str	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Optional[Any]	,     ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				TFFlaubertForSequenceClassification(_lowercase				)

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

     SCREAMING_SNAKE_CASE__      							=				model(_lowercase				)

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




   def      __a						(   self      :    Any	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Union[str, Any]	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[int]	,     _lowercase      :    List[str]	,     _lowercase      :    int	,     _lowercase      :    Tuple	,     _lowercase      :    Optional[int]	,     ):



     """simple docstring"""






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




   def      __a						(   self      :    Any	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Optional[int]	,     _lowercase      :    str	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    List[Any]	,     ):



     """simple docstring"""






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




   def      __a						(   self      :    Any				):



     """simple docstring"""






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







@require_tf
class __snake_case    (						lowerCamelCase_       ,		lowerCamelCase_       ,		unittest.TestCase		):
   lowerCAmelCase_														=							(
       (
           TFFlaubertModel,
           TFFlaubertWithLMHeadModel,
           TFFlaubertForSequenceClassification,
           TFFlaubertForQuestionAnsweringSimple,
           TFFlaubertForTokenClassification,
           TFFlaubertForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   lowerCAmelCase_														=							(
       (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
   )  # TODO (PVP): Check other models whether language generation is also applicable
   lowerCAmelCase_														=							(
       {
           "feature-extraction": TFFlaubertModel,
           "fill-mask": TFFlaubertWithLMHeadModel,
           "question-answering": TFFlaubertForQuestionAnsweringSimple,
           "text-classification": TFFlaubertForSequenceClassification,
           "token-classification": TFFlaubertForTokenClassification,
           "zero-shot": TFFlaubertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   lowerCAmelCase_														=							False
   lowerCAmelCase_														=							False




   def      __a						(   self      :    Dict	,     _lowercase      :    int	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Tuple	,     _lowercase      :    str	,     _lowercase      :    Optional[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      __a						(   self      :    Dict				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				TFFlaubertModelTester(self				)
     SCREAMING_SNAKE_CASE__      							=				ConfigTester(self	,     config_class=_lowercase	,     emb_dim=37				)




   def      __a						(   self      :    List[str]				):



     """simple docstring"""






     self.config_tester.run_common_tests()




   def      __a						(   self      :    int				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_model(*_lowercase				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_lm_head(*_lowercase				)




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



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_qa(*_lowercase				)




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



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_sequence_classif(*_lowercase				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_for_token_classification(*_lowercase				)




   def      __a						(   self      :    int				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_for_multiple_choice(*_lowercase				)




   @slow
   def      __a						(   self      :    str				):



     """simple docstring"""






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







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




   @slow
   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






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

     SCREAMING_SNAKE_CASE__      							=				tf.convert_to_tensor(
         [[0, 1_58, 7_35, 25_92, 14_24, 67_27, 82, 1]]	,     dtype=tf.intaa	,     )  # "J'aime flaubert !"

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

import warnings

from ...utils import logging
from .image_processing_donut import DonutImageProcessor


__lowerCamelCase      :			str							       =		logging.get_logger(__name__)







class __snake_case    (						lowerCamelCase_		):




   def __init__(   self      :    List[str]	,     *_lowercase      :    Union[str, Any]	,     **_lowercase      :    Union[str, Any]				):



     """simple docstring"""






     warnings.warn(
         """The class DonutFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"""
         """ use DonutImageProcessor instead."""	,     _lowercase	,     )
     super().__init__(*_lowercase	,     **_lowercase				)
