


'''simple docstring'''


import gc
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, KandinskyVaaPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel
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 	lowerCAmelCase__			(			UpperCAmelCase__    ,       unittest.TestCase	):
			lowerCAmelCase :	List[str]          =     KandinskyVaaPipeline
			lowerCAmelCase :	Optional[Any]          =     [
			    "image_embeds",
			    "negative_image_embeds",
			]
			lowerCAmelCase :	List[str]          =     ["image_embeds", "negative_image_embeds"]
			lowerCAmelCase :	Dict          =     [
			    "generator",
			    "height",
			    "width",
			    "latents",
			    "guidance_scale",
			    "num_inference_steps",
			    "return_dict",
			    "guidance_scale",
			    "num_images_per_prompt",
			    "output_type",
			    "return_dict",
			]
			lowerCAmelCase :	Any          =     False




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



					'''simple docstring'''







					return 32




			@property
			def 							lowerCAmelCase__    (		self  :     List[Any] )   ->int:



					'''simple docstring'''







					return 32




			@property
			def 							lowerCAmelCase__    (		self  :     List[Any] )   ->Tuple:



					'''simple docstring'''







					return self.time_input_dim




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



					'''simple docstring'''







					return self.time_input_dim * 4




			@property
			def 							lowerCAmelCase__    (		self  :     int )   ->Union[str, Any]:



					'''simple docstring'''







					return 1_00




			@property
			def 							lowerCAmelCase__    (		self  :     Dict )   ->str:



					'''simple docstring'''







					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": "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": "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  :     Optional[Any] )   ->int:



					'''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  :     Tuple )   ->Optional[Any]:



					'''simple docstring'''







					torch.manual_seed(0 )
					_UpperCAmelCase		:       Any								=      VQModel(**self.dummy_movq_kwargs )
					return model




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



					'''simple docstring'''







					_UpperCAmelCase		:       Optional[int]								=      self.dummy_unet
					_UpperCAmelCase		:       List[Any]								=      self.dummy_movq

					_UpperCAmelCase		:       int								=      DDIMScheduler(
					    num_train_timesteps=10_00	,  beta_schedule="linear"	,  beta_start=0.0_0_0_8_5	,  beta_end=0.0_1_2	,  clip_sample=lowerCamelCase__	,  set_alpha_to_one=lowerCamelCase__	,  steps_offset=1	,  prediction_type="epsilon"	,  thresholding=lowerCamelCase__	,  )

					_UpperCAmelCase		:       Union[str, Any]								=      {
					    "unet": unet,
					    "scheduler": scheduler,
					    "movq": movq,
					}
					return components




			def 							lowerCAmelCase__    (		self  :     List[str]	,  lowerCamelCase__  :     Dict	,  lowerCamelCase__  :     List[Any]=0 )   ->List[str]:



					'''simple docstring'''







					_UpperCAmelCase		:       Optional[int]								=      floats_tensor((1, self.text_embedder_hidden_size)	,  rng=random.Random(lowerCamelCase__ ) ).to(lowerCamelCase__ )
					_UpperCAmelCase		:       Any								=      floats_tensor((1, self.text_embedder_hidden_size)	,  rng=random.Random(seed + 1 ) ).to(
					    lowerCamelCase__ )
					if str(lowerCamelCase__ ).startswith("mps" ):
							_UpperCAmelCase		:       Tuple								=      torch.manual_seed(lowerCamelCase__ )
					else:
							_UpperCAmelCase		:       Any								=      torch.Generator(device=lowerCamelCase__ ).manual_seed(lowerCamelCase__ )
					_UpperCAmelCase		:       Dict								=      {
					    "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  :     Any )   ->Optional[Any]:



					'''simple docstring'''







					_UpperCAmelCase		:       Optional[Any]								=      "cpu"

					_UpperCAmelCase		:       Tuple								=      self.get_dummy_components()

					_UpperCAmelCase		:       List[Any]								=      self.pipeline_class(**lowerCamelCase__ )
					_UpperCAmelCase		:       List[Any]								=      pipe.to(lowerCamelCase__ )

					pipe.set_progress_bar_config(disable=lowerCamelCase__ )

					_UpperCAmelCase		:       List[Any]								=      pipe(**self.get_dummy_inputs(lowerCamelCase__ ) )
					_UpperCAmelCase		:       Union[str, Any]								=      output.images

					_UpperCAmelCase		:       List[Any]								=      pipe(
					    **self.get_dummy_inputs(lowerCamelCase__ )	,  return_dict=lowerCamelCase__	,  )[0]

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

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

					_UpperCAmelCase		:       Tuple								=      np.array(
					    [0.6_2_3_7_9_7_6, 1.0, 0.3_6_4_4_1_3_3_2, 1.0, 0.7_0_6_3_9_6_3_4, 0.2_9_8_7_7_1_8_6, 0.8_5_6_5_2_1_2_5, 0.5_2_1_6_8_4_3, 0.5_4_4_5_4_0_4_6] )

					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 	lowerCAmelCase__			(			unittest.TestCase	):




			def 							lowerCAmelCase__    (		self  :     Tuple )   ->Dict:



					'''simple docstring'''







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






			def 							lowerCAmelCase__    (		self  :     str )   ->List[Any]:



					'''simple docstring'''







					_UpperCAmelCase		:       List[Any]								=      load_numpy(
					    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
					    "/kandinskyv22/kandinskyv22_text2img_cat_fp16.npy" )

					_UpperCAmelCase		:       List[Any]								=      KandinskyVaaPriorPipeline.from_pretrained(
					    "kandinsky-community/kandinsky-2-2-prior"	,  torch_dtype=torch.floataa )
					pipe_prior.to(lowerCamelCase__ )

					_UpperCAmelCase		:       List[Any]								=      KandinskyVaaPipeline.from_pretrained(
					    "kandinsky-community/kandinsky-2-2-decoder"	,  torch_dtype=torch.floataa )
					_UpperCAmelCase		:       Optional[int]								=      pipeline.to(lowerCamelCase__ )
					pipeline.set_progress_bar_config(disable=lowerCamelCase__ )

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

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

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

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

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

					assert_mean_pixel_difference(lowerCamelCase__	,  lowerCamelCase__ )







'''simple docstring'''


def  __lowerCAmelCase (__lowerCAmelCase   ):  # noqa: E741
		_UpperCAmelCase		:       List[str]								=      len(__lowerCAmelCase   )
		_UpperCAmelCase		:       str								=      0
		_UpperCAmelCase		:       List[str]								=      [0] * n
		_UpperCAmelCase		:       int								=      [False] * n
		_UpperCAmelCase		:       Dict								=      [False] * n

		def dfs(__lowerCAmelCase      , __lowerCAmelCase      , __lowerCAmelCase      , __lowerCAmelCase   ):
				if parent == root:
						out_edge_count += 1
				_UpperCAmelCase		:       List[Any]								=      True
				_UpperCAmelCase		:       str								=      at

				for to in l[at]:
						if to == parent:
								pass
						elif not visited[to]:
								_UpperCAmelCase		:       List[str]								=      dfs(__lowerCAmelCase      , __lowerCAmelCase      , __lowerCAmelCase      , __lowerCAmelCase   )
								_UpperCAmelCase		:       Tuple								=      min(low[at]      , low[to]   )

								# AP found via bridge
								if at < low[to]:
										_UpperCAmelCase		:       Dict								=      True
								# AP found via cycle
								if at == low[to]:
										_UpperCAmelCase		:       Dict								=      True
						else:
								_UpperCAmelCase		:       Optional[int]								=      min(low[at]      , __lowerCAmelCase   )
				return out_edge_count

		for i in range(__lowerCAmelCase   ):
				if not visited[i]:
						_UpperCAmelCase		:       str								=      0
						_UpperCAmelCase		:       Tuple								=      dfs(__lowerCAmelCase      , __lowerCAmelCase      , -1      , __lowerCAmelCase   )
						_UpperCAmelCase		:       Optional[int]								=      out_edge_count > 1

		for x in range(len(__lowerCAmelCase   )   ):
				if is_art[x] is True:
						print(__lowerCAmelCase   )


# Adjacency list of graph
lowerCamelCase__    	=     {
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
    3: [2, 4],
    4: [3],
    5: [2, 6, 8],
    6: [5, 7],
    7: [6, 8],
    8: [5, 7],
}





compute_ap(data)



