

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

import torch_xla.distributed.xla_multiprocessing as xmp






def        __lowercase   (  )  ->    List[str]:
      SCREAMING_SNAKE_CASE			:   Union[str, 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        __lowercase   (  )  ->    Dict:
      SCREAMING_SNAKE_CASE			:   List[str]	  = parse_args()

      # Import training_script as a module.
      SCREAMING_SNAKE_CASE			:   Tuple	  = Path(args.training_script      )
      sys.path.append(str(script_fpath.parent.resolve()      )      )
      SCREAMING_SNAKE_CASE			:   Optional[int]	  = script_fpath.stem
      SCREAMING_SNAKE_CASE			:   Union[str, Any]	  = importlib.import_module(_A      )

      # Patch sys.argv
      SCREAMING_SNAKE_CASE			:   List[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_sentencepiece_available,
    is_speech_available,
    is_torch_available,
)


UpperCAmelCase__			:  Tuple					     =     {
    """configuration_speech_to_text_2""": ["""SPEECH_TO_TEXT_2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """Speech2Text2Config"""],
    """processing_speech_to_text_2""": ["""Speech2Text2Processor"""],
    """tokenization_speech_to_text_2""": ["""Speech2Text2Tokenizer"""],
}


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__			:  Tuple					     =     [
      """SPEECH_TO_TEXT_2_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """Speech2Text2ForCausalLM""",
      """Speech2Text2PreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_speech_to_text_a import SPEECH_TO_TEXT_2_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextaConfig
  from .processing_speech_to_text_a import SpeechaTextaProcessor
  from .tokenization_speech_to_text_a import SpeechaTextaTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_speech_to_text_a import (
        SPEECH_TO_TEXT_2_PRETRAINED_MODEL_ARCHIVE_LIST,
        SpeechaTextaForCausalLM,
        SpeechaTextaPreTrainedModel,
    )

else:
  import sys

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




