


# 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        lowerCamelCase__	(							UpperCAmelCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[Any]    =		'microsoft/speecht5_tts'
			_UpperCamelCase		:					Optional[Any]    =		(
			    '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.'
			)
			_UpperCamelCase		:					List[Any]    =		'text_reader'
			_UpperCamelCase		:					int    =		SpeechTaProcessor
			_UpperCamelCase		:					Tuple    =		SpeechTaForTextToSpeech
			_UpperCamelCase		:					int    =		SpeechTaHifiGan

			_UpperCamelCase		:					Tuple    =		['text']
			_UpperCamelCase		:					Tuple    =		['audio']




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case=None     ):

						'''simple docstring'''


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

						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[7305]["xvector"]     ).unsqueeze(0     )

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




			def 				snake_case__				(							self      ,						snake_case     ):

						'''simple docstring'''


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







			def 				snake_case__				(							self      ,						snake_case     ):

						'''simple docstring'''


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






import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
						from transformers import WhisperFeatureExtractor

if is_torch_available():
						import torch

__UpperCamelCase    		=       random.Random()
def        UpperCamelCase_(				_A   :Tuple				,     _A   :str=1.0				,     _A   :int=None				,     _A   :Dict=None  )->		str:
			if rng is None:
						UpperCamelCase__					=       global_rng

			UpperCamelCase__					=       []
			for batch_idx in range(shape[0]  ):
						values.append([]  )
						for _ in range(shape[1]  ):
									values[-1].append(rng.random() * scale  )

			return values







