





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__							(	)   ->    Union[str, Any]:
  _lowercase						    =			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=snake_case__      ,				default=1      ,				help='Number of TPU cores to use (1 or 8).'  )

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

  return parser.parse_args()

def 				SCREAMING_SNAKE_CASE__							(	)   ->    int:
  _lowercase						    =			parse_args()

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

  # Patch sys.argv
  _lowercase						    =			[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'''






# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A__							:  int    ={
    '''configuration_xmod''': [
        '''XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XmodConfig''',
        '''XmodOnnxConfig''',
    ],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__							:  List[str]    =[
          '''XMOD_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''XmodForCausalLM''',
          '''XmodForMaskedLM''',
          '''XmodForMultipleChoice''',
          '''XmodForQuestionAnswering''',
          '''XmodForSequenceClassification''',
          '''XmodForTokenClassification''',
          '''XmodModel''',
          '''XmodPreTrainedModel''',
      ]

if TYPE_CHECKING:
      from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_xmod import (
                XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
                XmodForCausalLM,
                XmodForMaskedLM,
                XmodForMultipleChoice,
                XmodForQuestionAnswering,
                XmodForSequenceClassification,
                XmodForTokenClassification,
                XmodModel,
                XmodPreTrainedModel,
            )

else:
      import sys

      A__							:  str    =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






