






# 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__						(    UpperCamelCase_						):





					"""simple docstring"""






					a_     =		"microsoft/speecht5_tts"
					a_     =		(
					    "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_     =		"text_reader"
					a_     =		SpeechTaProcessor
					a_     =		SpeechTaForTextToSpeech
					a_     =		SpeechTaHifiGan

					a_     =		["text"]
					a_     =		["audio"]



					def 	_lowercase					( self					:  List[str]	):
						if self.post_processor is None:
							snake_case__			:				Optional[Any]       =  "microsoft/speecht5_hifigan"
						super().setup()



					def 	_lowercase					( self					:  Any							,		__A					:  Any							,		__A					:  List[str]=None	):
						snake_case__			:				Dict       =  self.pre_processor(text=__A							,		return_tensors="pt"							,		truncation=__A	)

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

							snake_case__			:				Union[str, Any]       =  load_dataset("Matthijs/cmu-arctic-xvectors"							,		split="validation"	)
							snake_case__			:				Optional[Any]       =  torch.tensor(embeddings_dataset[7_3_0_5]["xvector"]	).unsqueeze(0	)

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



					def 	_lowercase					( self					:  List[str]							,		__A					:  List[Any]	):
						with torch.no_grad():
							return self.model.generate_speech(**__A	)






					def 	_lowercase					( self					:  Optional[int]							,		__A					:  int	):
						with torch.no_grad():
							return self.post_processor(__A	).cpu().detach()











from __future__ import annotations







def 					SCREAMING_SNAKE_CASE    (			snake_case_ :							float					,  snake_case_ :							float					,  snake_case_ :							float       ):
	if days_between_payments <= 0:
		raise ValueError("days_between_payments must be > 0"       )
	if daily_interest_rate < 0:
		raise ValueError("daily_interest_rate must be >= 0"       )
	if principal <= 0:
		raise ValueError("principal must be > 0"       )
	return principal * daily_interest_rate * days_between_payments







def 					SCREAMING_SNAKE_CASE    (			snake_case_ :							float					,  snake_case_ :							float					,  snake_case_ :							float					,  ):
	if number_of_compounding_periods <= 0:
		raise ValueError("number_of_compounding_periods must be > 0"       )
	if nominal_annual_interest_rate_percentage < 0:
		raise ValueError("nominal_annual_interest_rate_percentage must be >= 0"       )
	if principal <= 0:
		raise ValueError("principal must be > 0"       )

	return principal * (
	    (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods
	    - 1
	)







def 					SCREAMING_SNAKE_CASE    (			snake_case_ :							float					,  snake_case_ :							float					,  snake_case_ :							float					,  ):
	if number_of_years <= 0:
		raise ValueError("number_of_years must be > 0"       )
	if nominal_annual_percentage_rate < 0:
		raise ValueError("nominal_annual_percentage_rate must be >= 0"       )
	if principal <= 0:
		raise ValueError("principal must be > 0"       )

	return compound_interest(
	    snake_case_					,  nominal_annual_percentage_rate / 365					,  number_of_years * 365       )


if __name__ == "__main__":
	import doctest

	doctest.testmod()



