






'''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        _UpperCAmelCase						:




    def __init__(			self  :       List[str]  ,     a  :       Tuple  ,     ):






       '''simple docstring'''






       lowercase_	:    int           =     parent
       lowercase_	:    Optional[Any]           =     1_3
       lowercase_	:    str           =     7
       lowercase_	:    Optional[int]           =     True
       lowercase_	:    Optional[int]           =     True
       lowercase_	:    Optional[int]           =     True
       lowercase_	:    int           =     True
       lowercase_	:    Dict           =     True
       lowercase_	:    str           =     False
       lowercase_	:    Optional[Any]           =     False
       lowercase_	:    List[Any]           =     False
       lowercase_	:    Dict           =     2
       lowercase_	:    int           =     9_9
       lowercase_	:    Tuple           =     0
       lowercase_	:    int           =     3_2
       lowercase_	:    List[Any]           =     2
       lowercase_	:    Optional[Any]           =     4
       lowercase_	:    str           =     0.1
       lowercase_	:    Dict           =     0.1
       lowercase_	:    List[str]           =     5_1_2
       lowercase_	:    Optional[int]           =     1_6
       lowercase_	:    Dict           =     2
       lowercase_	:    List[str]           =     0.02
       lowercase_	:    Optional[int]           =     3
       lowercase_	:    Optional[int]           =     4
       lowercase_	:    Any           =     "last"
       lowercase_	:    Tuple           =     True
       lowercase_	:    Any           =     None
       lowercase_	:    Optional[Any]           =     0




    def 				lowerCAmelCase__				(			self  :       int			):






       '''simple docstring'''






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

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

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

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

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






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     TFFlaubertModel(config=a			)
       lowercase_	:    List[Any]           =     {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
       lowercase_	:    Any           =     model(a			)

       lowercase_	:    Optional[int]           =     [input_ids, input_mask]
       lowercase_	:    List[Any]           =     model(a			)
       self.parent.assertEqual(result.last_hidden_state.shape  ,     (self.batch_size, self.seq_length, self.hidden_size)			)




    def 				lowerCAmelCase__				(			self  :       List[str]  ,     a  :       List[Any]  ,     a  :       Optional[Any]  ,     a  :       Dict  ,     a  :       Union[str, Any]  ,     a  :       int  ,     a  :       List[Any]  ,     a  :       int  ,     a  :       Union[str, Any]  ,     a  :       Any  ,     ):






       '''simple docstring'''






       lowercase_	:    List[Any]           =     TFFlaubertWithLMHeadModel(a			)

       lowercase_	:    Dict           =     {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
       lowercase_	:    int           =     model(a			)

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




    def 				lowerCAmelCase__				(			self  :       Union[str, Any]  ,     a  :       Any  ,     a  :       Dict  ,     a  :       Union[str, Any]  ,     a  :       Union[str, Any]  ,     a  :       Union[str, Any]  ,     a  :       str  ,     a  :       List[Any]  ,     a  :       Optional[int]  ,     a  :       Union[str, Any]  ,     ):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     TFFlaubertForQuestionAnsweringSimple(a			)

       lowercase_	:    Optional[Any]           =     {"input_ids": input_ids, "lengths": input_lengths}

       lowercase_	:    List[Any]           =     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 				lowerCAmelCase__				(			self  :       Optional[Any]  ,     a  :       Any  ,     a  :       str  ,     a  :       List[Any]  ,     a  :       Tuple  ,     a  :       Union[str, Any]  ,     a  :       Tuple  ,     a  :       Tuple  ,     a  :       int  ,     a  :       Optional[Any]  ,     ):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     TFFlaubertForSequenceClassification(a			)

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

       lowercase_	:    List[str]           =     model(a			)

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




    def 				lowerCAmelCase__				(			self  :       Optional[int]  ,     a  :       List[Any]  ,     a  :       int  ,     a  :       Tuple  ,     a  :       Any  ,     a  :       str  ,     a  :       Union[str, Any]  ,     a  :       Optional[Any]  ,     a  :       int  ,     a  :       Dict  ,     ):






       '''simple docstring'''






       lowercase_	:    str           =     self.num_labels
       lowercase_	:    List[str]           =     TFFlaubertForTokenClassification(config=a			)
       lowercase_	:    str           =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       lowercase_	:    Dict           =     model(a			)
       self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.seq_length, self.num_labels)			)




    def 				lowerCAmelCase__				(			self  :       List[str]  ,     a  :       Optional[int]  ,     a  :       Dict  ,     a  :       str  ,     a  :       Tuple  ,     a  :       Tuple  ,     a  :       Tuple  ,     a  :       Any  ,     a  :       Dict  ,     a  :       List[str]  ,     ):






       '''simple docstring'''






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





    def 				lowerCAmelCase__				(			self  :       Dict			):






       '''simple docstring'''






       lowercase_	:    Union[str, Any]           =     self.prepare_config_and_inputs()
       (
           (
           lowercase_
       )    ,		(
           lowercase_
       )    ,		(
           lowercase_
       )    ,		(
           lowercase_
       )    ,		(
           lowercase_
       )    ,		(
           lowercase_
       )    ,		(
           lowercase_
       )    ,		(
           lowercase_
       )    ,		(
           lowercase_
       )    ,		
       )	:    List[str]           =     config_and_inputs
       lowercase_	:    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        _UpperCAmelCase						(		snake_case				,					snake_case				,					unittest.TestCase			):
    __lowerCamelCase:   Dict		       =    (
        (
            TFFlaubertModel,
            TFFlaubertWithLMHeadModel,
            TFFlaubertForSequenceClassification,
            TFFlaubertForQuestionAnsweringSimple,
            TFFlaubertForTokenClassification,
            TFFlaubertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    __lowerCamelCase:   Any		       =    (
        (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Check other models whether language generation is also applicable
    __lowerCamelCase:   Dict		       =    (
        {
            '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:   Dict		       =    False




    def 				lowerCAmelCase__				(			self  :       Optional[int]  ,     a  :       Optional[Any]  ,     a  :       Tuple  ,     a  :       List[str]  ,     a  :       Tuple  ,     a  :       Optional[int]			):






       '''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  :       Tuple			):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     TFFlaubertModelTester(self			)
       lowercase_	:    str           =     ConfigTester(self  ,     config_class=a  ,     emb_dim=3_7			)




    def 				lowerCAmelCase__				(			self  :       Optional[int]			):






       '''simple docstring'''






       self.config_tester.run_common_tests()




    def 				lowerCAmelCase__				(			self  :       Dict			):






       '''simple docstring'''






       lowercase_	:    int           =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_model(*a			)




    def 				lowerCAmelCase__				(			self  :       Dict			):






       '''simple docstring'''






       lowercase_	:    Optional[Any]           =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_lm_head(*a			)




    def 				lowerCAmelCase__				(			self  :       str			):






       '''simple docstring'''






       lowercase_	:    Any           =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_qa(*a			)




    def 				lowerCAmelCase__				(			self  :       Optional[Any]			):






       '''simple docstring'''






       lowercase_	:    Optional[Any]           =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_sequence_classif(*a			)




    def 				lowerCAmelCase__				(			self  :       Optional[int]			):






       '''simple docstring'''






       lowercase_	:    List[str]           =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_token_classification(*a			)




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






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_multiple_choice(*a			)





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






       '''simple docstring'''






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


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




    @slow
    def 				lowerCAmelCase__				(			self  :       List[str]			):






       '''simple docstring'''






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

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












'''simple docstring'''
# limitations under the License.

# NOTE: This file is deprecated and will be removed in a future version.
# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works

from .pipelines import DiffusionPipeline, ImagePipelineOutput  # noqa: F401
from .utils import deprecate


deprecate(
    'pipelines_utils',
    '0.22.0',
    'Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.',
    standard_warn=False,
    stacklevel=3,
)




