




from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
	from PIL import Image

	from transformers import ConvNextImageProcessor


class       SCREAMING_SNAKE_CASE_							:



	"""simple docstring"""


	def __init__(				self		:	List[Any]				,    lowerCAmelCase		:	Any				,    lowerCAmelCase		:	Optional[int]=13				,    lowerCAmelCase		:	List[Any]=32				,    lowerCAmelCase		:	Any=3				,    lowerCAmelCase		:	Any=4				,    lowerCAmelCase		:	Optional[Any]=[10, 20, 30, 40]				,    lowerCAmelCase		:	List[Any]=[2, 2, 3, 2]				,    lowerCAmelCase		:	Tuple=True				,    lowerCAmelCase		:	Tuple=True				,    lowerCAmelCase		:	Any=37				,    lowerCAmelCase		:	List[Any]="gelu"				,    lowerCAmelCase		:	Union[str, Any]=10				,    lowerCAmelCase		:	int=0.02				,    lowerCAmelCase		:	Any=3				,    lowerCAmelCase		:	Optional[int]=None				,    )  ->					str:







						"""simple docstring"""







						__UpperCamelCase				:  Optional[int]								=			parent
						__UpperCamelCase				:  Dict								=			batch_size
						__UpperCamelCase				:  Tuple								=			image_size
						__UpperCamelCase				:  Tuple								=			num_channels
						__UpperCamelCase				:  Optional[int]								=			num_stages
						__UpperCamelCase				:  List[str]								=			hidden_sizes
						__UpperCamelCase				:  str								=			depths
						__UpperCamelCase				:  str								=			is_training
						__UpperCamelCase				:  Any								=			use_labels
						__UpperCamelCase				:  Dict								=			intermediate_size
						__UpperCamelCase				:  Dict								=			hidden_act
						__UpperCamelCase				:  int								=			type_sequence_label_size
						__UpperCamelCase				:  Optional[int]								=			initializer_range
						__UpperCamelCase				:  Union[str, Any]								=			scope






	def 				lowerCamelCase__    (				self		:	Optional[Any]  )  ->					Tuple:







						"""simple docstring"""







						__UpperCamelCase				:  str								=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

						__UpperCamelCase				:  int								=			None
						if self.use_labels:
											__UpperCamelCase				:  Dict								=			ids_tensor([self.batch_size]				,    self.type_sequence_label_size  )

						__UpperCamelCase				:  int								=			self.get_config()

						return config, pixel_values, labels






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







						"""simple docstring"""







						return ConvNextConfig(
						    num_channels=self.num_channels				,    hidden_sizes=self.hidden_sizes				,    depths=self.depths				,    num_stages=self.num_stages				,    hidden_act=self.hidden_act				,    is_decoder=lowerCAmelCase				,    initializer_range=self.initializer_range				,    )






	def 				lowerCamelCase__    (				self		:	List[str]				,    lowerCAmelCase		:	int				,    lowerCAmelCase		:	Dict				,    lowerCAmelCase		:	Any  )  ->					List[Any]:







						"""simple docstring"""







						__UpperCamelCase				:  List[Any]								=			TFConvNextModel(config=lowerCAmelCase  )
						__UpperCamelCase				:  Optional[Any]								=			model(lowerCAmelCase				,    training=lowerCAmelCase  )
						# expected last hidden states: B, C, H // 32, W // 32
						self.parent.assertEqual(
						    result.last_hidden_state.shape				,    (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)				,    )






	def 				lowerCamelCase__    (				self		:	str				,    lowerCAmelCase		:	int				,    lowerCAmelCase		:	int				,    lowerCAmelCase		:	Any  )  ->					str:







						"""simple docstring"""







						__UpperCamelCase				:  int								=			self.type_sequence_label_size
						__UpperCamelCase				:  List[str]								=			TFConvNextForImageClassification(lowerCAmelCase  )
						__UpperCamelCase				:  Optional[int]								=			model(lowerCAmelCase				,    labels=lowerCAmelCase				,    training=lowerCAmelCase  )
						self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.type_sequence_label_size)  )






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







						"""simple docstring"""







						__UpperCamelCase				:  Any								=			self.prepare_config_and_inputs()
						__UpperCamelCase			, __UpperCamelCase			, __UpperCamelCase				:  int								=			config_and_inputs
						__UpperCamelCase				:  Tuple								=			{"""pixel_values""": pixel_values}
						return config, inputs_dict






