






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


			'''simple docstring'''





			def __init__(   self							:						Optional[int] ,      lowercase							:						Optional[Any] ,      )							->    Union[str, Any]:

									'''simple docstring'''







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






			def 				A      (   self							:						int			)							->    Tuple:

									'''simple docstring'''







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

									'''simple docstring'''







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

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






			def 				A      (   self							:						List[str] ,      lowercase							:						Any ,      lowercase							:						Union[str, Any] ,      lowercase							:						Tuple ,      lowercase							:						Any ,      lowercase							:						List[Any] ,      lowercase							:						str ,      lowercase							:						int ,      lowercase							:						Tuple ,      lowercase							:						str ,      )							->    Tuple:

									'''simple docstring'''







									UpperCamelCase__         = TFFlaubertWithLMHeadModel(lowercase			)

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

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






			def 				A      (   self							:						str ,      lowercase							:						List[Any] ,      lowercase							:						List[Any] ,      lowercase							:						Optional[Any] ,      lowercase							:						str ,      lowercase							:						Dict ,      lowercase							:						Union[str, Any] ,      lowercase							:						int ,      lowercase							:						Union[str, Any] ,      lowercase							:						str ,      )							->    Optional[int]:

									'''simple docstring'''







									UpperCamelCase__         = TFFlaubertForQuestionAnsweringSimple(lowercase			)

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

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

									'''simple docstring'''







									UpperCamelCase__         = TFFlaubertForSequenceClassification(lowercase			)

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

									UpperCamelCase__         = model(lowercase			)

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






			def 				A      (   self							:						Optional[Any] ,      lowercase							:						Any ,      lowercase							:						str ,      lowercase							:						str ,      lowercase							:						Tuple ,      lowercase							:						int ,      lowercase							:						Dict ,      lowercase							:						List[Any] ,      lowercase							:						Optional[Any] ,      lowercase							:						Optional[int] ,      )							->    Tuple:

									'''simple docstring'''







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






			def 				A      (   self							:						Tuple ,      lowercase							:						Optional[int] ,      lowercase							:						Dict ,      lowercase							:						List[str] ,      lowercase							:						Any ,      lowercase							:						List[str] ,      lowercase							:						List[Any] ,      lowercase							:						str ,      lowercase							:						Any ,      lowercase							:						List[str] ,      )							->    Optional[Any]:

									'''simple docstring'''







									UpperCamelCase__         = self.num_choices
									UpperCamelCase__         = TFFlaubertForMultipleChoice(config=lowercase			)
									UpperCamelCase__         = tf.tile(tf.expand_dims(lowercase ,      1			) ,      (1, self.num_choices, 1)			)
									UpperCamelCase__         = tf.tile(tf.expand_dims(lowercase ,      1			) ,      (1, self.num_choices, 1)			)
									UpperCamelCase__         = tf.tile(tf.expand_dims(lowercase ,      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(lowercase			)
									self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.num_choices)			)







			def 				A      (   self							:						List[str]			)							->    List[Any]:

									'''simple docstring'''







									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							(		SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       ,unittest.TestCase	):


			'''simple docstring'''





			__a							:							List[str]					     =					(
			    (
			        TFFlaubertModel,
			        TFFlaubertWithLMHeadModel,
			        TFFlaubertForSequenceClassification,
			        TFFlaubertForQuestionAnsweringSimple,
			        TFFlaubertForTokenClassification,
			        TFFlaubertForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			__a							:							Optional[int]					     =					(
			    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
			)  # TODO (PVP): Check other models whether language generation is also applicable
			__a							:							Union[str, Any]					     =					(
			    {
			        "feature-extraction": TFFlaubertModel,
			        "fill-mask": TFFlaubertWithLMHeadModel,
			        "question-answering": TFFlaubertForQuestionAnsweringSimple,
			        "text-classification": TFFlaubertForSequenceClassification,
			        "token-classification": TFFlaubertForTokenClassification,
			        "zero-shot": TFFlaubertForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			__a							:							List[str]					     =					False
			__a							:							Union[str, Any]					     =					False






			def 				A      (   self							:						Tuple ,      lowercase							:						Optional[Any] ,      lowercase							:						Tuple ,      lowercase							:						Optional[int] ,      lowercase							:						Any ,      lowercase							:						Union[str, Any]			)							->    str:

									'''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							:						List[Any]			)							->    Tuple:

									'''simple docstring'''







									UpperCamelCase__         = TFFlaubertModelTester(self			)
									UpperCamelCase__         = ConfigTester(self ,      config_class=lowercase ,      emb_dim=3_7			)






			def 				A      (   self							:						Union[str, Any]			)							->    Any:

									'''simple docstring'''







									self.config_tester.run_common_tests()






			def 				A      (   self							:						Union[str, Any]			)							->    str:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_model(*lowercase			)






			def 				A      (   self							:						List[str]			)							->    Tuple:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_lm_head(*lowercase			)






			def 				A      (   self							:						Optional[Any]			)							->    List[str]:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_qa(*lowercase			)






			def 				A      (   self							:						Any			)							->    Any:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_sequence_classif(*lowercase			)






			def 				A      (   self							:						Any			)							->    Tuple:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_token_classification(*lowercase			)






			def 				A      (   self							:						Any			)							->    List[Any]:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_multiple_choice(*lowercase			)







			@slow
			def 				A      (   self							:						Tuple			)							->    Tuple:

									'''simple docstring'''







									for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															UpperCamelCase__         = TFFlaubertModel.from_pretrained(lowercase			)
															self.assertIsNotNone(lowercase			)
@require_tf
@require_sentencepiece
@require_tokenizers
class    _SCREAMING_SNAKE_CASE							(		unittest.TestCase	):


			'''simple docstring'''





			@slow
			def 				A      (   self							:						int			)							->    Tuple:

									'''simple docstring'''







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

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

									UpperCamelCase__         = model(lowercase			)[0]
									UpperCamelCase__         = tf.TensorShape((1, 8, 5_1_2)			)
									self.assertEqual(output.shape ,      lowercase			)
									# compare the actual values for a slice.
									UpperCamelCase__         = tf.convert_to_tensor(
									    [
									        [
									            [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
									            [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
									            [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
									        ]
									    ] ,      dtype=tf.floataa ,      )

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








'''simple docstring'''


# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch

from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor
from ..utils import is_datasets_available
from .base import PipelineTool


if is_datasets_available():
					from datasets import load_dataset
class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





			__a							:							int					     =					"microsoft/speecht5_tts"
			__a							:							int					     =					(
			    "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the "
			    "text to read (in English) and returns a waveform object containing the sound."
			)
			__a							:							Optional[Any]					     =					"text_reader"
			__a							:							Tuple					     =					SpeechTaProcessor
			__a							:							int					     =					SpeechTaForTextToSpeech
			__a							:							int					     =					SpeechTaHifiGan

			__a							:							Optional[int]					     =					["text"]
			__a							:							Union[str, Any]					     =					["audio"]






			def 				A      (   self							:						str			)							->    Optional[int]:

									'''simple docstring'''







									if self.post_processor is None:
															UpperCamelCase__         = """microsoft/speecht5_hifigan"""
									super().setup()






			def 				A      (   self							:						List[Any] ,      lowercase							:						Any ,      lowercase							:						Union[str, Any]=None			)							->    Tuple:

									'''simple docstring'''







									UpperCamelCase__         = self.pre_processor(text=lowercase ,      return_tensors="""pt""" ,      truncation=lowercase			)

									if speaker_embeddings is None:
															if not is_datasets_available():
																					raise ImportError("""Datasets needs to be installed if not passing speaker embeddings."""			)

															UpperCamelCase__         = load_dataset("""Matthijs/cmu-arctic-xvectors""" ,      split="""validation"""			)
															UpperCamelCase__         = torch.tensor(embeddings_dataset[7_3_0_5]["""xvector"""]			).unsqueeze(0			)

									return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings}






			def 				A      (   self							:						Union[str, Any] ,      lowercase							:						Optional[int]			)							->    int:

									'''simple docstring'''







									with torch.no_grad():
															return self.model.generate_speech(**lowercase			)







			def 				A      (   self							:						str ,      lowercase							:						Union[str, Any]			)							->    Tuple:

									'''simple docstring'''







									with torch.no_grad():
															return self.post_processor(lowercase			).cpu().detach()
