


"""simple docstring"""


from pathlib import Path

import torch

from ...utils import is_npu_available, is_xpu_available
from .config_args import ClusterConfig, default_json_config_file
from .config_utils import SubcommandHelpFormatter


a_       							=    "Create a default config file for Accelerate with only a few flags set."






def      a__ (				__lowercase="no"     ,			__lowercase = default_json_config_file     ,			__lowercase = False   )	->	Any:
				_A					  =			Path(__lowercase   )
				path.parent.mkdir(parents=__lowercase     ,			exist_ok=__lowercase   )
				if path.exists():
								print(
								    f"""Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`."""   )
								return False
				_A					  =			mixed_precision.lower()
				if mixed_precision not in ["no", "fp16", "bf16", "fp8"]:
								raise ValueError(
								    f"""`mixed_precision` should be one of 'no', 'fp16', 'bf16', or 'fp8'. Received {mixed_precision}"""   )
				_A					  =			{
				    "compute_environment": "LOCAL_MACHINE",
				    "mixed_precision": mixed_precision,
				}
				if torch.cuda.is_available():
								_A					  =			torch.cuda.device_count()
								_A					  =			num_gpus
								_A					  =			False
								if num_gpus > 1:
												_A					  =			"MULTI_GPU"
								else:
												_A					  =			"NO"
				elif is_xpu_available() and use_xpu:
								_A					  =			torch.xpu.device_count()
								_A					  =			num_xpus
								_A					  =			False
								if num_xpus > 1:
												_A					  =			"MULTI_XPU"
								else:
												_A					  =			"NO"
				elif is_npu_available():
								_A					  =			torch.npu.device_count()
								_A					  =			num_npus
								_A					  =			False
								if num_npus > 1:
												_A					  =			"MULTI_NPU"
								else:
												_A					  =			"NO"
				else:
								_A					  =			0
								_A					  =			True
								_A					  =			1
								_A					  =			"NO"
				_A					  =			ClusterConfig(**__lowercase   )
				config.to_json_file(__lowercase   )
				return path






def      a__ (				__lowercase     ,			__lowercase   )	->	Dict:
				_A					  =			parser.add_parser("default"     ,			parents=__lowercase     ,			help=__lowercase     ,			formatter_class=__lowercase   )
				parser.add_argument(
				    "--config_file"     ,			default=__lowercase     ,			help=(
				        "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
				        "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
				        "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
				        "with 'huggingface'."
				    )     ,			dest="save_location"     ,			)

				parser.add_argument(
				    "--mixed_precision"     ,			choices=["no", "fp16", "bf16"]     ,			type=__lowercase     ,			help="Whether or not to use mixed precision training. "
				    "Choose between FP16 and BF16 (bfloat16) training. "
				    "BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later."     ,			default="no"     ,			)
				parser.set_defaults(func=__lowercase   )
				return parser






def      a__ (				__lowercase   )	->	Any:
				_A					  =			write_basic_config(args.mixed_precision     ,			args.save_location   )
				if config_file:
								print(f"""accelerate configuration saved at {config_file}"""   )






"""simple docstring"""


import random
import unittest

from torch.utils.data import BatchSampler, DataLoader, IterableDataset

from accelerate import Accelerator
from accelerate.data_loader import (
    BatchSamplerShard,
    DataLoaderDispatcher,
    DataLoaderShard,
    IterableDatasetShard,
    SkipBatchSampler,
    SkipDataLoader,
    skip_first_batches,
)
class snake_case      (  _UpperCamelCase):







		def __init__(					self      :       Optional[int]    ,   a__      :       str=0.0_1    ,   a__      :       str=10_00		)       ->						int:





						'''simple docstring'''







						_A					  =			p_stop
						_A					  =			max_length







		def __iter__(					self      :       Any		)       ->						Optional[Any]:





						'''simple docstring'''







						_A					  =			0
						_A					  =			False
						while not stop and count < self.max_length:
										yield count
										count += 1
										_A					  =			random.random() < self.p_stop





