

import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






@skip_mps
class 	UpperCAmelCase__		(	A__						,					unittest.TestCase	):






  """simple docstring"""


  a									= VideoToVideoSDPipeline
  a									= TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"video"}	) - {"image", "width", "height"}
  a									= TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"video"}	) - {"image"}
  a									= PipelineTesterMixin.required_optional_params - {"latents"}
  a									= False

  # No `output_type`.
  a									= frozenset(
      [
          "num_inference_steps",
          "generator",
          "latents",
          "return_dict",
          "callback",
          "callback_steps",
      ]	)






  def 				lowercase_		(							self						:		str )		->							Tuple:
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   UNetaDConditionModel(
           block_out_channels=(32, 64, 64, 64)     ,       layers_per_block=2     ,       sample_size=32     ,       in_channels=4     ,       out_channels=4     ,       down_block_types=('''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''DownBlock3D''')     ,       up_block_types=('''UpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''')     ,       cross_attention_dim=32     ,       attention_head_dim=4     ,       )
       SCREAMING_SNAKE_CASE__   =   DDIMScheduler(
           beta_start=0.00085     ,       beta_end=0.012     ,       beta_schedule='''scaled_linear'''     ,       clip_sample=__lowerCamelCase     ,       set_alpha_to_one=__lowerCamelCase     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   AutoencoderKL(
           block_out_channels=[32, 64]     ,       in_channels=3     ,       out_channels=3     ,       down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,       up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,       latent_channels=4     ,       sample_size=128     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   CLIPTextConfig(
           bos_token_id=0     ,       eos_token_id=2     ,       hidden_size=32     ,       intermediate_size=37     ,       layer_norm_eps=1e-05     ,       num_attention_heads=4     ,       num_hidden_layers=5     ,       pad_token_id=1     ,       vocab_size=1000     ,       hidden_act='''gelu'''     ,       projection_dim=512     ,       )
       SCREAMING_SNAKE_CASE__   =   CLIPTextModel(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )

       SCREAMING_SNAKE_CASE__   =   {
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
       }
       return components






  def 				lowercase_		(							self						:		str     ,       __lowerCamelCase						:		int     ,       __lowerCamelCase						:		Tuple=0 )		->							List[str]:
       # 3 frames
       SCREAMING_SNAKE_CASE__   =   floats_tensor((1, 3, 3, 32, 32)     ,       rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase )

       if str(__lowerCamelCase ).startswith('''mps''' ):
            SCREAMING_SNAKE_CASE__   =   torch.manual_seed(__lowerCamelCase )
       else:
            SCREAMING_SNAKE_CASE__   =   torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   {
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''video''': video,
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 6.0,
           '''output_type''': '''pt''',
       }
       return inputs






  def 				lowercase_		(							self						:		Optional[int] )		->							str:
       SCREAMING_SNAKE_CASE__   =   '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE__   =   self.get_dummy_components()
       SCREAMING_SNAKE_CASE__   =   VideoToVideoSDPipeline(**__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   sd_pipe.to(__lowerCamelCase )
       sd_pipe.set_progress_bar_config(disable=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   self.get_dummy_inputs(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   '''np'''
       SCREAMING_SNAKE_CASE__   =   sd_pipe(**__lowerCamelCase ).frames
       SCREAMING_SNAKE_CASE__   =   frames[0][-3:, -3:, -1]

       assert frames[0].shape == (32, 32, 3)
       SCREAMING_SNAKE_CASE__   =   np.array([106, 117, 113, 174, 137, 112, 148, 151, 131] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2






  @unittest.skipIf(
      torch_device != '''cuda''' or not is_xformers_available()     ,       reason='''XFormers attention is only available with CUDA and `xformers` installed'''     ,       )
  def 				lowercase_		(							self						:		Tuple )		->							Tuple:
       self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__lowerCamelCase     ,       expected_max_diff=5e-3 )






  @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.''' )
  def 				lowercase_		(							self						:		Optional[int] )		->							List[str]:
       pass






  @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.''' )
  def 				lowercase_		(							self						:		List[str] )		->							Optional[int]:
       pass






  @unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.''' )
  def 				lowercase_		(							self						:		str )		->							Dict:
       pass







  def 				lowercase_		(							self						:		List[Any] )		->							int:
       return super().test_progress_bar()






@slow
@skip_mps
class 	UpperCAmelCase__		(	unittest.TestCase	):






  """simple docstring"""


  def 				lowercase_		(							self						:		Dict )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__   =   VideoToVideoSDPipeline.from_pretrained('''cerspense/zeroscope_v2_XL'''     ,       torch_dtype=torch.floataa )
       pipe.enable_model_cpu_offload()

       # 10 frames
       SCREAMING_SNAKE_CASE__   =   torch.Generator(device='''cpu''' ).manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   torch.randn((1, 10, 3, 1024, 576)     ,       generator=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   video.to('''cuda''' )

       SCREAMING_SNAKE_CASE__   =   '''Spiderman is surfing'''

       SCREAMING_SNAKE_CASE__   =   pipe(__lowerCamelCase     ,       video=__lowerCamelCase     ,       generator=__lowerCamelCase     ,       num_inference_steps=3     ,       output_type='''pt''' ).frames

       SCREAMING_SNAKE_CASE__   =   np.array([-1.0458984, -1.1279297, -0.9663086, -0.91503906, -0.75097656] )
       assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array ).sum() < 1e-2






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 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  def __init__(							self						:		List[str]     ,       __lowerCamelCase						:		Tuple=0.01     ,       __lowerCamelCase						:		Optional[Any]=1000 )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   p_stop
       SCREAMING_SNAKE_CASE__   =   max_length







  def __iter__(							self						:		List[str] )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   0
       SCREAMING_SNAKE_CASE__   =   False
       while not stop and count < self.max_length:
            yield count
            count += 1
            SCREAMING_SNAKE_CASE__   =   random.random() < self.p_stop






class 	UpperCAmelCase__		(	unittest.TestCase	):






  """simple docstring"""


  def 				lowercase_		(							self						:		List[Any]     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Any=False     ,       __lowerCamelCase						:		Optional[int]=True )		->							Dict:
       SCREAMING_SNAKE_CASE__   =   [
           BatchSamplerShard(__lowerCamelCase     ,       2     ,       __lowerCamelCase     ,       split_batches=__lowerCamelCase     ,       even_batches=__lowerCamelCase )
           for i in range(2 )
       ]
       SCREAMING_SNAKE_CASE__   =   [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 				lowercase_		(							self						:		Any )		->							Optional[Any]:
       # Check the shards when the dataset is a round multiple of total batch size.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(24 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(20 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(20 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(2 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [[[0, 1, 0]], [[1, 0, 1]]]
       self.check_batch_sampler_shards(__lowerCamelCase     ,       __lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(2 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [[], []]
       self.check_batch_sampler_shards(__lowerCamelCase     ,       __lowerCamelCase )






  def 				lowercase_		(							self						:		Optional[int] )		->							int:
       # Check the shards when the dataset is a round multiple of batch size.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(24 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(2 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [[[0, 1]], [[0, 1]]]
       self.check_batch_sampler_shards(__lowerCamelCase     ,       __lowerCamelCase     ,       split_batches=__lowerCamelCase )

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






  def 				lowercase_		(							self						:		str )		->							Dict:
       # Check the shards when the dataset is a round multiple of total batch size.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(24 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(20 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(20 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(2 )     ,       batch_size=3     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [[[0, 1]], []]
       self.check_batch_sampler_shards(__lowerCamelCase     ,       __lowerCamelCase     ,       even_batches=__lowerCamelCase )

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






  def 				lowercase_		(							self						:		List[str] )		->							Tuple:
       # Check the shards when the dataset is a round multiple of batch size.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(24 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(22 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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 )

       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(21 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [
           [[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.
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(2 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   [[[0, 1]], []]
       self.check_batch_sampler_shards(__lowerCamelCase     ,       __lowerCamelCase     ,       split_batches=__lowerCamelCase     ,       even_batches=__lowerCamelCase )

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






  def 				lowercase_		(							self						:		Optional[int] )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   [[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
       SCREAMING_SNAKE_CASE__   =   [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 				lowercase_		(							self						:		Optional[Any]     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Tuple=False     ,       __lowerCamelCase						:		Optional[int]=2     ,       __lowerCamelCase						:		Dict=False )		->							str:
       random.seed(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   list(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   [
           IterableDatasetShard(
               __lowerCamelCase     ,       batch_size=__lowerCamelCase     ,       drop_last=__lowerCamelCase     ,       num_processes=__lowerCamelCase     ,       process_index=__lowerCamelCase     ,       split_batches=__lowerCamelCase     ,       )
           for i in range(__lowerCamelCase )
       ]
       SCREAMING_SNAKE_CASE__   =   []
       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 ) )

       SCREAMING_SNAKE_CASE__   =   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
       SCREAMING_SNAKE_CASE__   =   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 )

       SCREAMING_SNAKE_CASE__   =   []
       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 				lowercase_		(							self						:		str )		->							Dict:
       SCREAMING_SNAKE_CASE__   =   42
       SCREAMING_SNAKE_CASE__   =   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
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		Optional[Any] )		->							Any:
       SCREAMING_SNAKE_CASE__   =   BatchSampler(range(16 )     ,       batch_size=4     ,       drop_last=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   SkipBatchSampler(__lowerCamelCase     ,       2 )
       self.assertListEqual(list(__lowerCamelCase )     ,       [[8, 9, 10, 11], [12, 13, 14, 15]] )






  def 				lowercase_		(							self						:		Union[str, Any] )		->							str:
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		Dict )		->							List[Any]:
       SCREAMING_SNAKE_CASE__   =   DataLoader(list(range(16 ) )     ,       batch_size=4 )
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		List[Any] )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		Union[str, Any] )		->							str:
       Accelerator()
       SCREAMING_SNAKE_CASE__   =   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 )


