"""simple docstring"""







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

import torch_xla.distributed.xla_multiprocessing as xmp
def 						__UpperCAmelCase       (					)							->    Union[str, Any]:

	'''simple docstring'''





	__snake_case    :							Union[str, Any]   	=				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=UpperCAmelCase_    ,							default=1    ,							help='Number of TPU cores to use (1 or 8).'						)

	# positional
	parser.add_argument(
	    'training_script'    ,							type=UpperCAmelCase_    ,							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=UpperCAmelCase_						)

	return parser.parse_args()
def 						__UpperCAmelCase       (					)							->    Union[str, Any]:

	'''simple docstring'''





	__snake_case    :							Optional[Any]   	=				parse_args()

	# Import training_script as a module.
	__snake_case    :							List[Any]   	=				Path(args.training_script						)
	sys.path.append(str(script_fpath.parent.resolve()						)						)
	__snake_case    :							int   	=				script_fpath.stem
	__snake_case    :							int   	=				importlib.import_module(UpperCAmelCase_						)

	# Patch sys.argv
	__snake_case    :							int   	=				[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()






"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available


_a  :  Any=				{"configuration_speech_encoder_decoder": ["SpeechEncoderDecoderConfig"]}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_a  :  Union[str, Any]=				["SpeechEncoderDecoderModel"]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_a  :  Tuple=				["FlaxSpeechEncoderDecoderModel"]

if TYPE_CHECKING:
	from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
	import sys

	_a  :  str=				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