class snake_case      (  unittest.TestCase):







		def  a_ (					self      :       List[Any]    ,   a__      :       Union[str, Any]    ,   a__      :       Union[str, Any]    ,   a__      :       List[str]=False    ,   a__      :       str=True		)       ->						Union[str, Any]:





						'''simple docstring'''







						_A					  =			[
						    BatchSamplerShard(a__    ,   2    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)
						    for i in range(2		)
						]
						_A					  =			[list(a__		) for batch_sampler_shard in batch_sampler_shards]
						if not split_batches:
										self.assertListEqual([len(a__		) for shard in batch_sampler_shards]    ,   [len(a__		) for e in expected]		)
						self.assertListEqual(a__    ,   a__		)







		def  a_ (					self      :       List[Any]		)       ->						str:





						'''simple docstring'''







						_A					  =			BatchSampler(range(24		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
						]
						self.check_batch_sampler_shards(a__    ,   a__		)

						_A					  =			BatchSampler(range(24		)    ,   batch_size=3    ,   drop_last=a__		)
						# Expected shouldn't change
						self.check_batch_sampler_shards(a__    ,   a__		)

						# Check the shards when the dataset is a round multiple of batch size but not total batch size.
						_A					  =			BatchSampler(range(21		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [0, 1, 2]],
						]
						self.check_batch_sampler_shards(a__    ,   a__		)

						_A					  =			BatchSampler(range(21		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__		)

						# Check the shards when the dataset is not a round multiple of batch size but has a multiple of
						# num_processes batch.
						_A					  =			BatchSampler(range(22		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 0, 1]],
						]
						self.check_batch_sampler_shards(a__    ,   a__		)

						_A					  =			BatchSampler(range(22		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__		)

						# Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
						# num_processes batch.
						_A					  =			BatchSampler(range(20		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 0]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [1, 2, 3]],
						]
						self.check_batch_sampler_shards(a__    ,   a__		)

						_A					  =			BatchSampler(range(20		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__		)

						# Check the shards when the dataset is very small.
						_A					  =			BatchSampler(range(2		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[[[0, 1, 0]], [[1, 0, 1]]]
						self.check_batch_sampler_shards(a__    ,   a__		)

						_A					  =			BatchSampler(range(2		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[[], []]
						self.check_batch_sampler_shards(a__    ,   a__		)







		def  a_ (					self      :       int		)       ->						int:





						'''simple docstring'''







						_A					  =			BatchSampler(range(24		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)

						_A					  =			BatchSampler(range(24		)    ,   batch_size=4    ,   drop_last=a__		)
						# Expected shouldn't change
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)

						# Check the shards when the dataset is not a round multiple of batch size.
						_A					  =			BatchSampler(range(22		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [0, 1]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)

						_A					  =			BatchSampler(range(22		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)

						# Check the shards when the dataset is not a round multiple of batch size or num_processes.
						_A					  =			BatchSampler(range(21		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 0]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [1, 2]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)

						_A					  =			BatchSampler(range(21		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)

						# Check the shards when the dataset is very small.
						_A					  =			BatchSampler(range(2		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[[[0, 1]], [[0, 1]]]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)

						_A					  =			BatchSampler(range(2		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[[], []]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__		)







		def  a_ (					self      :       List[str]		)       ->						List[str]:





						'''simple docstring'''







						_A					  =			BatchSampler(range(24		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(24		)    ,   batch_size=3    ,   drop_last=a__		)
						# Expected shouldn't change
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						# Check the shards when the dataset is a round multiple of batch size but not total batch size.
						_A					  =			BatchSampler(range(21		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(21		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						# Check the shards when the dataset is not a round multiple of batch size but has a multiple of
						# num_processes batch.
						_A					  =			BatchSampler(range(22		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(22		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						# Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
						# num_processes batch.
						_A					  =			BatchSampler(range(20		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(20		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
						    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						# Check the shards when the dataset is very small.
						_A					  =			BatchSampler(range(2		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[[[0, 1]], []]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(2		)    ,   batch_size=3    ,   drop_last=a__		)
						_A					  =			[[], []]
						self.check_batch_sampler_shards(a__    ,   a__    ,   even_batches=a__		)







		def  a_ (					self      :       List[str]		)       ->						str:





						'''simple docstring'''







						_A					  =			BatchSampler(range(24		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(24		)    ,   batch_size=4    ,   drop_last=a__		)
						# Expected shouldn't change
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)

						# Check the shards when the dataset is not a round multiple of batch size.
						_A					  =			BatchSampler(range(22		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(22		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)

						# Check the shards when the dataset is not a round multiple of batch size or num_processes.
						_A					  =			BatchSampler(range(21		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(21		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[
						    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
						    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
						]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)

						# Check the shards when the dataset is very small.
						_A					  =			BatchSampler(range(2		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[[[0, 1]], []]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)

						_A					  =			BatchSampler(range(2		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			[[], []]
						self.check_batch_sampler_shards(a__    ,   a__    ,   split_batches=a__    ,   even_batches=a__		)







		def  a_ (					self      :       Union[str, Any]		)       ->						str:





						'''simple docstring'''







						_A					  =			[[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
						_A					  =			[BatchSamplerShard(a__    ,   2    ,   a__    ,   even_batches=a__		) for i in range(2		)]

						self.assertEqual(len(batch_sampler_shards[0]		)    ,   3		)
						self.assertEqual(len(batch_sampler_shards[1]		)    ,   2		)

						self.assertListEqual(list(batch_sampler_shards[0]		)    ,   [[0, 1, 2], [5, 6, 7, 8], [12, 13]]		)
						self.assertListEqual(list(batch_sampler_shards[1]		)    ,   [[3, 4], [9, 10, 11]]		)







		def  a_ (					self      :       Optional[int]    ,   a__      :       Optional[int]    ,   a__      :       Tuple    ,   a__      :       Optional[int]    ,   a__      :       Union[str, Any]=False    ,   a__      :       int=2    ,   a__      :       List[Any]=False		)       ->						str:





						'''simple docstring'''







						random.seed(a__		)
						_A					  =			list(a__		)

						_A					  =			[
						    IterableDatasetShard(
						        a__    ,   batch_size=a__    ,   drop_last=a__    ,   num_processes=a__    ,   process_index=a__    ,   split_batches=a__    ,   )
						    for i in range(a__		)
						]
						_A					  =			[]
						for iterable_dataset_shard in iterable_dataset_shards:
										# Since our random iterable dataset will be... random... we need to use a seed to get reproducible results.
										random.seed(a__		)
										iterable_dataset_lists.append(list(a__		)		)

						_A					  =			batch_size // num_processes if split_batches else batch_size
						# All iterable dataset shard should have the same length, a round multiple of shard_batch_size
						_A					  =			iterable_dataset_lists[0]
						for l in iterable_dataset_lists[1:]:
										self.assertEqual(len(a__		)    ,   len(a__		)		)
										self.assertTrue(len(a__		) % shard_batch_size == 0		)

						_A					  =			[]
						for idx in range(0    ,   len(a__		)    ,   a__		):
										for l in iterable_dataset_lists:
														observed += l[idx : idx + shard_batch_size]

						if not drop_last:
										while len(a__		) < len(a__		):
														reference += reference
						self.assertListEqual(a__    ,   reference[: len(a__		)]		)







		def  a_ (					self      :       List[str]		)       ->						List[Any]:





						'''simple docstring'''







						_A					  =			42
						_A					  =			RandomIterableDataset()

						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)
						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)
						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)
						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)

						# Edge case with a very small dataset
						_A					  =			RandomIterableDataset(max_length=2		)

						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)
						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)
						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)
						self.check_iterable_dataset_shards(a__    ,   a__    ,   batch_size=4    ,   drop_last=a__    ,   split_batches=a__		)







		def  a_ (					self      :       List[str]		)       ->						Dict:





						'''simple docstring'''







						_A					  =			BatchSampler(range(16		)    ,   batch_size=4    ,   drop_last=a__		)
						_A					  =			SkipBatchSampler(a__    ,   2		)
						self.assertListEqual(list(a__		)    ,   [[8, 9, 10, 11], [12, 13, 14, 15]]		)







		def  a_ (					self      :       int		)       ->						Union[str, Any]:





						'''simple docstring'''







						_A					  =			SkipDataLoader(list(range(16		)		)    ,   batch_size=4    ,   skip_batches=2		)
						self.assertListEqual([t.tolist() for t in dataloader]    ,   [[8, 9, 10, 11], [12, 13, 14, 15]]		)







		def  a_ (					self      :       int		)       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			DataLoader(list(range(16		)		)    ,   batch_size=4		)
						_A					  =			skip_first_batches(a__    ,   num_batches=2		)
						self.assertListEqual([t.tolist() for t in new_dataloader]    ,   [[8, 9, 10, 11], [12, 13, 14, 15]]		)







		def  a_ (					self      :       Optional[Any]		)       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			DataLoaderShard(list(range(16		)		)    ,   batch_size=4		)
						for idx, _ in enumerate(a__		):
										self.assertEqual(dataloader.end_of_dataloader    ,   idx == 3		)

						# Test it also works on the second iteration
						for idx, _ in enumerate(a__		):
										self.assertEqual(dataloader.end_of_dataloader    ,   idx == 3		)







		def  a_ (					self      :       int		)       ->						int:





						'''simple docstring'''







						Accelerator()
						_A					  =			DataLoaderDispatcher(range(16		)    ,   batch_size=4		)
						for idx, _ in enumerate(a__		):
										self.assertEqual(dataloader.end_of_dataloader    ,   idx == 3		)

						# Test it also works on the second iteration
						for idx, _ in enumerate(a__		):
										self.assertEqual(dataloader.end_of_dataloader    ,   idx == 3		)