@require_torch
@require_torchaudio
class        lowerCamelCase__	(							unittest.TestCase      ):






			"""simple docstring"""






			def __init__(							self      ,						snake_case      ,						snake_case=7      ,						snake_case=400      ,						snake_case=2000      ,						snake_case=10      ,						snake_case=160      ,						snake_case=8      ,						snake_case=0.0      ,						snake_case=4000      ,						snake_case=False      ,						snake_case=True      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       parent
						UpperCamelCase__					=       batch_size
						UpperCamelCase__					=       min_seq_length
						UpperCamelCase__					=       max_seq_length
						UpperCamelCase__					=       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
						UpperCamelCase__					=       padding_value
						UpperCamelCase__					=       sampling_rate
						UpperCamelCase__					=       return_attention_mask
						UpperCamelCase__					=       do_normalize
						UpperCamelCase__					=       feature_size
						UpperCamelCase__					=       chunk_length
						UpperCamelCase__					=       hop_length




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return {
						    "feature_size": self.feature_size,
						    "hop_length": self.hop_length,
						    "chunk_length": self.chunk_length,
						    "padding_value": self.padding_value,
						    "sampling_rate": self.sampling_rate,
						    "return_attention_mask": self.return_attention_mask,
						    "do_normalize": self.do_normalize,
						}







			def 				snake_case__				(							self      ,						snake_case=False      ,						snake_case=False     ):

						'''simple docstring'''


						def _flatten(snake_case     ):
									return list(itertools.chain(*snake_case     )     )

						if equal_length:
									UpperCamelCase__					=       [floats_list((self.max_seq_length, self.feature_size)     ) for _ in range(self.batch_size     )]
						else:
									# make sure that inputs increase in size
									UpperCamelCase__					=       [
									    floats_list((x, self.feature_size)     )
									    for x in range(self.min_seq_length      ,						self.max_seq_length      ,						self.seq_length_diff     )
									]
						if numpify:
									UpperCamelCase__					=       [np.asarray(snake_case     ) for x in speech_inputs]
						return speech_inputs







@require_torch
@require_torchaudio
class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Any    =		WhisperFeatureExtractor if is_speech_available() else None




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       WhisperFeatureExtractionTester(self     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_dict     )

						with tempfile.TemporaryDirectory() as tmpdirname:
									UpperCamelCase__					=       feat_extract_first.save_pretrained(snake_case     )[0]
									check_json_file_has_correct_format(snake_case     )
									UpperCamelCase__					=       self.feature_extraction_class.from_pretrained(snake_case     )

						UpperCamelCase__					=       feat_extract_first.to_dict()
						UpperCamelCase__					=       feat_extract_second.to_dict()
						UpperCamelCase__					=       feat_extract_first.mel_filters
						UpperCamelCase__					=       feat_extract_second.mel_filters
						self.assertTrue(np.allclose(snake_case      ,						snake_case     )     )
						self.assertEqual(snake_case      ,						snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_dict     )

						with tempfile.TemporaryDirectory() as tmpdirname:
									UpperCamelCase__					=       os.path.join(snake_case      ,						"feat_extract.json"     )
									feat_extract_first.to_json_file(snake_case     )
									UpperCamelCase__					=       self.feature_extraction_class.from_json_file(snake_case     )

						UpperCamelCase__					=       feat_extract_first.to_dict()
						UpperCamelCase__					=       feat_extract_second.to_dict()
						UpperCamelCase__					=       feat_extract_first.mel_filters
						UpperCamelCase__					=       feat_extract_second.mel_filters
						self.assertTrue(np.allclose(snake_case      ,						snake_case     )     )
						self.assertEqual(snake_case      ,						snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
						# create three inputs of length 800, 1000, and 1200
						UpperCamelCase__					=       [floats_list((1, x)     )[0] for x in range(800      ,						1400      ,						200     )]
						UpperCamelCase__					=       [np.asarray(snake_case     ) for speech_input in speech_inputs]

						# Test feature size
						UpperCamelCase__					=       feature_extractor(snake_case      ,						padding="max_length"      ,						return_tensors="np"     ).input_features
						self.assertTrue(input_features.ndim == 3     )
						self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames     )
						self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size     )

						# Test not batched input
						UpperCamelCase__					=       feature_extractor(speech_inputs[0]      ,						return_tensors="np"     ).input_features
						UpperCamelCase__					=       feature_extractor(np_speech_inputs[0]      ,						return_tensors="np"     ).input_features
						self.assertTrue(np.allclose(snake_case      ,						snake_case      ,						atol=1E-3     )     )

						# Test batched
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						for enc_seq_a, enc_seq_a in zip(snake_case      ,						snake_case     ):
									self.assertTrue(np.allclose(snake_case      ,						snake_case      ,						atol=1E-3     )     )

						# Test 2-D numpy arrays are batched.
						UpperCamelCase__					=       [floats_list((1, x)     )[0] for x in (800, 800, 800)]
						UpperCamelCase__					=       np.asarray(snake_case     )
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						for enc_seq_a, enc_seq_a in zip(snake_case      ,						snake_case     ):
									self.assertTrue(np.allclose(snake_case      ,						snake_case      ,						atol=1E-3     )     )

						# Test truncation required
						UpperCamelCase__					=       [floats_list((1, x)     )[0] for x in range(200      ,						(feature_extractor.n_samples + 500)      ,						200     )]
						UpperCamelCase__					=       [np.asarray(snake_case     ) for speech_input in speech_inputs]

						UpperCamelCase__					=       [x[: feature_extractor.n_samples] for x in speech_inputs]
						UpperCamelCase__					=       [np.asarray(snake_case     ) for speech_input in speech_inputs_truncated]

						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						for enc_seq_a, enc_seq_a in zip(snake_case      ,						snake_case     ):
									self.assertTrue(np.allclose(snake_case      ,						snake_case      ,						atol=1E-3     )     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						import torch

						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
						UpperCamelCase__					=       np.random.rand(100      ,						32     ).astype(np.floataa     )
						UpperCamelCase__					=       np_speech_inputs.tolist()

						for inputs in [py_speech_inputs, np_speech_inputs]:
									UpperCamelCase__					=       feature_extractor.pad([{"input_features": inputs}]      ,						return_tensors="np"     )
									self.assertTrue(np_processed.input_features.dtype == np.floataa     )
									UpperCamelCase__					=       feature_extractor.pad([{"input_features": inputs}]      ,						return_tensors="pt"     )
									self.assertTrue(pt_processed.input_features.dtype == torch.floataa     )




			def 				snake_case__				(							self      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       load_dataset("hf-internal-testing/librispeech_asr_dummy"      ,						"clean"      ,						split="validation"     )
						# automatic decoding with librispeech
						UpperCamelCase__					=       ds.sort("id"     ).select(range(snake_case     )     )[:num_samples]["audio"]

						return [x["array"] for x in speech_samples]




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       torch.tensor(
						    [
						        0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
						        0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
						        0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
						        -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
						    ]     )
						# fmt: on

						UpperCamelCase__					=       self._load_datasamples(1     )
						UpperCamelCase__					=       WhisperFeatureExtractor()
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="pt"     ).input_features
						self.assertEqual(input_features.shape      ,						(1, 80, 3000)     )
						self.assertTrue(torch.allclose(input_features[0, 0, :30]      ,						snake_case      ,						atol=1E-4     )     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
						UpperCamelCase__					=       self._load_datasamples(1     )[0]
						UpperCamelCase__					=       ((audio - audio.min()) / (audio.max() - audio.min())) * 65535  # Rescale to [0, 65535] to show issue
						UpperCamelCase__					=       feat_extract.zero_mean_unit_var_norm([audio]      ,						attention_mask=snake_case     )[0]

						self.assertTrue(np.all(np.mean(snake_case     ) < 1E-3     )     )
						self.assertTrue(np.all(np.abs(np.var(snake_case     ) - 1     ) < 1E-3     )     )


