






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

import torch_xla.distributed.xla_multiprocessing as xmp







def 	_UpperCamelCase   (    )  ->   str:

						"""simple docstring"""



						lowerCAmelCase__    						=						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   (    )  ->   List[Any]:

						"""simple docstring"""



						lowerCAmelCase__    						=						parse_args()

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

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













from typing import TYPE_CHECKING

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


__snake_case    :    Dict         =     {"""configuration_speech_encoder_decoder""": ["""SpeechEncoderDecoderConfig"""]}

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

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__snake_case    :    str         =     ["""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

					__snake_case    :    Tuple         =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





