






from math import pow


def 							_a	(  UpperCamelCase_       :					Union[str, Any]     , UpperCamelCase_       :					List[Any]     , UpperCamelCase_       :					int     , UpperCamelCase_       :					Any     , UpperCamelCase_       :					Tuple     , )			-> Any:
						"""simple docstring"""







						if current_sum == needed_sum:
												# If the sum of the powers is equal to needed_sum, then we have a solution.
												solutions_count += 1
												return current_sum, solutions_count

						lowerCAmelCase__			   =    int(pow(A__     , A__ ) )
						if current_sum + i_to_n <= needed_sum:
												# If the sum of the powers is less than needed_sum, then continue adding powers.
												current_sum += i_to_n
												lowerCAmelCase__			   =    backtrack(
												    A__     , A__     , current_number + 1     , A__     , A__ )
												current_sum -= i_to_n
						if i_to_n < needed_sum:
												# If the power of i is less than needed_sum, then try with the next power.
												lowerCAmelCase__			   =    backtrack(
												    A__     , A__     , current_number + 1     , A__     , A__ )
						return current_sum, solutions_count


def 							_a	(  UpperCamelCase_       :					int     , UpperCamelCase_       :					Any )			-> Union[str, Any]:
						"""simple docstring"""







						if not (1 <= needed_sum <= 1_000 and 2 <= power <= 10):
												raise ValueError(
												    "Invalid input\n"
												    "needed_sum must be between 1 and 1000, power between 2 and 10." )

						return backtrack(A__     , A__     , 1     , 0     , 0 )[1]  # Return the solutions_count


if __name__ == "__main__":
	import doctest

	doctest.testmod()










# 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 	__lowercase    (__SCREAMING_SNAKE_CASE  ):





							"""simple docstring"""







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

							_UpperCAmelCase      =						["""text"""]
							_UpperCAmelCase      =						["""audio"""]






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										if self.post_processor is None:
													SCREAMING_SNAKE_CASE_		:     List[Any]					=					'microsoft/speecht5_hifigan'
										super().setup()






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





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     int					=					self.pre_processor(text=lowerCAmelCase__			,						return_tensors='pt'			,						truncation=lowerCAmelCase__       )

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

													SCREAMING_SNAKE_CASE_		:     List[Any]					=					load_dataset('Matthijs/cmu-arctic-xvectors'			,						split='validation'       )
													SCREAMING_SNAKE_CASE_		:     Optional[int]					=					torch.tensor(embeddings_dataset[7_3_0_5]['xvector']       ).unsqueeze(0       )

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






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




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






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




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





