code: 
  
  
  
  
  
  import importlib
  import os
  import platform
  from pathlib import Path
  
  from packaging import version
  
  from .utils.logging import get_logger
  
  
  UpperCAmelCase			:			Dict	  = get_logger(__name__)
  
  # Datasets
  UpperCAmelCase			:			Optional[Any]	  = "https://s3.amazonaws.com/datasets.huggingface.co/datasets/datasets"
  UpperCAmelCase			:			Optional[int]	  = "https://cdn-datasets.huggingface.co/datasets/datasets"
  UpperCAmelCase			:			Tuple	  = "https://raw.githubusercontent.com/huggingface/datasets/{revision}/datasets/{path}/{name}"
  
  # Metrics
  UpperCAmelCase			:			Any	  = "https://s3.amazonaws.com/datasets.huggingface.co/datasets/metrics"
  UpperCAmelCase			:			Any	  = "https://cdn-datasets.huggingface.co/datasets/metric"
  UpperCAmelCase			:			List[Any]	  = "https://raw.githubusercontent.com/huggingface/datasets/{revision}/metrics/{path}/{name}"
  
  # Hub
  UpperCAmelCase			:			Any	  = os.environ.get("""HF_ENDPOINT""", """https://huggingface.co""")
  UpperCAmelCase			:			Any	  = HF_ENDPOINT + "/datasets/{repo_id}/resolve/{revision}/{path}"
  UpperCAmelCase			:			List[str]	  = "main"
  
  UpperCAmelCase			:			Optional[Any]	  = version.parse(platform.python_version())
  
  if PY_VERSION < version.parse("""3.8"""):
         import importlib_metadata
  else:
         import importlib.metadata as importlib_metadata
  
  # General environment variables accepted values for booleans
  UpperCAmelCase			:			Dict	  = {"1", "ON", "YES", "TRUE"}
  UpperCAmelCase			:			Dict	  = ENV_VARS_TRUE_VALUES.union({"""AUTO"""})
  
  
  # Imports
  UpperCAmelCase			:			Union[str, Any]	  = version.parse(importlib_metadata.version("""dill"""))
  UpperCAmelCase			:			List[str]	  = version.parse(importlib_metadata.version("""pandas"""))
  UpperCAmelCase			:			str	  = version.parse(importlib_metadata.version("""pyarrow"""))
  
  UpperCAmelCase			:			Tuple	  = os.environ.get("""USE_TF""", """AUTO""").upper()
  UpperCAmelCase			:			Optional[Any]	  = os.environ.get("""USE_TORCH""", """AUTO""").upper()
  UpperCAmelCase			:			Any	  = os.environ.get("""USE_JAX""", """AUTO""").upper()
  
  UpperCAmelCase			:			int	  = "N/A"
  UpperCAmelCase			:			Union[str, Any]	  = False
  
  if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES:
         UpperCAmelCase			:			str	  = importlib.util.find_spec("""torch""") is not None
         if TORCH_AVAILABLE:
                try:
                       UpperCAmelCase			:			Dict	  = version.parse(importlib_metadata.version("""torch"""))
                       logger.info(F"""PyTorch version {TORCH_VERSION} available.""")
                except importlib_metadata.PackageNotFoundError:
                       pass
  else:
         logger.info("""Disabling PyTorch because USE_TF is set""")
  
  UpperCAmelCase			:			Optional[int]	  = "N/A"
  UpperCAmelCase			:			Any	  = False
  
  if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES:
         UpperCAmelCase			:			Optional[Any]	  = importlib.util.find_spec("""tensorflow""") is not None
         if TF_AVAILABLE:
                # For the metadata, we have to look for both tensorflow and tensorflow-cpu
                for package in [
                    "tensorflow",
                    "tensorflow-cpu",
                    "tensorflow-gpu",
                    "tf-nightly",
                    "tf-nightly-cpu",
                    "tf-nightly-gpu",
                    "intel-tensorflow",
                    "tensorflow-rocm",
                    "tensorflow-macos",
                ]:
                       try:
                              UpperCAmelCase			:			Optional[Any]	  = version.parse(importlib_metadata.version(package))
                       except importlib_metadata.PackageNotFoundError:
                              continue
                       else:
                              break
                else:
                       UpperCAmelCase			:			int	  = False
         if TF_AVAILABLE:
                if TF_VERSION.major < 2:
                       logger.info(F"""TensorFlow found but with version {TF_VERSION}. `datasets` requires version 2 minimum.""")
                       UpperCAmelCase			:			Any	  = False
                else:
                       logger.info(F"""TensorFlow version {TF_VERSION} available.""")
  else:
         logger.info("""Disabling Tensorflow because USE_TORCH is set""")
  
  
  UpperCAmelCase			:			int	  = "N/A"
  UpperCAmelCase			:			Optional[Any]	  = False
  
  if USE_JAX in ENV_VARS_TRUE_AND_AUTO_VALUES:
         UpperCAmelCase			:			List[Any]	  = importlib.util.find_spec("""jax""") is not None and importlib.util.find_spec("""jaxlib""") is not None
         if JAX_AVAILABLE:
                try:
                       UpperCAmelCase			:			Optional[Any]	  = version.parse(importlib_metadata.version("""jax"""))
                       logger.info(F"""JAX version {JAX_VERSION} available.""")
                except importlib_metadata.PackageNotFoundError:
                       pass
  else:
         logger.info("""Disabling JAX because USE_JAX is set to False""")
  
  
  UpperCAmelCase			:			int	  = os.environ.get("""USE_BEAM""", """AUTO""").upper()
  UpperCAmelCase			:			List[str]	  = "N/A"
  UpperCAmelCase			:			List[Any]	  = False
  if USE_BEAM in ENV_VARS_TRUE_AND_AUTO_VALUES:
         try:
                UpperCAmelCase			:			Dict	  = version.parse(importlib_metadata.version("""apache_beam"""))
                UpperCAmelCase			:			Optional[Any]	  = True
                logger.info(F"""Apache Beam version {BEAM_VERSION} available.""")
         except importlib_metadata.PackageNotFoundError:
                pass
  else:
         logger.info("""Disabling Apache Beam because USE_BEAM is set to False""")
  
  
  # Optional tools for data loading
  UpperCAmelCase			:			List[str]	  = importlib.util.find_spec("""sqlalchemy""") is not None
  
  # Optional tools for feature decoding
  UpperCAmelCase			:			int	  = importlib.util.find_spec("""PIL""") is not None
  UpperCAmelCase			:			Any	  = importlib.util.find_spec("""soundfile""") is not None and version.parse(
      importlib.import_module("""soundfile""").__libsndfile_version__
  ) >= version.parse("""1.0.31""")
  UpperCAmelCase			:			Tuple	  = importlib.util.find_spec("""soundfile""") is not None and version.parse(
      importlib.import_module("""soundfile""").__libsndfile_version__
  ) >= version.parse("""1.1.0""")
  
  # Optional compression tools
  UpperCAmelCase			:			Dict	  = importlib.util.find_spec("""rarfile""") is not None
  UpperCAmelCase			:			Dict	  = importlib.util.find_spec("""zstandard""") is not None
  UpperCAmelCase			:			Optional[Any]	  = importlib.util.find_spec("""lz4""") is not None
  UpperCAmelCase			:			Optional[Any]	  = importlib.util.find_spec("""py7zr""") is not None
  
  
  # Cache location
  UpperCAmelCase			:			str	  = "~/.cache"
  UpperCAmelCase			:			List[Any]	  = os.getenv("""XDG_CACHE_HOME""", DEFAULT_XDG_CACHE_HOME)
  UpperCAmelCase			:			Tuple	  = os.path.join(XDG_CACHE_HOME, """huggingface""")
  UpperCAmelCase			:			Any	  = os.path.expanduser(os.getenv("""HF_HOME""", DEFAULT_HF_CACHE_HOME))
  
  UpperCAmelCase			:			str	  = os.path.join(HF_CACHE_HOME, """datasets""")
  UpperCAmelCase			:			str	  = Path(os.getenv("""HF_DATASETS_CACHE""", DEFAULT_HF_DATASETS_CACHE))
  
  UpperCAmelCase			:			Union[str, Any]	  = os.path.join(HF_CACHE_HOME, """metrics""")
  UpperCAmelCase			:			Optional[int]	  = Path(os.getenv("""HF_METRICS_CACHE""", DEFAULT_HF_METRICS_CACHE))
  
  UpperCAmelCase			:			Dict	  = os.path.join(HF_CACHE_HOME, """modules""")
  UpperCAmelCase			:			List[str]	  = Path(os.getenv("""HF_MODULES_CACHE""", DEFAULT_HF_MODULES_CACHE))
  
  UpperCAmelCase			:			Any	  = "downloads"
  UpperCAmelCase			:			Optional[Any]	  = os.path.join(HF_DATASETS_CACHE, DOWNLOADED_DATASETS_DIR)
  UpperCAmelCase			:			Dict	  = Path(os.getenv("""HF_DATASETS_DOWNLOADED_DATASETS_PATH""", DEFAULT_DOWNLOADED_DATASETS_PATH))
  
  UpperCAmelCase			:			Optional[Any]	  = "extracted"
  UpperCAmelCase			:			Optional[Any]	  = os.path.join(DEFAULT_DOWNLOADED_DATASETS_PATH, EXTRACTED_DATASETS_DIR)
  UpperCAmelCase			:			List[Any]	  = Path(os.getenv("""HF_DATASETS_EXTRACTED_DATASETS_PATH""", DEFAULT_EXTRACTED_DATASETS_PATH))
  
  # Download count for the website
  UpperCAmelCase			:			Optional[Any]	  = (
      os.environ.get("""HF_UPDATE_DOWNLOAD_COUNTS""", """AUTO""").upper() in ENV_VARS_TRUE_AND_AUTO_VALUES
  )
  
  # Batch size constants. For more info, see:
  # https://github.com/apache/arrow/blob/master/docs/source/cpp/arrays.rst#size-limitations-and-recommendations)
  UpperCAmelCase			:			List[Any]	  = 1000
  
  # Size of the preloaded record batch in `Dataset.__iter__`
  UpperCAmelCase			:			List[str]	  = 10
  
  # Pickling tables works only for small tables (<4GiB)
  # For big tables, we write them on disk instead
  UpperCAmelCase			:			int	  = 4 << 30
  
  # Max shard size in bytes (e.g. to shard parquet datasets in push_to_hub or download_and_prepare)
  UpperCAmelCase			:			Union[str, Any]	  = "500MB"
  
  # Parquet configuration
  UpperCAmelCase			:			Optional[Any]	  = 100
  UpperCAmelCase			:			int	  = 100
  UpperCAmelCase			:			List[Any]	  = 100
  
  # Offline mode
  UpperCAmelCase			:			str	  = os.environ.get("""HF_DATASETS_OFFLINE""", """AUTO""").upper() in ENV_VARS_TRUE_VALUES
  
  # In-memory
  UpperCAmelCase			:			Any	  = 0  # Disabled
  UpperCAmelCase			:			Optional[int]	  = float(os.environ.get("""HF_DATASETS_IN_MEMORY_MAX_SIZE""", DEFAULT_IN_MEMORY_MAX_SIZE))
  
  # File names
  UpperCAmelCase			:			List[Any]	  = "dataset.arrow"
  UpperCAmelCase			:			str	  = "indices.arrow"
  UpperCAmelCase			:			str	  = "state.json"
  UpperCAmelCase			:			str	  = "dataset_info.json"
  UpperCAmelCase			:			Any	  = "dataset_infos.json"
  UpperCAmelCase			:			Any	  = "LICENSE"
  UpperCAmelCase			:			Optional[Any]	  = "metric_info.json"
  UpperCAmelCase			:			int	  = "dataset_dict.json"
  
  UpperCAmelCase			:			Optional[int]	  = "datasets_modules"
  
  UpperCAmelCase			:			Tuple	  = 255
  
  # Streaming
  UpperCAmelCase			:			List[Any]	  = 20
  UpperCAmelCase			:			Dict	  = 5
  
  # Datasets without script
  UpperCAmelCase			:			str	  = 200
  UpperCAmelCase			:			Optional[Any]	  = 10
  UpperCAmelCase			:			Optional[int]	  = 200
  
  # Progress bars
  UpperCAmelCase			:			Union[str, Any]	  = 0.0_5  # 20 progress updates per sec
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import importlib
  import sys
  from argparse import REMAINDER, ArgumentParser
  from pathlib import Path
  
  import torch_xla.distributed.xla_multiprocessing as xmp
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[int]            =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=SCREAMING_SNAKE_CASE , default=1 , help="Number of TPU cores to use (1 or 8)."		)
  
    # positional
    parser.add_argument(
        "training_script" , type=SCREAMING_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=SCREAMING_SNAKE_CASE		)
  
    return parser.parse_args()
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[Any]            =parse_args()
  
    # Import training_script as a module.
    a__			:      Tuple            =Path(args.training_script		)
    sys.path.append(str(script_fpath.parent.resolve()		)		)
    a__			:      Tuple            =script_fpath.stem
    a__			:      Any            =importlib.import_module(SCREAMING_SNAKE_CASE		)
  
    # Patch sys.argv
    a__			:      List[str]            =[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()
  
  
  
  
  
  
  