


'''simple docstring'''
import pytest

from datasets.splits import SplitDict, SplitInfo
from datasets.utils.py_utils import asdict


@pytest.mark.parametrize(
    'split_dict',					[
        SplitDict(),
        SplitDict({'train': SplitInfo(name='train',					num_bytes=1337,					num_examples=42,					dataset_name='my_dataset'      )}      ),
        SplitDict({'train': SplitInfo(name='train',					num_bytes=1337,					num_examples=42      )}      ),
        SplitDict({'train': SplitInfo()}      ),
    ],					)
def       _lowercase							(					UpperCamelCase__							:       SplitDict      ):
 __A	:		Any	  =      split_dict._to_yaml_list()
 assert len(UpperCamelCase__      ) == len(UpperCamelCase__      )
 __A	:		Union[str, Any]	  =      SplitDict._from_yaml_list(UpperCamelCase__      )
 for split_name, split_info in split_dict.items():
  # dataset_name field is deprecated, and is therefore not part of the YAML dump
  __A	:		Union[str, Any]	  =      None
  # the split name of split_dict takes over the name of the split info object
  __A	:		Optional[Any]	  =      split_name
 assert split_dict == reloaded


@pytest.mark.parametrize(
    'split_info',					[SplitInfo(), SplitInfo(dataset_name=UpperCamelCase__      ), SplitInfo(dataset_name='my_dataset'      )]      )
def       _lowercase							(					UpperCamelCase__							:       Any      ):
 # For backward compatibility, we need asdict(split_dict) to return split info dictrionaries with the "dataset_name"
 # field even if it's deprecated. This way old versionso of `datasets` can still reload dataset_infos.json files
 __A	:		List[str]	  =      asdict(SplitDict({'train': split_info}      )      )
 assert "dataset_name" in split_dict_asdict["train"]
 assert split_dict_asdict["train"]["dataset_name"] == split_info.dataset_name










'''simple docstring'''
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp


def       _lowercase							(					):
 __A	:		List[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=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       _lowercase							(					):
 __A	:		str	  =      parse_args()

 # Import training_script as a module.
 __A	:		Tuple	  =      Path(args.training_script      )
 sys.path.append(str(script_fpath.parent.resolve()      )      )
 __A	:		str	  =      script_fpath.stem
 __A	:		Dict	  =      importlib.import_module(UpperCamelCase__      )

 # Patch sys.argv
 __A	:		Optional[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()






