
'''simple docstring'''


from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching



def  __snake_case     (    ):
   import os as original_os
   from os import path as original_path
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join

   UpperCamelCase       =  '''__test_patch_submodule_mock__'''
   with patch_submodule(_test_patching,      '''os.path.join''',      _UpperCAmelCase):
      # Every way to access os.path.join must be patched, and the rest must stay untouched

      # check os.path.join
      assert isinstance(_test_patching.os,      _PatchedModuleObj)
      assert isinstance(_test_patching.os.path,      _PatchedModuleObj)
      assert _test_patching.os.path.join is mock

      # check path.join
      assert isinstance(_test_patching.path,      _PatchedModuleObj)
      assert _test_patching.path.join is mock

      # check join
      assert _test_patching.join is mock

      # check that the other attributes are untouched
      assert _test_patching.os.rename is original_rename
      assert _test_patching.path.dirname is original_dirname
      assert _test_patching.os.path.dirname is original_dirname

      # Even renamed modules or objects must be patched

      # check renamed_os.path.join
      assert isinstance(_test_patching.renamed_os,      _PatchedModuleObj)
      assert isinstance(_test_patching.renamed_os.path,      _PatchedModuleObj)
      assert _test_patching.renamed_os.path.join is mock

      # check renamed_path.join
      assert isinstance(_test_patching.renamed_path,      _PatchedModuleObj)
      assert _test_patching.renamed_path.join is mock

      # check renamed_join
      assert _test_patching.renamed_join is mock

      # check that the other attributes are untouched
      assert _test_patching.renamed_os.rename is original_rename
      assert _test_patching.renamed_path.dirname is original_dirname
      assert _test_patching.renamed_os.path.dirname is original_dirname

   # check that everthing is back to normal when the patch is over

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join



def  __snake_case     (    ):
   assert _test_patching.open is open

   UpperCamelCase       =  '''__test_patch_submodule_builtin_mock__'''
   # _test_patching has "open" in its globals
   assert _test_patching.open is open
   with patch_submodule(_test_patching,      '''open''',      _UpperCAmelCase):
      assert _test_patching.open is mock

   # check that everthing is back to normal when the patch is over

   assert _test_patching.open is open



def  __snake_case     (    ):
   # pandas.read_csv is not present in _test_patching
   UpperCamelCase       =  '''__test_patch_submodule_missing_mock__'''
   with patch_submodule(_test_patching,      '''pandas.read_csv''',      _UpperCAmelCase):
      pass



def  __snake_case     (    ):
   # builtin should always be mocked even if they're not in the globals
   # in case they're loaded at one point
   UpperCamelCase       =  '''__test_patch_submodule_missing_builtin_mock__'''
   # _test_patching doesn't have "len" in its globals
   assert getattr(_test_patching,      '''len''',      _UpperCAmelCase) is None
   with patch_submodule(_test_patching,      '''len''',      _UpperCAmelCase):
      assert _test_patching.len is mock
   assert _test_patching.len is len



def  __snake_case     (    ):
   UpperCamelCase       =  '''__test_patch_submodule_start_and_stop_mock__'''
   UpperCamelCase       =  patch_submodule(_test_patching,      '''open''',      _UpperCAmelCase)
   assert _test_patching.open is open
   patch.start()
   assert _test_patching.open is mock
   patch.stop()
   assert _test_patching.open is open



def  __snake_case     (    ):
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   UpperCamelCase       =  '''__test_patch_submodule_successive_join__'''
   UpperCamelCase       =  '''__test_patch_submodule_successive_dirname__'''
   UpperCamelCase       =  '''__test_patch_submodule_successive_rename__'''
   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename

   with patch_submodule(_test_patching,      '''os.path.join''',      _UpperCAmelCase):
      with patch_submodule(_test_patching,      '''os.rename''',      _UpperCAmelCase):
         with patch_submodule(_test_patching,      '''os.path.dirname''',      _UpperCAmelCase):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

    # try another order
   with patch_submodule(_test_patching,      '''os.rename''',      _UpperCAmelCase):
      with patch_submodule(_test_patching,      '''os.path.join''',      _UpperCAmelCase):
         with patch_submodule(_test_patching,      '''os.path.dirname''',      _UpperCAmelCase):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename



def  __snake_case     (    ):
   UpperCamelCase       =  '''__test_patch_submodule_doesnt_exist_mock__'''
   with patch_submodule(_test_patching,      '''__module_that_doesn_exist__.__attribute_that_doesn_exist__''',      _UpperCAmelCase):
      pass
   with patch_submodule(_test_patching,      '''os.__attribute_that_doesn_exist__''',      _UpperCAmelCase):
      pass







'''simple docstring'''


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

import torch_xla.distributed.xla_multiprocessing as xmp



def  __snake_case     (    ):
   UpperCamelCase       =  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  __snake_case     (    ):
   UpperCamelCase       =  parse_args()

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

   # Patch sys.argv
   UpperCamelCase       =  [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()





