






'''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      A     (   SCREAMING_SNAKE_CASE__    ):






 """simple docstring"""





 def __init__(				self      ,  __lowerCAmelCase=0.01      ,  __lowerCAmelCase=10_00			):
       UpperCamelCase_					: Any            =				p_stop
       UpperCamelCase_					: int            =				max_length





 def __iter__(				self			):
       UpperCamelCase_					: Tuple            =				0
       UpperCamelCase_					: int            =				False
       while not stop and count < self.max_length:
             yield count
             count += 1
             UpperCamelCase_					: str            =				random.random() < self.p_stop






class      A     (   unittest.TestCase    ):






 """simple docstring"""





 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase      ,  __lowerCAmelCase=False      ,  __lowerCAmelCase=True			):
       UpperCamelCase_					: Union[str, Any]            =				[
           BatchSamplerShard(__lowerCAmelCase      ,  2      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)
           for i in range(2			)
       ]
       UpperCamelCase_					: Dict            =				[list(__lowerCAmelCase			) for batch_sampler_shard in batch_sampler_shards]
       if not split_batches:
             self.assertListEqual([len(__lowerCAmelCase			) for shard in batch_sampler_shards]      ,  [len(__lowerCAmelCase			) for e in expected]			)
       self.assertListEqual(__lowerCAmelCase      ,  __lowerCAmelCase			)
 def 	_UpperCAmelCase							(				self			):
       # Check the shards when the dataset is a round multiple of total batch size.
       UpperCamelCase_					: int            =				BatchSampler(range(24			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: List[str]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase			)

       UpperCamelCase_					: int            =				BatchSampler(range(24			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       # Expected shouldn't change
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase			)

       # Check the shards when the dataset is a round multiple of batch size but not total batch size.
       UpperCamelCase_					: Optional[Any]            =				BatchSampler(range(21			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: List[Any]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase			)

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

       # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
       # num_processes batch.
       UpperCamelCase_					: Optional[int]            =				BatchSampler(range(22			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: List[Any]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase			)

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

       # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
       # num_processes batch.
       UpperCamelCase_					: Tuple            =				BatchSampler(range(20			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: str            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase			)

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

       # Check the shards when the dataset is very small.
       UpperCamelCase_					: int            =				BatchSampler(range(2			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: str            =				[[[0, 1, 0]], [[1, 0, 1]]]
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase			)

       UpperCamelCase_					: int            =				BatchSampler(range(2			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Tuple            =				[[], []]
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase			)
 def 	_UpperCAmelCase							(				self			):
       # Check the shards when the dataset is a round multiple of batch size.
       UpperCamelCase_					: Dict            =				BatchSampler(range(24			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: List[Any]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)

       UpperCamelCase_					: Tuple            =				BatchSampler(range(24			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       # Expected shouldn't change
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)

       # Check the shards when the dataset is not a round multiple of batch size.
       UpperCamelCase_					: List[Any]            =				BatchSampler(range(22			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Dict            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)

       UpperCamelCase_					: int            =				BatchSampler(range(22			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Tuple            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)

       # Check the shards when the dataset is not a round multiple of batch size or num_processes.
       UpperCamelCase_					: List[str]            =				BatchSampler(range(21			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Optional[int]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)

       UpperCamelCase_					: Dict            =				BatchSampler(range(21			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Optional[Any]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)

       # Check the shards when the dataset is very small.
       UpperCamelCase_					: Tuple            =				BatchSampler(range(2			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: str            =				[[[0, 1]], [[0, 1]]]
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)

       UpperCamelCase_					: Union[str, Any]            =				BatchSampler(range(2			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Dict            =				[[], []]
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)
 def 	_UpperCAmelCase							(				self			):
       # Check the shards when the dataset is a round multiple of total batch size.
       UpperCamelCase_					: Optional[Any]            =				BatchSampler(range(24			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: str            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       UpperCamelCase_					: List[str]            =				BatchSampler(range(24			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       # Expected shouldn't change
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       # Check the shards when the dataset is a round multiple of batch size but not total batch size.
       UpperCamelCase_					: Union[str, Any]            =				BatchSampler(range(21			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Tuple            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

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

       # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
       # num_processes batch.
       UpperCamelCase_					: Optional[Any]            =				BatchSampler(range(22			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: List[Any]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

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

       # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
       # num_processes batch.
       UpperCamelCase_					: List[str]            =				BatchSampler(range(20			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Any            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

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

       # Check the shards when the dataset is very small.
       UpperCamelCase_					: Optional[Any]            =				BatchSampler(range(2			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: List[str]            =				[[[0, 1]], []]
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       UpperCamelCase_					: List[str]            =				BatchSampler(range(2			)      ,  batch_size=3      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Dict            =				[[], []]
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)
 def 	_UpperCAmelCase							(				self			):
       # Check the shards when the dataset is a round multiple of batch size.
       UpperCamelCase_					: List[str]            =				BatchSampler(range(24			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: List[Any]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       UpperCamelCase_					: Optional[Any]            =				BatchSampler(range(24			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       # Expected shouldn't change
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       # Check the shards when the dataset is not a round multiple of batch size.
       UpperCamelCase_					: Optional[Any]            =				BatchSampler(range(22			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Tuple            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       UpperCamelCase_					: str            =				BatchSampler(range(22			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Tuple            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       # Check the shards when the dataset is not a round multiple of batch size or num_processes.
       UpperCamelCase_					: int            =				BatchSampler(range(21			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: str            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

       UpperCamelCase_					: List[Any]            =				BatchSampler(range(21			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Union[str, Any]            =				[
           [[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(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)

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

       UpperCamelCase_					: str            =				BatchSampler(range(2			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: Any            =				[[], []]
       self.check_batch_sampler_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  even_batches=__lowerCAmelCase			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Optional[int]            =				[[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
       UpperCamelCase_					: List[str]            =				[BatchSamplerShard(__lowerCAmelCase      ,  2      ,  __lowerCAmelCase      ,  even_batches=__lowerCAmelCase			) 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 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase      ,  __lowerCAmelCase      ,  __lowerCAmelCase=False      ,  __lowerCAmelCase=2      ,  __lowerCAmelCase=False			):
       random.seed(__lowerCAmelCase			)
       UpperCamelCase_					: List[Any]            =				list(__lowerCAmelCase			)

       UpperCamelCase_					: Tuple            =				[
           IterableDatasetShard(
               __lowerCAmelCase      ,  batch_size=__lowerCAmelCase      ,  drop_last=__lowerCAmelCase      ,  num_processes=__lowerCAmelCase      ,  process_index=__lowerCAmelCase      ,  split_batches=__lowerCAmelCase      ,  )
           for i in range(__lowerCAmelCase			)
       ]
       UpperCamelCase_					: Any            =				[]
       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(__lowerCAmelCase			)
             iterable_dataset_lists.append(list(__lowerCAmelCase			)			)

       UpperCamelCase_					: int            =				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
       UpperCamelCase_					: Dict            =				iterable_dataset_lists[0]
       for l in iterable_dataset_lists[1:]:
             self.assertEqual(len(__lowerCAmelCase			)      ,  len(__lowerCAmelCase			)			)
             self.assertTrue(len(__lowerCAmelCase			) % shard_batch_size == 0			)

       UpperCamelCase_					: Optional[int]            =				[]
       for idx in range(0      ,  len(__lowerCAmelCase			)      ,  __lowerCAmelCase			):
             for l in iterable_dataset_lists:
                   observed += l[idx : idx + shard_batch_size]

       if not drop_last:
             while len(__lowerCAmelCase			) < len(__lowerCAmelCase			):
                   reference += reference
       self.assertListEqual(__lowerCAmelCase      ,  reference[: len(__lowerCAmelCase			)]			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: List[Any]            =				42
       UpperCamelCase_					: List[str]            =				RandomIterableDataset()

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

       # Edge case with a very small dataset
       UpperCamelCase_					: Optional[Any]            =				RandomIterableDataset(max_length=2			)

       self.check_iterable_dataset_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  batch_size=4      ,  drop_last=__lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)
       self.check_iterable_dataset_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  batch_size=4      ,  drop_last=__lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)
       self.check_iterable_dataset_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  batch_size=4      ,  drop_last=__lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)
       self.check_iterable_dataset_shards(__lowerCAmelCase      ,  __lowerCAmelCase      ,  batch_size=4      ,  drop_last=__lowerCAmelCase      ,  split_batches=__lowerCAmelCase			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: int            =				BatchSampler(range(16			)      ,  batch_size=4      ,  drop_last=__lowerCAmelCase			)
       UpperCamelCase_					: str            =				SkipBatchSampler(__lowerCAmelCase      ,  2			)
       self.assertListEqual(list(__lowerCAmelCase			)      ,  [[8, 9, 10, 11], [12, 13, 14, 15]]			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: int            =				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 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: List[Any]            =				DataLoader(list(range(16			)			)      ,  batch_size=4			)
       UpperCamelCase_					: Tuple            =				skip_first_batches(__lowerCAmelCase      ,  num_batches=2			)
       self.assertListEqual([t.tolist() for t in new_dataloader]      ,  [[8, 9, 10, 11], [12, 13, 14, 15]]			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Optional[int]            =				DataLoaderShard(list(range(16			)			)      ,  batch_size=4			)
       for idx, _ in enumerate(__lowerCAmelCase			):
             self.assertEqual(dataloader.end_of_dataloader      ,  idx == 3			)

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





 def 	_UpperCAmelCase							(				self			):
       Accelerator()
       UpperCamelCase_					: Tuple            =				DataLoaderDispatcher(range(16			)      ,  batch_size=4			)
       for idx, _ in enumerate(__lowerCAmelCase			):
             self.assertEqual(dataloader.end_of_dataloader      ,  idx == 3			)

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














'''simple docstring'''

def 				snake_case       (  a_				:			list						)							->					list:





      """simple docstring"""

      UpperCamelCase_					: List[str]            =				False
      while is_sorted is False:  # Until all the indices are traversed keep looping
            UpperCamelCase_					: Tuple            =				True
            for i in range(0     , len(a_						) - 1     , 2						):  # iterating over all even indices
                  if input_list[i] > input_list[i + 1]:
                        UpperCamelCase_     ,      UpperCamelCase_					: Optional[Any]            =				input_list[i + 1], input_list[i]
                        # swapping if elements not in order
                        UpperCamelCase_					: Any            =				False

            for i in range(1     , len(a_						) - 1     , 2						):  # iterating over all odd indices
                  if input_list[i] > input_list[i + 1]:
                        UpperCamelCase_     ,      UpperCamelCase_					: List[str]            =				input_list[i + 1], input_list[i]
                        # swapping if elements not in order
                        UpperCamelCase_					: Dict            =				False
      return input_list


if __name__ == "__main__":
      print("Enter list to be sorted")
      UpperCamelCase      					=[int(x) for x in input().split()]
      # inputing elements of the list in one line
      UpperCamelCase      					=odd_even_sort(input_list)
      print("The sorted list is")
      print(sorted_list)






