





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

import torch_xla.distributed.xla_multiprocessing as xmp






def 	lowerCamelCase_		(							)						->		Optional[int]:






				"""simple docstring"""


				snake_case_		:       Dict           =    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 	lowerCamelCase_		(							)						->		Union[str, Any]:






				"""simple docstring"""


				snake_case_		:       Dict           =    parse_args()

				# Import training_script as a module.
				snake_case_		:       str           =    Path(args.training_script					)
				sys.path.append(str(script_fpath.parent.resolve()					)					)
				snake_case_		:       str           =    script_fpath.stem
				snake_case_		:       Optional[int]           =    importlib.import_module(_UpperCamelCase					)

				# Patch sys.argv
				snake_case_		:       Any           =    [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_tf_available, is_torch_available


snake_case_					:      Union[str, Any]    			=    {
    'configuration_transfo_xl': ['TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TransfoXLConfig'],
    'tokenization_transfo_xl': ['TransfoXLCorpus', 'TransfoXLTokenizer'],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_					:      str    			=    [
					    'TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'AdaptiveEmbedding',
					    'TransfoXLForSequenceClassification',
					    'TransfoXLLMHeadModel',
					    'TransfoXLModel',
					    'TransfoXLPreTrainedModel',
					    'load_tf_weights_in_transfo_xl',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_					:      Any    			=    [
					    'TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFAdaptiveEmbedding',
					    'TFTransfoXLForSequenceClassification',
					    'TFTransfoXLLMHeadModel',
					    'TFTransfoXLMainLayer',
					    'TFTransfoXLModel',
					    'TFTransfoXLPreTrainedModel',
					]


if TYPE_CHECKING:
					from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
					from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_transfo_xl import (
										    TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    AdaptiveEmbedding,
										    TransfoXLForSequenceClassification,
										    TransfoXLLMHeadModel,
										    TransfoXLModel,
										    TransfoXLPreTrainedModel,
										    load_tf_weights_in_transfo_xl,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_transfo_xl import (
										    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFAdaptiveEmbedding,
										    TFTransfoXLForSequenceClassification,
										    TFTransfoXLLMHeadModel,
										    TFTransfoXLMainLayer,
										    TFTransfoXLModel,
										    TFTransfoXLPreTrainedModel,
										)

else:
					import sys

					snake_case_					:      Dict    			=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