@require_tf
class       SCREAMING_SNAKE_CASE_							(					_UpperCamelCase  ,     _UpperCamelCase  ,     unittest.TestCase      ):



	"""simple docstring"""


	__magic_name__      :					Dict			  =		(TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
	__magic_name__      :					Optional[Any]			  =		(
	    {'feature-extraction': TFConvNextModel, 'image-classification': TFConvNextForImageClassification}
	    if is_tf_available()
	    else {}
	)

	__magic_name__      :					Optional[Any]			  =		False
	__magic_name__      :					int			  =		False
	__magic_name__      :					Optional[int]			  =		False
	__magic_name__      :					List[str]			  =		False
	__magic_name__      :					List[str]			  =		False






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







						"""simple docstring"""







						__UpperCamelCase				:  Union[str, Any]								=			TFConvNextModelTester(self  )
						__UpperCamelCase				:  str								=			ConfigTester(
						    self				,    config_class=lowerCAmelCase				,    has_text_modality=lowerCAmelCase				,    hidden_size=37				,    )






	@unittest.skip(reason="""ConvNext does not use inputs_embeds"""  )
	def 				lowerCamelCase__    (				self		:	Tuple  )  ->					Union[str, Any]:







						"""simple docstring"""







						pass






	@unittest.skipIf(
	    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""  )  ) == 0				,    reason="""TF does not support backprop for grouped convolutions on CPU."""				,    )
	@slow
	def 				lowerCamelCase__    (				self		:	str  )  ->					List[Any]:







						"""simple docstring"""







						super().test_keras_fit()






	@unittest.skip(reason="""ConvNext does not support input and output embeddings"""  )
	def 				lowerCamelCase__    (				self		:	Union[str, Any]  )  ->					Optional[Any]:







						"""simple docstring"""







						pass






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







						"""simple docstring"""







						__UpperCamelCase			, __UpperCamelCase				:  Tuple								=			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__UpperCamelCase				:  Optional[Any]								=			model_class(lowerCAmelCase  )
											__UpperCamelCase				:  str								=			inspect.signature(model.call  )
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											__UpperCamelCase				:  str								=			[*signature.parameters.keys()]

											__UpperCamelCase				:  List[str]								=			["""pixel_values"""]
											self.assertListEqual(arg_names[:1]				,    lowerCAmelCase  )






	def 				lowerCamelCase__    (				self		:	int  )  ->					Dict:







						"""simple docstring"""







						__UpperCamelCase				:  Optional[Any]								=			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCAmelCase  )






	@unittest.skipIf(
	    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""  )  ) == 0				,    reason="""TF does not support backprop for grouped convolutions on CPU."""				,    )
	def 				lowerCamelCase__    (				self		:	str  )  ->					Dict:







						"""simple docstring"""







						super().test_dataset_conversion()






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







						"""simple docstring"""







						def check_hidden_states_output(lowerCAmelCase		:	Tuple				,    lowerCAmelCase		:	List[str]				,    lowerCAmelCase		:	List[str]  ):
											__UpperCamelCase				:  Union[str, Any]								=			model_class(lowerCAmelCase  )

											__UpperCamelCase				:  Any								=			model(**self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase  )  )
											__UpperCamelCase				:  Tuple								=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

											__UpperCamelCase				:  int								=			self.model_tester.num_stages
											self.assertEqual(len(lowerCAmelCase  )				,    expected_num_stages + 1  )

											# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]  )				,    [self.model_tester.image_size // 4, self.model_tester.image_size // 4]				,    )

						__UpperCamelCase			, __UpperCamelCase				:  Tuple								=			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__UpperCamelCase				:  Optional[Any]								=			True
											check_hidden_states_output(lowerCAmelCase				,    lowerCAmelCase				,    lowerCAmelCase  )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											__UpperCamelCase				:  Any								=			True

											check_hidden_states_output(lowerCAmelCase				,    lowerCAmelCase				,    lowerCAmelCase  )






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







						"""simple docstring"""







						__UpperCamelCase			, __UpperCamelCase				:  List[str]								=			self.model_tester.prepare_config_and_inputs_for_common()

						def check_equivalence(lowerCAmelCase		:	Tuple				,    lowerCAmelCase		:	Dict				,    lowerCAmelCase		:	List[Any]				,    lowerCAmelCase		:	str={}  ):
											__UpperCamelCase				:  Tuple								=			model(lowerCAmelCase				,    return_dict=lowerCAmelCase				,    **lowerCAmelCase  )
											__UpperCamelCase				:  int								=			model(lowerCAmelCase				,    return_dict=lowerCAmelCase				,    **lowerCAmelCase  ).to_tuple()

											def recursive_check(lowerCAmelCase		:	Optional[Any]				,    lowerCAmelCase		:	List[str]  ):
																if isinstance(lowerCAmelCase				,    (List, Tuple)  ):
																					for tuple_iterable_value, dict_iterable_value in zip(lowerCAmelCase				,    lowerCAmelCase  ):
																										recursive_check(lowerCAmelCase				,    lowerCAmelCase  )
																elif tuple_object is None:
																					return
																else:
																					self.assertTrue(
																					    all(tf.equal(lowerCAmelCase				,    lowerCAmelCase  )  )				,    msg=(
																					        """Tuple and dict output are not equal. Difference:"""
																					        F''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object  )  )}'''
																					    )				,    )

																recursive_check(lowerCAmelCase				,    lowerCAmelCase  )

						for model_class in self.all_model_classes:
											__UpperCamelCase				:  int								=			model_class(lowerCAmelCase  )

											__UpperCamelCase				:  int								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase  )
											__UpperCamelCase				:  Dict								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase  )
											check_equivalence(lowerCAmelCase				,    lowerCAmelCase				,    lowerCAmelCase  )

											__UpperCamelCase				:  List[Any]								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase				,    return_labels=lowerCAmelCase  )
											__UpperCamelCase				:  Union[str, Any]								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase				,    return_labels=lowerCAmelCase  )
											check_equivalence(lowerCAmelCase				,    lowerCAmelCase				,    lowerCAmelCase  )

											__UpperCamelCase				:  Any								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase  )
											__UpperCamelCase				:  Dict								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase  )
											check_equivalence(lowerCAmelCase				,    lowerCAmelCase				,    lowerCAmelCase				,    {"""output_hidden_states""": True}  )

											__UpperCamelCase				:  Tuple								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase				,    return_labels=lowerCAmelCase  )
											__UpperCamelCase				:  Tuple								=			self._prepare_for_class(lowerCAmelCase				,    lowerCAmelCase				,    return_labels=lowerCAmelCase  )
											check_equivalence(lowerCAmelCase				,    lowerCAmelCase				,    lowerCAmelCase				,    {"""output_hidden_states""": True}  )






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







						"""simple docstring"""







						__UpperCamelCase				:  Union[str, Any]								=			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase  )






	@slow
	def 				lowerCamelCase__    (				self		:	List[Any]  )  ->					Optional[Any]:







						"""simple docstring"""







						__UpperCamelCase				:  List[str]								=			TFConvNextModel.from_pretrained("""facebook/convnext-tiny-224"""  )
						self.assertIsNotNone(lowerCAmelCase  )






def 							A__   ()    ->	str:
					__UpperCamelCase				:  List[Any]								=			Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
					return image







@require_tf
@require_vision
class       SCREAMING_SNAKE_CASE_							(					unittest.TestCase      ):



	"""simple docstring"""


	@cached_property
	def 				lowerCamelCase__    (				self		:	Optional[int]  )  ->					Union[str, Any]:







						"""simple docstring"""







						return ConvNextImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""  ) if is_vision_available() else None






	@slow
	def 				lowerCamelCase__    (				self		:	List[Any]  )  ->					List[Any]:







						"""simple docstring"""







						__UpperCamelCase				:  Any								=			TFConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""  )

						__UpperCamelCase				:  List[Any]								=			self.default_image_processor
						__UpperCamelCase				:  List[str]								=			prepare_img()
						__UpperCamelCase				:  Optional[Any]								=			image_processor(images=lowerCAmelCase				,    return_tensors="""tf"""  )

						# forward pass
						__UpperCamelCase				:  Dict								=			model(**lowerCAmelCase  )

						# verify the logits
						__UpperCamelCase				:  Optional[int]								=			tf.TensorShape((1, 1000)  )
						self.assertEqual(outputs.logits.shape				,    lowerCAmelCase  )

						__UpperCamelCase				:  List[str]								=			tf.constant([-0.02_60, -0.47_39, 0.19_11]  )

						tf.debugging.assert_near(outputs.logits[0, :3]				,    lowerCAmelCase				,    atol=1E-4  )












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       SCREAMING_SNAKE_CASE_							(					_UpperCamelCase  ,     unittest.TestCase      ):



	"""simple docstring"""


	__magic_name__      :					str			  =		KandinskyPipeline
	__magic_name__      :					Optional[Any]			  =		[
	    'prompt',
	    'image_embeds',
	    'negative_image_embeds',
	]
	__magic_name__      :					int			  =		['prompt', 'negative_prompt', 'image_embeds', 'negative_image_embeds']
	__magic_name__      :					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',
	]
	__magic_name__      :					Optional[Any]			  =		False






	@property
	def 				lowerCamelCase__    (				self		:	Tuple  )  ->					Dict:







						"""simple docstring"""







						return 32






	@property
	def 				lowerCamelCase__    (				self		:	Tuple  )  ->					Optional[int]:







						"""simple docstring"""







						return 32






	@property
	def 				lowerCamelCase__    (				self		:	Any  )  ->					str:







						"""simple docstring"""







						return self.time_input_dim






	@property
	def 				lowerCamelCase__    (				self		:	Optional[Any]  )  ->					str:







						"""simple docstring"""







						return self.time_input_dim * 4






	@property
	def 				lowerCamelCase__    (				self		:	List[str]  )  ->					str:







						"""simple docstring"""







						return 100






	@property
	def 				lowerCamelCase__    (				self		:	Dict  )  ->					int:







						"""simple docstring"""







						__UpperCamelCase				:  Tuple								=			XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""  )
						return tokenizer






	@property
	def 				lowerCamelCase__    (				self		:	List[Any]  )  ->					List[str]:







						"""simple docstring"""







						torch.manual_seed(0  )
						__UpperCamelCase				:  Dict								=			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=1005				,    )

						__UpperCamelCase				:  Union[str, Any]								=			MultilingualCLIP(lowerCAmelCase  )
						__UpperCamelCase				:  Any								=			text_encoder.eval()

						return text_encoder






	@property
	def 				lowerCamelCase__    (				self		:	Tuple  )  ->					Dict:







						"""simple docstring"""







						torch.manual_seed(0  )

						__UpperCamelCase				:  str								=			{
						    """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				:  int								=			UNetaDConditionModel(**lowerCAmelCase  )
						return model






	@property
	def 				lowerCamelCase__    (				self		:	str  )  ->					str:







						"""simple docstring"""







						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 				lowerCamelCase__    (				self		:	Dict  )  ->					Optional[Any]:







						"""simple docstring"""







						torch.manual_seed(0  )
						__UpperCamelCase				:  Union[str, Any]								=			VQModel(**self.dummy_movq_kwargs  )
						return model






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







						"""simple docstring"""







						__UpperCamelCase				:  Union[str, Any]								=			self.dummy_text_encoder
						__UpperCamelCase				:  Optional[Any]								=			self.dummy_tokenizer
						__UpperCamelCase				:  Optional[Any]								=			self.dummy_unet
						__UpperCamelCase				:  List[str]								=			self.dummy_movq

						__UpperCamelCase				:  Any								=			DDIMScheduler(
						    num_train_timesteps=1000				,    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				:  Any								=			{
						    """text_encoder""": text_encoder,
						    """tokenizer""": tokenizer,
						    """unet""": unet,
						    """scheduler""": scheduler,
						    """movq""": movq,
						}
						return components






	def 				lowerCamelCase__    (				self		:	Optional[int]				,    lowerCAmelCase		:	Tuple				,    lowerCAmelCase		:	Dict=0  )  ->					Optional[int]:







						"""simple docstring"""







						__UpperCamelCase				:  str								=			floats_tensor((1, self.cross_attention_dim)				,    rng=random.Random(lowerCAmelCase  )  ).to(lowerCAmelCase  )
						__UpperCamelCase				:  Dict								=			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				:  Dict								=			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 				lowerCamelCase__    (				self		:	Optional[Any]  )  ->					List[str]:







						"""simple docstring"""







						__UpperCamelCase				:  Dict								=			"""cpu"""

						__UpperCamelCase				:  Optional[Any]								=			self.get_dummy_components()

						__UpperCamelCase				:  Optional[Any]								=			self.pipeline_class(**lowerCAmelCase  )
						__UpperCamelCase				:  Tuple								=			pipe.to(lowerCAmelCase  )

						pipe.set_progress_bar_config(disable=lowerCAmelCase  )

						__UpperCamelCase				:  Dict								=			pipe(**self.get_dummy_inputs(lowerCAmelCase  )  )
						__UpperCamelCase				:  Dict								=			output.images

						__UpperCamelCase				:  Optional[Any]								=			pipe(
						    **self.get_dummy_inputs(lowerCAmelCase  )				,    return_dict=lowerCAmelCase				,    )[0]

						__UpperCamelCase				:  Dict								=			image[0, -3:, -3:, -1]
						__UpperCamelCase				:  Dict								=			image_from_tuple[0, -3:, -3:, -1]

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

						__UpperCamelCase				:  Tuple								=			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       SCREAMING_SNAKE_CASE_							(					unittest.TestCase      ):



	"""simple docstring"""


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







						"""simple docstring"""







						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()






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







						"""simple docstring"""







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

						__UpperCamelCase				:  str								=			KandinskyPriorPipeline.from_pretrained(
						    """kandinsky-community/kandinsky-2-1-prior"""				,    torch_dtype=torch.floataa  )
						pipe_prior.to(lowerCAmelCase  )

						__UpperCamelCase				:  Union[str, Any]								=			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				:  List[Any]								=			"""red cat, 4k photo"""

						__UpperCamelCase				:  List[str]								=			torch.Generator(device="""cuda"""  ).manual_seed(0  )
						__UpperCamelCase			, __UpperCamelCase				:  List[Any]								=			pipe_prior(
						    lowerCAmelCase				,    generator=lowerCAmelCase				,    num_inference_steps=5				,    negative_prompt=""""""				,    ).to_tuple()

						__UpperCamelCase				:  List[Any]								=			torch.Generator(device="""cuda"""  ).manual_seed(0  )
						__UpperCamelCase				:  int								=			pipeline(
						    lowerCAmelCase				,    image_embeds=lowerCAmelCase				,    negative_image_embeds=lowerCAmelCase				,    generator=lowerCAmelCase				,    num_inference_steps=100				,    output_type="""np"""				,    )

						__UpperCamelCase				:  Optional[Any]								=			output.images[0]

						assert image.shape == (512, 512, 3)

						assert_mean_pixel_difference(lowerCAmelCase				,    lowerCAmelCase  )






