





import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionInstructPixaPixPipeline,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class 						lowerCamelCase       (__lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     unittest.TestCase      ):







							"""simple docstring"""




							UpperCAmelCase_      						=   StableDiffusionInstructPixaPixPipeline
							UpperCAmelCase_      						=   TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width", "cross_attention_kwargs"}
							UpperCAmelCase_      						=   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
							UpperCAmelCase_      						=   IMAGE_TO_IMAGE_IMAGE_PARAMS
							UpperCAmelCase_      						=   IMAGE_TO_IMAGE_IMAGE_PARAMS






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





														"""simple docstring"""
														torch.manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						UNetaDConditionModel(
														    block_out_channels=(3_2, 6_4),			layers_per_block=2,			sample_size=3_2,			in_channels=8,			out_channels=4,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),			cross_attention_dim=3_2,			)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						PNDMScheduler(skip_prk_steps=_UpperCAmelCase						)
														torch.manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      Any     =						AutoencoderKL(
														    block_out_channels=[3_2, 6_4],			in_channels=3,			out_channels=3,			down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],			up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],			latent_channels=4,			)
														torch.manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      Any     =						CLIPTextConfig(
														    bos_token_id=0,			eos_token_id=2,			hidden_size=3_2,			intermediate_size=3_7,			layer_norm_eps=1E-05,			num_attention_heads=4,			num_hidden_layers=5,			pad_token_id=1,			vocab_size=1_0_0_0,			)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						CLIPTextModel(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      int     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

														SCREAMING_SNAKE_CASE__       :      Tuple     =						{
														    '''unet''': unet,
														    '''scheduler''': scheduler,
														    '''vae''': vae,
														    '''text_encoder''': text_encoder,
														    '''tokenizer''': tokenizer,
														    '''safety_checker''': None,
														    '''feature_extractor''': None,
														}
														return components






							def  A_     ( self     :					str,			_UpperCAmelCase     :					str,			_UpperCAmelCase     :					Union[str, Any]=0						)				->			Optional[int]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Dict     =						floats_tensor((1, 3, 3_2, 3_2),			rng=random.Random(_UpperCAmelCase						)						).to(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Any     =						image.cpu().permute(0,			2,			3,			1						)[0]
														SCREAMING_SNAKE_CASE__       :      Dict     =						Image.fromarray(np.uinta(_UpperCAmelCase						)						).convert("RGB"						)
														if str(_UpperCAmelCase						).startswith("mps"						):
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						torch.manual_seed(_UpperCAmelCase						)
														else:
																					SCREAMING_SNAKE_CASE__       :      str     =						torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						{
														    '''prompt''': '''A painting of a squirrel eating a burger''',
														    '''image''': image,
														    '''generator''': generator,
														    '''num_inference_steps''': 2,
														    '''guidance_scale''': 6.0,
														    '''image_guidance_scale''': 1,
														    '''output_type''': '''numpy''',
														}
														return inputs






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						'''cpu'''  # ensure determinism for the device-dependent torch.Generator
														SCREAMING_SNAKE_CASE__       :      str     =						self.get_dummy_components()
														SCREAMING_SNAKE_CASE__       :      Tuple     =						StableDiffusionInstructPixaPixPipeline(**_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Any     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      List[str]     =						self.get_dummy_inputs(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						sd_pipe(**_UpperCAmelCase						).images
														SCREAMING_SNAKE_CASE__       :      int     =						image[0, -3:, -3:, -1]
														assert image.shape == (1, 3_2, 3_2, 3)
														SCREAMING_SNAKE_CASE__       :      int     =						np.array([0.7526, 0.3750, 0.4547, 0.6117, 0.5866, 0.5016, 0.4327, 0.5642, 0.4815]						)

														assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-3






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						'''cpu'''  # ensure determinism for the device-dependent torch.Generator
														SCREAMING_SNAKE_CASE__       :      Any     =						self.get_dummy_components()
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						StableDiffusionInstructPixaPixPipeline(**_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      str     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      str     =						self.get_dummy_inputs(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						'''french fries'''
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						sd_pipe(**_UpperCAmelCase,			negative_prompt=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						output.images
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						image[0, -3:, -3:, -1]

														assert image.shape == (1, 3_2, 3_2, 3)
														SCREAMING_SNAKE_CASE__       :      str     =						np.array([0.7511, 0.3642, 0.4553, 0.6236, 0.5797, 0.5013, 0.4343, 0.5611, 0.4831]						)

														assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-3






							def  A_     ( self     :					str						)				->			Tuple:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Tuple     =						'''cpu'''  # ensure determinism for the device-dependent torch.Generator
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						self.get_dummy_components()
														SCREAMING_SNAKE_CASE__       :      Dict     =						StableDiffusionInstructPixaPixPipeline(**_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      List[str]     =						self.get_dummy_inputs(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						[inputs['''prompt''']] * 2

														SCREAMING_SNAKE_CASE__       :      Dict     =						np.array(inputs["image"]						).astype(np.floataa						) / 255.0
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						torch.from_numpy(_UpperCAmelCase						).unsqueeze(0						).to(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      str     =						image / 2 + 0.5
														SCREAMING_SNAKE_CASE__       :      List[str]     =						image.permute(0,			3,			1,			2						)
														SCREAMING_SNAKE_CASE__       :      str     =						image.repeat(2,			1,			1,			1						)

														SCREAMING_SNAKE_CASE__       :      Any     =						sd_pipe(**_UpperCAmelCase						).images
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						image[-1, -3:, -3:, -1]

														assert image.shape == (2, 3_2, 3_2, 3)
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						np.array([0.5812, 0.5748, 0.5222, 0.5908, 0.5695, 0.7174, 0.6804, 0.5523, 0.5579]						)

														assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-3






							def  A_     ( self     :					Optional[int]						)				->			Dict:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[str]     =						'''cpu'''  # ensure determinism for the device-dependent torch.Generator
														SCREAMING_SNAKE_CASE__       :      Any     =						self.get_dummy_components()
														SCREAMING_SNAKE_CASE__       :      Tuple     =						EulerAncestralDiscreteScheduler(
														    beta_start=0.00085,			beta_end=0.012,			beta_schedule="scaled_linear"						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						StableDiffusionInstructPixaPixPipeline(**_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      Tuple     =						self.get_dummy_inputs(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						sd_pipe(**_UpperCAmelCase						).images
														SCREAMING_SNAKE_CASE__       :      Any     =						image[0, -3:, -3:, -1]

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						[round(_UpperCAmelCase,			4						) for x in image_slice.flatten().tolist()]
														print(",".join([str(_UpperCAmelCase						) for x in slice]						)						)

														assert image.shape == (1, 3_2, 3_2, 3)
														SCREAMING_SNAKE_CASE__       :      Dict     =						np.array([0.7417, 0.3842, 0.4732, 0.5776, 0.5891, 0.5139, 0.4052, 0.5673, 0.4986]						)

														assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-3






							def  A_     ( self     :					List[Any]						)				->			Optional[Any]:





														"""simple docstring"""
														super().test_inference_batch_single_identical(expected_max_diff=3E-3						)






							def  A_     ( self     :					Tuple						)				->			Dict:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.get_dummy_components()
														SCREAMING_SNAKE_CASE__       :      int     =						StableDiffusionInstructPixaPixPipeline(**_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						VaeImageProcessor(do_resize=_UpperCAmelCase,			do_normalize=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      str     =						pipe.to(_UpperCAmelCase						)
														pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      int     =						pipe(**self.get_dummy_inputs_by_type(_UpperCAmelCase,			input_image_type="pt"						)						)[0]

														SCREAMING_SNAKE_CASE__       :      Dict     =						components['''vae''']
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.get_dummy_inputs_by_type(_UpperCAmelCase,			input_image_type="pt"						)

														for image_param in self.image_latents_params:
																					if image_param in inputs.keys():
																												SCREAMING_SNAKE_CASE__       :      List[Any]     =						vae.encode(inputs[image_param]						).latent_dist.mode()

														SCREAMING_SNAKE_CASE__       :      Dict     =						pipe(**_UpperCAmelCase						)[0]

														SCREAMING_SNAKE_CASE__       :      List[str]     =						np.abs(out - out_latents_inputs						).max()
														self.assertLess(_UpperCAmelCase,			1E-4,			"passing latents as image input generate different result from passing image"						)


@slow
@require_torch_gpu
class 						lowerCamelCase       (unittest.TestCase      ):







							"""simple docstring"""




							def  A_     ( self     :					Optional[int]						)				->			str:





														"""simple docstring"""
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()






							def  A_     ( self     :					Any,			_UpperCAmelCase     :					Tuple=0						)				->			List[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      str     =						torch.manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						load_image(
														    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_pix2pix/example.jpg"						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						{
														    '''prompt''': '''turn him into a cyborg''',
														    '''image''': image,
														    '''generator''': generator,
														    '''num_inference_steps''': 3,
														    '''guidance_scale''': 7.5,
														    '''image_guidance_scale''': 1.0,
														    '''output_type''': '''numpy''',
														}
														return inputs






							def  A_     ( self     :					int						)				->			Any:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						StableDiffusionInstructPixaPixPipeline.from_pretrained(
														    "timbrooks/instruct-pix2pix",			safety_checker=_UpperCAmelCase						)
														pipe.to(_UpperCAmelCase						)
														pipe.set_progress_bar_config(disable=_UpperCAmelCase						)
														pipe.enable_attention_slicing()

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.get_inputs()
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						pipe(**_UpperCAmelCase						).images
														SCREAMING_SNAKE_CASE__       :      str     =						image[0, -3:, -3:, -1].flatten()

														assert image.shape == (1, 5_1_2, 5_1_2, 3)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						np.array([0.5902, 0.6015, 0.6027, 0.5983, 0.6092, 0.6061, 0.5765, 0.5785, 0.5555]						)

														assert np.abs(expected_slice - image_slice						).max() < 1E-3






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						StableDiffusionInstructPixaPixPipeline.from_pretrained(
														    "timbrooks/instruct-pix2pix",			safety_checker=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						LMSDiscreteScheduler.from_config(pipe.scheduler.config						)
														pipe.to(_UpperCAmelCase						)
														pipe.set_progress_bar_config(disable=_UpperCAmelCase						)
														pipe.enable_attention_slicing()

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.get_inputs()
														SCREAMING_SNAKE_CASE__       :      str     =						pipe(**_UpperCAmelCase						).images
														SCREAMING_SNAKE_CASE__       :      int     =						image[0, -3:, -3:, -1].flatten()

														assert image.shape == (1, 5_1_2, 5_1_2, 3)
														SCREAMING_SNAKE_CASE__       :      int     =						np.array([0.6578, 0.6817, 0.6972, 0.6761, 0.6856, 0.6916, 0.6428, 0.6516, 0.6301]						)

														assert np.abs(expected_slice - image_slice						).max() < 1E-3






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						StableDiffusionInstructPixaPixPipeline.from_pretrained(
														    "timbrooks/instruct-pix2pix",			safety_checker=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						DDIMScheduler.from_config(pipe.scheduler.config						)
														pipe.to(_UpperCAmelCase						)
														pipe.set_progress_bar_config(disable=_UpperCAmelCase						)
														pipe.enable_attention_slicing()

														SCREAMING_SNAKE_CASE__       :      str     =						self.get_inputs()
														SCREAMING_SNAKE_CASE__       :      Dict     =						pipe(**_UpperCAmelCase						).images
														SCREAMING_SNAKE_CASE__       :      str     =						image[0, -3:, -3:, -1].flatten()

														assert image.shape == (1, 5_1_2, 5_1_2, 3)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						np.array([0.3828, 0.3834, 0.3818, 0.3792, 0.3865, 0.3752, 0.3792, 0.3847, 0.3753]						)

														assert np.abs(expected_slice - image_slice						).max() < 1E-3






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Dict     =						0

														def callback_fn(_UpperCAmelCase     :					Union[str, Any],			_UpperCAmelCase     :					Dict,			_UpperCAmelCase     :					Any						) -> None:
																					SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						True
																					nonlocal number_of_steps
																					number_of_steps += 1
																					if step == 1:
																												SCREAMING_SNAKE_CASE__       :      Dict     =						latents.detach().cpu().numpy()
																												assert latents.shape == (1, 4, 6_4, 6_4)
																												SCREAMING_SNAKE_CASE__       :      List[Any]     =						latents[0, -3:, -3:, -1]
																												SCREAMING_SNAKE_CASE__       :      List[str]     =						np.array([-0.2463, -0.4644, -0.9756, 1.5176, 1.4414, 0.7866, 0.9897, 0.8521, 0.7983]						)

																												assert np.abs(latents_slice.flatten() - expected_slice						).max() < 5E-2
																					elif step == 2:
																												SCREAMING_SNAKE_CASE__       :      List[Any]     =						latents.detach().cpu().numpy()
																												assert latents.shape == (1, 4, 6_4, 6_4)
																												SCREAMING_SNAKE_CASE__       :      Tuple     =						latents[0, -3:, -3:, -1]
																												SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						np.array([-0.2644, -0.4626, -0.9653, 1.5176, 1.4551, 0.7686, 0.9805, 0.8452, 0.8115]						)

																												assert np.abs(latents_slice.flatten() - expected_slice						).max() < 5E-2

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						False

														SCREAMING_SNAKE_CASE__       :      str     =						StableDiffusionInstructPixaPixPipeline.from_pretrained(
														    "timbrooks/instruct-pix2pix",			safety_checker=_UpperCAmelCase,			torch_dtype=torch.floataa						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						pipe.to(_UpperCAmelCase						)
														pipe.set_progress_bar_config(disable=_UpperCAmelCase						)
														pipe.enable_attention_slicing()

														SCREAMING_SNAKE_CASE__       :      Dict     =						self.get_inputs()
														pipe(**_UpperCAmelCase,			callback=_UpperCAmelCase,			callback_steps=1						)
														assert callback_fn.has_been_called
														assert number_of_steps == 3






							def  A_     ( self     :					List[str]						)				->			Optional[int]:





														"""simple docstring"""
														torch.cuda.empty_cache()
														torch.cuda.reset_max_memory_allocated()
														torch.cuda.reset_peak_memory_stats()

														SCREAMING_SNAKE_CASE__       :      str     =						StableDiffusionInstructPixaPixPipeline.from_pretrained(
														    "timbrooks/instruct-pix2pix",			safety_checker=_UpperCAmelCase,			torch_dtype=torch.floataa						)
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						pipe.to(_UpperCAmelCase						)
														pipe.set_progress_bar_config(disable=_UpperCAmelCase						)
														pipe.enable_attention_slicing(1						)
														pipe.enable_sequential_cpu_offload()

														SCREAMING_SNAKE_CASE__       :      int     =						self.get_inputs()
														SCREAMING_SNAKE_CASE__       :      Dict     =						pipe(**_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						torch.cuda.max_memory_allocated()
														# make sure that less than 2.2 GB is allocated
														assert mem_bytes < 2.2 * 1_0**9






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Tuple     =						self.get_inputs()
														# resize to resolution that is divisible by 8 but not 16 or 32
														SCREAMING_SNAKE_CASE__       :      str     =						inputs['''image'''].resize((5_0_4, 5_0_4)						)

														SCREAMING_SNAKE_CASE__       :      List[Any]     =						'''timbrooks/instruct-pix2pix'''
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						StableDiffusionInstructPixaPixPipeline.from_pretrained(
														    _UpperCAmelCase,			safety_checker=_UpperCAmelCase,			)
														pipe.to(_UpperCAmelCase						)
														pipe.set_progress_bar_config(disable=_UpperCAmelCase						)
														pipe.enable_attention_slicing()

														SCREAMING_SNAKE_CASE__       :      int     =						pipe(**_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						output.images[0]

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						image[2_5_5:2_5_8, 3_8_3:3_8_6, -1]

														assert image.shape == (5_0_4, 5_0_4, 3)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						np.array([0.2726, 0.2529, 0.2664, 0.2655, 0.2641, 0.2642, 0.2591, 0.2649, 0.2590]						)

														assert np.abs(image_slice.flatten() - expected_slice						).max() < 5E-3













import pytest

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




@pytest.mark.parametrize(
    "split_dict"			,				[
        SplitDict(),
        SplitDict({"train": SplitInfo(name="train"			,				num_bytes=13_37			,				num_examples=42			,				dataset_name="my_dataset"       )}       ),
        SplitDict({"train": SplitInfo(name="train"			,				num_bytes=13_37			,				num_examples=42       )}       ),
        SplitDict({"train": SplitInfo()}       ),
    ]			,				)
def _a (  SCREAMING_SNAKE_CASE__      :  SplitDict       )	->    str:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      Dict     =						split_dict._to_yaml_list()
							assert len(SCREAMING_SNAKE_CASE__       ) == len(SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						SplitDict._from_yaml_list(SCREAMING_SNAKE_CASE__       )
							for split_name, split_info in split_dict.items():
														# dataset_name field is deprecated, and is therefore not part of the YAML dump
														SCREAMING_SNAKE_CASE__       :      str     =						None
														# the split name of split_dict takes over the name of the split info object
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						split_name
							assert split_dict == reloaded







@pytest.mark.parametrize(
    "split_info"			,				[SplitInfo(), SplitInfo(dataset_name=SCREAMING_SNAKE_CASE__       ), SplitInfo(dataset_name="my_dataset"       )]       )
def _a (  SCREAMING_SNAKE_CASE__      :  Any       )	->    Dict:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      str     =						asdict(SplitDict({"train": split_info}       )       )
							assert "dataset_name" in split_dict_asdict["train"]
							assert split_dict_asdict["train"]["dataset_name"] == split_info.dataset_name






