



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

import torch_xla.distributed.xla_multiprocessing as xmp



def 		lowerCAmelCase__     (       )->	Dict:
    A__					=       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]:
    A__					=       parse_args()

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

    # Patch sys.argv
    A__					=       [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_torch_available


_lowercase    	=		{
    "configuration_upernet": ["UperNetConfig"],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _lowercase    	=		[
       "UperNetForSemanticSegmentation",
       "UperNetPreTrainedModel",
   ]


if TYPE_CHECKING:
   from .configuration_upernet import UperNetConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_upernet import UperNetForSemanticSegmentation, UperNetPreTrainedModel


else:
   import sys

   _lowercase    	=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
