




from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase__					:  Optional[Any]      							=				{
    'configuration_autoformer': [
        'AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'AutoformerConfig',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__					:  List[str]      							=				[
       'AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'AutoformerForPrediction',
       'AutoformerModel',
       'AutoformerPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_autoformer import (
       AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       AutoformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_autoformer import (
          AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          AutoformerForPrediction,
          AutoformerModel,
          AutoformerPreTrainedModel,
      )

else:
   import sys

   lowerCamelCase__					:  Optional[int]      							=				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


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

import torch_xla.distributed.xla_multiprocessing as xmp
def 							__SCREAMING_SNAKE_CASE     (   )					->				Tuple:
	__A :			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=a__			,default=1			,help="""Number of TPU cores to use (1 or 8)."""       )

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

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

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

	# Patch sys.argv
	__A :			List[str]		    =			[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()





