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

import torch_xla.distributed.xla_multiprocessing as xmp
def    __magic_name__(	)    ->     Tuple:



      '''simple docstring'''

      _lowerCamelCase           =					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    __magic_name__(	)    ->     Optional[Any]:



      '''simple docstring'''

      _lowerCamelCase           =					parse_args()

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

      # Patch sys.argv
      _lowerCamelCase           =					[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_tokenizers_available,
    is_torch_available,
)


snake_case__						      =			{
    'configuration_dpr': ['DPR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DPRConfig'],
    'tokenization_dpr': [
        'DPRContextEncoderTokenizer',
        'DPRQuestionEncoderTokenizer',
        'DPRReaderOutput',
        'DPRReaderTokenizer',
    ],
}


try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__						      =			[
         'DPRContextEncoderTokenizerFast',
         'DPRQuestionEncoderTokenizerFast',
         'DPRReaderTokenizerFast',
     ]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__						      =			[
         'DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'DPRContextEncoder',
         'DPRPretrainedContextEncoder',
         'DPRPreTrainedModel',
         'DPRPretrainedQuestionEncoder',
         'DPRPretrainedReader',
         'DPRQuestionEncoder',
         'DPRReader',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__						      =			[
         'TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TFDPRContextEncoder',
         'TFDPRPretrainedContextEncoder',
         'TFDPRPretrainedQuestionEncoder',
         'TFDPRPretrainedReader',
         'TFDPRQuestionEncoder',
         'TFDPRReader',
     ]


if TYPE_CHECKING:
     from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
     from .tokenization_dpr import (
         DPRContextEncoderTokenizer,
         DPRQuestionEncoderTokenizer,
         DPRReaderOutput,
         DPRReaderTokenizer,
     )

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_dpr_fast import (
              DPRContextEncoderTokenizerFast,
              DPRQuestionEncoderTokenizerFast,
              DPRReaderTokenizerFast,
          )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_dpr import (
              DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
              DPRContextEncoder,
              DPRPretrainedContextEncoder,
              DPRPreTrainedModel,
              DPRPretrainedQuestionEncoder,
              DPRPretrainedReader,
              DPRQuestionEncoder,
              DPRReader,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_dpr import (
              TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFDPRContextEncoder,
              TFDPRPretrainedContextEncoder,
              TFDPRPretrainedQuestionEncoder,
              TFDPRPretrainedReader,
              TFDPRQuestionEncoder,
              TFDPRReader,
          )

else:
     import sys

     snake_case__						      =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)