



"""simple docstring"""


import unittest

from transformers import load_tool
from transformers.utils import is_torch_available


if is_torch_available():
				import torch

from transformers.testing_utils import require_torch

from .test_tools_common import ToolTesterMixin







@require_torch
class 				A_      (					unittest.TestCase     ,       SCREAMING_SNAKE_CASE_    ):



						"""simple docstring"""






						def      UpperCAmelCase__					( self			:Dict )    ->      Any:
												UpperCAmelCase					=			load_tool('text-to-speech' )
												self.tool.setup()






						def      UpperCAmelCase__					( self			:List[str] )    ->      Tuple:
												# SpeechT5 isn't deterministic
												torch.manual_seed(0 )
												UpperCAmelCase					=			self.tool('hey' )
												UpperCAmelCase					=			result.to_raw()
												self.assertTrue(
												    torch.allclose(
												        resulting_tensor[:3]       ,  torch.tensor([-0.000_5966_6688_3211_5829, -0.000_3657_6401_9079_5064, -0.0001_3439_5027_9988_3485] )       ,  ) )






						def      UpperCAmelCase__					( self			:Optional[int] )    ->      Any:
												# SpeechT5 isn't deterministic
												torch.manual_seed(0 )
												UpperCAmelCase					=			self.tool('hey' )
												UpperCAmelCase					=			result.to_raw()
												self.assertTrue(
												    torch.allclose(
												        resulting_tensor[:3]       ,  torch.tensor([-0.000_5966_6688_3211_5829, -0.000_3657_6401_9079_5064, -0.0001_3439_5027_9988_3485] )       ,  ) )










"""simple docstring"""


import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp

def 			_lowerCAmelCase				(       ):
						UpperCAmelCase					=			ArgumentParser(
						    description=(
						        'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
						    )						)

						# Optional arguments for the launch helper
						parser.add_argument('--num_cores'		,     type=lowercase_		,     default=1		,     help='Number of TPU cores to use (1 or 8).'						)

						# positional
						parser.add_argument(
						    'training_script'		,     type=lowercase_		,     help=(
						        'The full path to the single TPU training '
						        'program/script to be launched in parallel, '
						        'followed by all the arguments for the '
						        'training script'
						    )		,     )

						# rest from the training program
						parser.add_argument('training_script_args'		,     nargs=lowercase_						)

						return parser.parse_args()

def 			_lowerCAmelCase				(       ):
						UpperCAmelCase					=			parse_args()

						# Import training_script as a module.
						UpperCAmelCase					=			Path(args.training_script						)
						sys.path.append(str(script_fpath.parent.resolve()						)						)
						UpperCAmelCase					=			script_fpath.stem
						UpperCAmelCase					=			importlib.import_module(lowercase_						)

						# Patch sys.argv
						UpperCAmelCase					=			[args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores						)]

						xmp.spawn(mod._mp_fn		,     args=()		,     nprocs=args.num_cores						)


if __name__ == "__main__":
				main()





