






import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow


@is_pipeline_test
@require_torch
class       __SCREAMING_SNAKE_CASE   (				unittest.TestCase):






						@require_torch
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  pipeline(
												    task='zero-shot-audio-classification'       ,  model='hf-internal-testing/tiny-clap-htsat-unfused'				)
												lowerCAmelCase__        =  load_dataset('ashraq/esc50'				)
												lowerCAmelCase__        =  dataset['train']['audio'][-1]['array']
												lowerCAmelCase__        =  audio_classifier(_UpperCamelCase       ,  candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']				)
												self.assertEqual(
												    nested_simplify(_UpperCamelCase				)       ,  [{'score': 0.5_01, 'label': 'Sound of a dog'}, {'score': 0.4_99, 'label': 'Sound of vaccum cleaner'}]       ,  )






						@unittest.skip('No models are available in TF'				)
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass






						@slow
						@require_torch
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  pipeline(
												    task='zero-shot-audio-classification'       ,  model='laion/clap-htsat-unfused'       ,  )
												# This is an audio of a dog
												lowerCAmelCase__        =  load_dataset('ashraq/esc50'				)
												lowerCAmelCase__        =  dataset['train']['audio'][-1]['array']
												lowerCAmelCase__        =  audio_classifier(_UpperCamelCase       ,  candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']				)

												self.assertEqual(
												    nested_simplify(_UpperCamelCase				)       ,  [
												        {'score': 0.9_99, 'label': 'Sound of a dog'},
												        {'score': 0.0_01, 'label': 'Sound of vaccum cleaner'},
												    ]       ,  )

												lowerCAmelCase__        =  audio_classifier([audio] * 5       ,  candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']				)
												self.assertEqual(
												    nested_simplify(_UpperCamelCase				)       ,  [
												        [
												            {'score': 0.9_99, 'label': 'Sound of a dog'},
												            {'score': 0.0_01, 'label': 'Sound of vaccum cleaner'},
												        ],
												    ]
												    * 5       ,  )
												lowerCAmelCase__        =  audio_classifier(
												    [audio] * 5       ,  candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']       ,  batch_size=5				)
												self.assertEqual(
												    nested_simplify(_UpperCamelCase				)       ,  [
												        [
												            {'score': 0.9_99, 'label': 'Sound of a dog'},
												            {'score': 0.0_01, 'label': 'Sound of vaccum cleaner'},
												        ],
												    ]
												    * 5       ,  )







						@unittest.skip('No models are available in TF'				)
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass













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

						_SCREAMING_SNAKE_CASE		:    Optional[int]						=   ['''text''']
						_SCREAMING_SNAKE_CASE		:    List[Any]						=   ['''audio''']






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												if self.post_processor is None:
																		lowerCAmelCase__        =  'microsoft/speecht5_hifigan'
												super().setup()






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase=None				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.pre_processor(text=_UpperCamelCase       ,  return_tensors='pt'       ,  truncation=_UpperCamelCase				)

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

																		lowerCAmelCase__        =  load_dataset('Matthijs/cmu-arctic-xvectors'       ,  split='validation'				)
																		lowerCAmelCase__        =  torch.tensor(embeddings_dataset[73_05]['xvector']				).unsqueeze(0				)

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






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												with torch.no_grad():
																		return self.model.generate_speech(**_UpperCamelCase				)







						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												with torch.no_grad():
																		return self.post_processor(_UpperCamelCase				).cpu().detach()





