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

import torch_xla.distributed.xla_multiprocessing as xmp



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

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

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





from typing import TYPE_CHECKING

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


A__       :   Union[str, Any]   						=					{"""configuration_cvt""": ["""CVT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CvtConfig"""]}


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__       :   Union[str, Any]   						=					[
							    """CVT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """CvtForImageClassification""",
							    """CvtModel""",
							    """CvtPreTrainedModel""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__       :   str   						=					[
							    """TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TFCvtForImageClassification""",
							    """TFCvtModel""",
							    """TFCvtPreTrainedModel""",
							]

if TYPE_CHECKING:
							from .configuration_cvt import CVT_PRETRAINED_CONFIG_ARCHIVE_MAP, CvtConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_cvt import (
														    CVT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    CvtForImageClassification,
														    CvtModel,
														    CvtPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_cvt import (
														    TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFCvtForImageClassification,
														    TFCvtModel,
														    TFCvtPreTrainedModel,
														)


else:
							import sys

							A__       :   Optional[Any]   						=					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



