
import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
				import torch


__lowerCamelCase								=					random.Random()




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE=1.0      ,	_SCREAMING_SNAKE_CASE=None      ,	_SCREAMING_SNAKE_CASE=None  )   ->      Dict:

							"""simple docstring"""






							if rng is None:
														_UpperCAmelCase  :			Any	       =		global_rng

							_UpperCAmelCase  :			str	       =		[]
							for batch_idx in range(shape[0]  ):
														values.append([]  )
														for _ in range(shape[1]  ):
																					values[-1].append(rng.random() * scale  )

							return values
@require_torch
class    _UpperCamelCase(   unittest.TestCase				):

						def __init__(					self		:			List[Any]	,						_lowerCamelCase		:			List[Any]	,						_lowerCamelCase		:			List[str]=7	,						_lowerCamelCase		:			List[Any]=4_00	,						_lowerCamelCase		:			List[str]=20_00	,						_lowerCamelCase		:			Optional[int]=1	,						_lowerCamelCase		:			List[str]=0.0	,						_lowerCamelCase		:			List[str]=2_40_00	,						_lowerCamelCase		:			List[Any]=True	,						):
													_UpperCAmelCase  :			List[str]	       =		parent
													_UpperCAmelCase  :			Tuple	       =		batch_size
													_UpperCAmelCase  :			List[Any]	       =		min_seq_length
													_UpperCAmelCase  :			Optional[Any]	       =		max_seq_length
													_UpperCAmelCase  :			List[Any]	       =		(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
													_UpperCAmelCase  :			int	       =		feature_size
													_UpperCAmelCase  :			List[str]	       =		padding_value
													_UpperCAmelCase  :			Optional[int]	       =		sampling_rate
													_UpperCAmelCase  :			List[Any]	       =		return_attention_mask

						def 						a__ (					self		:			Optional[Any]			):
													return {
													    "feature_size": self.feature_size,
													    "padding_value": self.padding_value,
													    "sampling_rate": self.sampling_rate,
													    "return_attention_mask": self.return_attention_mask,
													}






						def 						a__ (					self		:			Dict	,						_lowerCamelCase		:			Tuple=False	,						_lowerCamelCase		:			Optional[Any]=False			):
													def _flatten(_lowerCamelCase		:			List[str]			):
																				return list(itertools.chain(*_lowerCamelCase			)			)

													if equal_length:
																				_UpperCAmelCase  :			int	       =		floats_list((self.batch_size, self.max_seq_length)			)
													else:
																				# make sure that inputs increase in size
																				_UpperCAmelCase  :			Any	       =		[
																				    _flatten(floats_list((x, self.feature_size)			)			)
																				    for x in range(self.min_seq_length	,						self.max_seq_length	,						self.seq_length_diff			)
																				]

													if numpify:
																				_UpperCAmelCase  :			Dict	       =		[np.asarray(_lowerCamelCase			) for x in audio_inputs]

													return audio_inputs







@require_torch
class    _UpperCamelCase(   SCREAMING_SNAKE_CASE		,						unittest.TestCase				):
						__A:						int				   =      EncodecFeatureExtractor

						def 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase  :			List[Any]	       =		EnCodecFeatureExtractionTester(self			)

						def 						a__ (					self		:			Optional[int]			):
													# Tests that all call wrap to encode_plus and batch_encode_plus
													_UpperCAmelCase  :			Union[str, Any]	       =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
													# create three inputs of length 800, 1000, and 1200
													_UpperCAmelCase  :			Tuple	       =		[floats_list((1, x)			)[0] for x in range(8_00	,						14_00	,						2_00			)]
													_UpperCAmelCase  :			Optional[int]	       =		[np.asarray(_lowerCamelCase			) for audio_input in audio_inputs]

													# Test not batched input
													_UpperCAmelCase  :			List[Any]	       =		feat_extract(audio_inputs[0]	,						return_tensors="np"			).input_values
													_UpperCAmelCase  :			List[Any]	       =		feat_extract(np_audio_inputs[0]	,						return_tensors="np"			).input_values
													self.assertTrue(np.allclose(_lowerCamelCase	,						_lowerCamelCase	,						atol=1E-3			)			)

													# Test batched
													_UpperCAmelCase  :			Union[str, Any]	       =		feat_extract(_lowerCamelCase	,						padding=_lowerCamelCase	,						return_tensors="np"			).input_values
													_UpperCAmelCase  :			Tuple	       =		feat_extract(_lowerCamelCase	,						padding=_lowerCamelCase	,						return_tensors="np"			).input_values
													for enc_seq_a, enc_seq_a in zip(_lowerCamelCase	,						_lowerCamelCase			):
																				self.assertTrue(np.allclose(_lowerCamelCase	,						_lowerCamelCase	,						atol=1E-3			)			)

						def 						a__ (					self		:			int			):
													_UpperCAmelCase  :			List[Any]	       =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
													_UpperCAmelCase  :			List[Any]	       =		np.random.rand(1_00			).astype(np.floataa			)
													_UpperCAmelCase  :			Optional[int]	       =		np_audio_inputs.tolist()

													for inputs in [py_audio_inputs, np_audio_inputs]:
																				_UpperCAmelCase  :			int	       =		feature_extractor.pad([{"input_values": inputs}]	,						return_tensors="np"			)
																				self.assertTrue(np_processed.input_values.dtype == np.floataa			)
																				_UpperCAmelCase  :			Tuple	       =		feature_extractor.pad([{"input_values": inputs}]	,						return_tensors="pt"			)
																				self.assertTrue(pt_processed.input_values.dtype == torch.floataa			)

						def 						a__ (					self		:			List[str]	,						_lowerCamelCase		:			Any			):
													from datasets import load_dataset

													_UpperCAmelCase  :			Optional[Any]	       =		load_dataset("hf-internal-testing/librispeech_asr_dummy"	,						"clean"	,						split="validation"			)
													# automatic decoding with librispeech
													_UpperCAmelCase  :			Union[str, Any]	       =		ds.sort("id"			).select(range(_lowerCamelCase			)			)[:num_samples]["audio"]

													return [x["array"] for x in audio_samples]

						def 						a__ (					self		:			int			):
													# fmt: off
													_UpperCAmelCase  :			Tuple	       =		torch.tensor(
													    [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
													     3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
													     2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
													     4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
													     7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
													     4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]			)
													# fmt: on
													_UpperCAmelCase  :			Any	       =		self._load_datasamples(1			)
													_UpperCAmelCase  :			Optional[Any]	       =		EncodecFeatureExtractor()
													_UpperCAmelCase  :			List[Any]	       =		feature_extractor(_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(input_values.shape	,						(1, 1, 9_36_80)			)
													self.assertTrue(torch.allclose(input_values[0, 0, :30]	,						_lowerCamelCase	,						atol=1E-6			)			)

						def 						a__ (					self		:			str			):
													# fmt: off
													_UpperCAmelCase  :			Dict	       =		torch.tensor(
													    [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
													     3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
													     2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
													     4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
													     7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
													     4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]			)
													# fmt: on
													_UpperCAmelCase  :			Union[str, Any]	       =		self._load_datasamples(1			)
													_UpperCAmelCase  :			Dict	       =		[np.tile(input_audio[0][None]	,						reps=(2, 1)			)]
													input_audio[0][1] *= 0.5
													_UpperCAmelCase  :			List[Any]	       =		EncodecFeatureExtractor(feature_size=2			)
													_UpperCAmelCase  :			List[str]	       =		feature_extractor(_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(input_values.shape	,						(1, 2, 9_36_80)			)
													self.assertTrue(torch.allclose(input_values[0, 0, :30]	,						_lowerCamelCase	,						atol=1E-6			)			)
													self.assertTrue(torch.allclose(input_values[0, 1, :30]	,						EXPECTED_INPUT_VALUES * 0.5	,						atol=1E-6			)			)






						def 						a__ (					self		:			List[str]			):
													_UpperCAmelCase  :			Any	       =		self._load_datasamples(2			)
													# would be easier if the stride was like
													_UpperCAmelCase  :			List[str]	       =		EncodecFeatureExtractor(feature_size=1	,						chunk_length_s=1	,						overlap=0.01			)

													# pad and trunc raise an error ?
													with self.assertRaisesRegex(
													    _lowerCamelCase	,						"^Both padding and truncation were set. Make sure you only set one.$"	,						):
																				_UpperCAmelCase  :			List[Any]	       =		feature_extractor(
																				    _lowerCamelCase	,						padding="max_length"	,						truncation=_lowerCamelCase	,						return_tensors="pt"			).input_values

													# truncate to chunk
													_UpperCAmelCase  :			List[str]	       =		feature_extractor(_lowerCamelCase	,						truncation=_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(truncated_outputs.shape	,						(2, 1, 7_15_20)			)  # 2 chunks

													# force truncate to max_length
													_UpperCAmelCase  :			Dict	       =		feature_extractor(
													    _lowerCamelCase	,						truncation=_lowerCamelCase	,						max_length=4_80_00	,						return_tensors="pt"			).input_values
													self.assertEquals(truncated_outputs.shape	,						(2, 1, 4_80_00)			)

													# pad to chunk
													_UpperCAmelCase  :			int	       =		feature_extractor(_lowerCamelCase	,						padding=_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(padded_outputs.shape	,						(2, 1, 9_52_80)			)

													# pad to chunk
													_UpperCAmelCase  :			List[str]	       =		feature_extractor(_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(truncated_outputs.shape	,						(2, 1, 9_52_80)			)

													# force pad to max length
													_UpperCAmelCase  :			List[str]	       =		feature_extractor(
													    _lowerCamelCase	,						padding="max_length"	,						max_length=10_00_00	,						return_tensors="pt"			).input_values
													self.assertEquals(truncated_outputs.shape	,						(2, 1, 10_00_00)			)

													# force no pad
													with self.assertRaisesRegex(
													    _lowerCamelCase	,						"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"	,						):
																				_UpperCAmelCase  :			Any	       =		feature_extractor(_lowerCamelCase	,						padding=_lowerCamelCase	,						return_tensors="pt"			).input_values

													_UpperCAmelCase  :			Any	       =		feature_extractor(input_audio[0]	,						padding=_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(truncated_outputs.shape	,						(1, 1, 9_36_80)			)

													# no pad if no chunk_length_s
													_UpperCAmelCase  :			str	       =		None
													with self.assertRaisesRegex(
													    _lowerCamelCase	,						"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"	,						):
																				_UpperCAmelCase  :			Union[str, Any]	       =		feature_extractor(_lowerCamelCase	,						padding=_lowerCamelCase	,						return_tensors="pt"			).input_values

													_UpperCAmelCase  :			List[Any]	       =		feature_extractor(input_audio[0]	,						padding=_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(truncated_outputs.shape	,						(1, 1, 9_36_80)			)

													# no pad if no overlap
													_UpperCAmelCase  :			Optional[int]	       =		2
													_UpperCAmelCase  :			Tuple	       =		None
													with self.assertRaisesRegex(
													    _lowerCamelCase	,						"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"	,						):
																				_UpperCAmelCase  :			Dict	       =		feature_extractor(_lowerCamelCase	,						padding=_lowerCamelCase	,						return_tensors="pt"			).input_values

													_UpperCAmelCase  :			Optional[int]	       =		feature_extractor(input_audio[0]	,						padding=_lowerCamelCase	,						return_tensors="pt"			).input_values
													self.assertEquals(truncated_outputs.shape	,						(1, 1, 9_36_80)			)






import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()
class    _UpperCamelCase(   SCREAMING_SNAKE_CASE		,						unittest.TestCase				):
						__A:						Dict				   =      KandinskyPipeline
						__A:						List[Any]				   =      [
						    """prompt""",
						    """image_embeds""",
						    """negative_image_embeds""",
						]
						__A:						Dict				   =      ["""prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds"""]
						__A:						List[str]				   =      [
						    """generator""",
						    """height""",
						    """width""",
						    """latents""",
						    """guidance_scale""",
						    """negative_prompt""",
						    """num_inference_steps""",
						    """return_dict""",
						    """guidance_scale""",
						    """num_images_per_prompt""",
						    """output_type""",
						    """return_dict""",
						]
						__A:						List[str]				   =      False

						@property
						def 						a__ (					self		:			List[Any]			):
													return 32

						@property
						def 						a__ (					self		:			Tuple			):
													return 32

						@property
						def 						a__ (					self		:			List[Any]			):
													return self.time_input_dim

						@property
						def 						a__ (					self		:			List[Any]			):
													return self.time_input_dim * 4

						@property
						def 						a__ (					self		:			Dict			):
													return 1_00

						@property
						def 						a__ (					self		:			Tuple			):
													_UpperCAmelCase  :			Optional[int]	       =		XLMRobertaTokenizerFast.from_pretrained("YiYiXu/tiny-random-mclip-base"			)
													return tokenizer

						@property
						def 						a__ (					self		:			Tuple			):
													torch.manual_seed(0			)
													_UpperCAmelCase  :			int	       =		MCLIPConfig(
													    numDims=self.cross_attention_dim	,						transformerDimensions=self.text_embedder_hidden_size	,						hidden_size=self.text_embedder_hidden_size	,						intermediate_size=37	,						num_attention_heads=4	,						num_hidden_layers=5	,						vocab_size=10_05	,						)

													_UpperCAmelCase  :			Optional[Any]	       =		MultilingualCLIP(_lowerCamelCase			)
													_UpperCAmelCase  :			str	       =		text_encoder.eval()

													return text_encoder

						@property
						def 						a__ (					self		:			Any			):
													torch.manual_seed(0			)

													_UpperCAmelCase  :			Any	       =		{
													    "in_channels": 4,
													    # Out channels is double in channels because predicts mean and variance
													    "out_channels": 8,
													    "addition_embed_type": "text_image",
													    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
													    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
													    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
													    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
													    "layers_per_block": 1,
													    "encoder_hid_dim": self.text_embedder_hidden_size,
													    "encoder_hid_dim_type": "text_image_proj",
													    "cross_attention_dim": self.cross_attention_dim,
													    "attention_head_dim": 4,
													    "resnet_time_scale_shift": "scale_shift",
													    "class_embed_type": None,
													}

													_UpperCAmelCase  :			Optional[Any]	       =		UNetaDConditionModel(**_lowerCamelCase			)
													return model

						@property
						def 						a__ (					self		:			Optional[Any]			):
													return {
													    "block_out_channels": [32, 64],
													    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
													    "in_channels": 3,
													    "latent_channels": 4,
													    "layers_per_block": 1,
													    "norm_num_groups": 8,
													    "norm_type": "spatial",
													    "num_vq_embeddings": 12,
													    "out_channels": 3,
													    "up_block_types": [
													        "AttnUpDecoderBlock2D",
													        "UpDecoderBlock2D",
													    ],
													    "vq_embed_dim": 4,
													}

						@property
						def 						a__ (					self		:			Tuple			):
													torch.manual_seed(0			)
													_UpperCAmelCase  :			Dict	       =		VQModel(**self.dummy_movq_kwargs			)
													return model

						def 						a__ (					self		:			List[Any]			):
													_UpperCAmelCase  :			Union[str, Any]	       =		self.dummy_text_encoder
													_UpperCAmelCase  :			Any	       =		self.dummy_tokenizer
													_UpperCAmelCase  :			List[Any]	       =		self.dummy_unet
													_UpperCAmelCase  :			Union[str, Any]	       =		self.dummy_movq

													_UpperCAmelCase  :			str	       =		DDIMScheduler(
													    num_train_timesteps=10_00	,						beta_schedule="linear"	,						beta_start=0.0_00_85	,						beta_end=0.0_12	,						clip_sample=_lowerCamelCase	,						set_alpha_to_one=_lowerCamelCase	,						steps_offset=1	,						prediction_type="epsilon"	,						thresholding=_lowerCamelCase	,						)

													_UpperCAmelCase  :			Optional[Any]	       =		{
													    "text_encoder": text_encoder,
													    "tokenizer": tokenizer,
													    "unet": unet,
													    "scheduler": scheduler,
													    "movq": movq,
													}
													return components

						def 						a__ (					self		:			int	,						_lowerCamelCase		:			Any	,						_lowerCamelCase		:			List[str]=0			):
													_UpperCAmelCase  :			Tuple	       =		floats_tensor((1, self.cross_attention_dim)	,						rng=random.Random(_lowerCamelCase			)			).to(_lowerCamelCase			)
													_UpperCAmelCase  :			Tuple	       =		floats_tensor((1, self.cross_attention_dim)	,						rng=random.Random(seed + 1			)			).to(_lowerCamelCase			)
													if str(_lowerCamelCase			).startswith("mps"			):
																				_UpperCAmelCase  :			Union[str, Any]	       =		torch.manual_seed(_lowerCamelCase			)
													else:
																				_UpperCAmelCase  :			Optional[Any]	       =		torch.Generator(device=_lowerCamelCase			).manual_seed(_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		{
													    "prompt": "horse",
													    "image_embeds": image_embeds,
													    "negative_image_embeds": negative_image_embeds,
													    "generator": generator,
													    "height": 64,
													    "width": 64,
													    "guidance_scale": 4.0,
													    "num_inference_steps": 2,
													    "output_type": "np",
													}
													return inputs






						def 						a__ (					self		:			List[Any]			):
													_UpperCAmelCase  :			Optional[Any]	       =		"cpu"

													_UpperCAmelCase  :			Dict	       =		self.get_dummy_components()

													_UpperCAmelCase  :			Any	       =		self.pipeline_class(**_lowerCamelCase			)
													_UpperCAmelCase  :			Optional[int]	       =		pipe.to(_lowerCamelCase			)

													pipe.set_progress_bar_config(disable=_lowerCamelCase			)

													_UpperCAmelCase  :			Dict	       =		pipe(**self.get_dummy_inputs(_lowerCamelCase			)			)
													_UpperCAmelCase  :			int	       =		output.images

													_UpperCAmelCase  :			Tuple	       =		pipe(
													    **self.get_dummy_inputs(_lowerCamelCase			)	,						return_dict=_lowerCamelCase	,						)[0]

													_UpperCAmelCase  :			Any	       =		image[0, -3:, -3:, -1]
													_UpperCAmelCase  :			Optional[Any]	       =		image_from_tuple[0, -3:, -3:, -1]

													assert image.shape == (1, 64, 64, 3)

													_UpperCAmelCase  :			Dict	       =		np.array(
													    [0.32_86_63, 1.0, 0.23_21_68_73, 1.0, 0.92_71_75_64, 0.4_63_90_46, 0.96_89_47_77, 0.31_71_33_78, 0.6_29_39_53]			)

													assert (
													    np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
													), f""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
													assert (
													    np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1E-2
													), f""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""







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

						def 						a__ (					self		:			int			):
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()






						def 						a__ (					self		:			str			):
													_UpperCAmelCase  :			List[str]	       =		load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
													    "/kandinsky/kandinsky_text2img_cat_fp16.npy"			)

													_UpperCAmelCase  :			Dict	       =		KandinskyPriorPipeline.from_pretrained(
													    "kandinsky-community/kandinsky-2-1-prior"	,						torch_dtype=torch.floataa			)
													pipe_prior.to(_lowerCamelCase			)

													_UpperCAmelCase  :			str	       =		KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1"	,						torch_dtype=torch.floataa			)
													_UpperCAmelCase  :			Union[str, Any]	       =		pipeline.to(_lowerCamelCase			)
													pipeline.set_progress_bar_config(disable=_lowerCamelCase			)

													_UpperCAmelCase  :			Tuple	       =		"red cat, 4k photo"

													_UpperCAmelCase  :			List[Any]	       =		torch.Generator(device="cuda"			).manual_seed(0			)
													_UpperCAmelCase       ,_UpperCAmelCase  :			int	       =		pipe_prior(
													    _lowerCamelCase	,						generator=_lowerCamelCase	,						num_inference_steps=5	,						negative_prompt=""	,						).to_tuple()

													_UpperCAmelCase  :			Tuple	       =		torch.Generator(device="cuda"			).manual_seed(0			)
													_UpperCAmelCase  :			Dict	       =		pipeline(
													    _lowerCamelCase	,						image_embeds=_lowerCamelCase	,						negative_image_embeds=_lowerCamelCase	,						generator=_lowerCamelCase	,						num_inference_steps=1_00	,						output_type="np"	,						)

													_UpperCAmelCase  :			Tuple	       =		output.images[0]

													assert image.shape == (5_12, 5_12, 3)

													assert_mean_pixel_difference(_lowerCamelCase	,						_lowerCamelCase			)




