
import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class 			_lowerCAmelCase      (			__a      ,   __a      ,   __a      ,   unittest.TestCase ):
				_lowercase    	=AltDiffusionPipeline
				_lowercase    	=TEXT_TO_IMAGE_PARAMS
				_lowercase    	=TEXT_TO_IMAGE_BATCH_PARAMS
				_lowercase    	=TEXT_TO_IMAGE_IMAGE_PARAMS
				_lowercase    	=TEXT_TO_IMAGE_IMAGE_PARAMS




				def   __a		(      self  )       ->   Optional[int]:
							torch.manual_seed(0  )
							lowerCAmelCase_      			=			UNetaDConditionModel(
							    block_out_channels=(32, 64)       ,       layers_per_block=2       ,       sample_size=32       ,       in_channels=4       ,       out_channels=4       ,       down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")       ,       up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")       ,       cross_attention_dim=32       ,       )
							lowerCAmelCase_      			=			DDIMScheduler(
							    beta_start=0.00085       ,       beta_end=0.012       ,       beta_schedule="scaled_linear"       ,       clip_sample=UpperCamelCase_       ,       set_alpha_to_one=UpperCamelCase_       ,       )
							torch.manual_seed(0  )
							lowerCAmelCase_      			=			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       ,       )

							# TODO: address the non-deterministic text encoder (fails for save-load tests)
							# torch.manual_seed(0)
							# text_encoder_config = RobertaSeriesConfig(
							#     hidden_size=32,
							#     project_dim=32,
							#     intermediate_size=37,
							#     layer_norm_eps=1e-05,
							#     num_attention_heads=4,
							#     num_hidden_layers=5,
							#     vocab_size=5002,
							# )
							# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

							torch.manual_seed(0  )
							lowerCAmelCase_      			=			CLIPTextConfig(
							    bos_token_id=0       ,       eos_token_id=2       ,       hidden_size=32       ,       projection_dim=32       ,       intermediate_size=37       ,       layer_norm_eps=1e-0_5       ,       num_attention_heads=4       ,       num_hidden_layers=5       ,       pad_token_id=1       ,       vocab_size=5_002       ,       )
							lowerCAmelCase_      			=			CLIPTextModel(UpperCamelCase_  )

							lowerCAmelCase_      			=			XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta"  )
							lowerCAmelCase_      			=			77

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




				def   __a		(      self       ,       _UpperCamelCase       ,       _UpperCamelCase=0  )       ->   Optional[int]:





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




				def   __a		(      self  )       ->   int:
							super().test_attention_slicing_forward_pass(expected_max_diff=3e-3  )




				def   __a		(      self  )       ->   Any:
							super().test_inference_batch_single_identical(expected_max_diff=3e-3  )




				def   __a		(      self  )       ->   Dict:
							lowerCAmelCase_      			=			'cpu'  # ensure determinism for the device-dependent torch.Generator

							lowerCAmelCase_      			=			self.get_dummy_components()
							torch.manual_seed(0  )
							lowerCAmelCase_      			=			RobertaSeriesConfig(
							    hidden_size=32       ,       project_dim=32       ,       intermediate_size=37       ,       layer_norm_eps=1e-0_5       ,       num_attention_heads=4       ,       num_hidden_layers=5       ,       vocab_size=5_002       ,       )
							# TODO: remove after fixing the non-deterministic text encoder
							lowerCAmelCase_      			=			RobertaSeriesModelWithTransformation(UpperCamelCase_  )
							lowerCAmelCase_      			=			text_encoder

							lowerCAmelCase_      			=			AltDiffusionPipeline(**UpperCamelCase_  )
							lowerCAmelCase_      			=			alt_pipe.to(UpperCamelCase_  )
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_  )

							lowerCAmelCase_      			=			self.get_dummy_inputs(UpperCamelCase_  )
							lowerCAmelCase_      			=			'A photo of an astronaut'
							lowerCAmelCase_      			=			alt_pipe(**UpperCamelCase_  )
							lowerCAmelCase_      			=			output.images
							lowerCAmelCase_      			=			image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							lowerCAmelCase_      			=			np.array(
							    [0.5748162, 0.60447145, 0.48821217, 0.50100636, 0.5431185, 0.45763683, 0.49657696, 0.48132733, 0.47573093]  )

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




				def   __a		(      self  )       ->   List[str]:
							lowerCAmelCase_      			=			'cpu'  # ensure determinism for the device-dependent torch.Generator

							lowerCAmelCase_      			=			self.get_dummy_components()
							lowerCAmelCase_      			=			PNDMScheduler(skip_prk_steps=UpperCamelCase_  )
							torch.manual_seed(0  )
							lowerCAmelCase_      			=			RobertaSeriesConfig(
							    hidden_size=32       ,       project_dim=32       ,       intermediate_size=37       ,       layer_norm_eps=1e-0_5       ,       num_attention_heads=4       ,       num_hidden_layers=5       ,       vocab_size=5_002       ,       )
							# TODO: remove after fixing the non-deterministic text encoder
							lowerCAmelCase_      			=			RobertaSeriesModelWithTransformation(UpperCamelCase_  )
							lowerCAmelCase_      			=			text_encoder
							lowerCAmelCase_      			=			AltDiffusionPipeline(**UpperCamelCase_  )
							lowerCAmelCase_      			=			alt_pipe.to(UpperCamelCase_  )
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_  )

							lowerCAmelCase_      			=			self.get_dummy_inputs(UpperCamelCase_  )
							lowerCAmelCase_      			=			alt_pipe(**UpperCamelCase_  )
							lowerCAmelCase_      			=			output.images
							lowerCAmelCase_      			=			image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							lowerCAmelCase_      			=			np.array(
							    [0.51605093, 0.5707241, 0.47365507, 0.50578886, 0.5633877, 0.4642503, 0.5182081, 0.48763484, 0.49084237]  )

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





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




				def   __a		(      self  )       ->   Union[str, Any]:
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




				def   __a		(      self  )       ->   int:
							lowerCAmelCase_      			=			AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion"       ,       safety_checker=UpperCamelCase_  )
							lowerCAmelCase_      			=			alt_pipe.to(UpperCamelCase_  )
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_  )

							lowerCAmelCase_      			=			'A painting of a squirrel eating a burger'
							lowerCAmelCase_      			=			torch.manual_seed(0  )
							lowerCAmelCase_      			=			alt_pipe([prompt]       ,       generator=UpperCamelCase_       ,       guidance_scale=6.0       ,       num_inference_steps=20       ,       output_type="np"  )

							lowerCAmelCase_      			=			output.images

							lowerCAmelCase_      			=			image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							lowerCAmelCase_      			=			np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]  )

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




				def   __a		(      self  )       ->   int:
							lowerCAmelCase_      			=			DDIMScheduler.from_pretrained("BAAI/AltDiffusion"       ,       subfolder="scheduler"  )

							lowerCAmelCase_      			=			AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion"       ,       scheduler=UpperCamelCase_       ,       safety_checker=UpperCamelCase_  )
							lowerCAmelCase_      			=			alt_pipe.to(UpperCamelCase_  )
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_  )

							lowerCAmelCase_      			=			'A painting of a squirrel eating a burger'
							lowerCAmelCase_      			=			torch.manual_seed(0  )

							lowerCAmelCase_      			=			alt_pipe([prompt]       ,       generator=UpperCamelCase_       ,       num_inference_steps=2       ,       output_type="numpy"  )
							lowerCAmelCase_      			=			output.images

							lowerCAmelCase_      			=			image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							lowerCAmelCase_      			=			np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]  )

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





import math





class 			_lowerCAmelCase      :




				def __init__(      self       ,       _UpperCamelCase=0  )       ->   Tuple:  # a graph with Node 0,1,...,N-1
							lowerCAmelCase_      			=			n
							lowerCAmelCase_      			=			[
							    [math.inf for j in range(0       ,       _UpperCamelCase  )] for i in range(0       ,       _UpperCamelCase  )
							]  # adjacency matrix for weight
							lowerCAmelCase_      			=			[
							    [math.inf for j in range(0       ,       _UpperCamelCase  )] for i in range(0       ,       _UpperCamelCase  )
							]  # dp[i][j] stores minimum distance from i to j




				def   __a		(      self       ,       _UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase  )       ->   List[Any]:
							lowerCAmelCase_      			=			w




				def   __a		(      self  )       ->   List[str]:
							for k in range(0       ,       self.n  ):
										for i in range(0       ,       self.n  ):
													for j in range(0       ,       self.n  ):
																lowerCAmelCase_      			=			min(self.dp[i][j]       ,       self.dp[i][k] + self.dp[k][j]  )




				def   __a		(      self       ,       _UpperCamelCase       ,       _UpperCamelCase  )       ->   Dict:
							return self.dp[u][v]


if __name__ == "__main__":
			_A     =  Graph(5)
			graph.add_edge(0, 2, 9)
			graph.add_edge(0, 4, 10)
			graph.add_edge(1, 3, 5)
			graph.add_edge(2, 3, 7)
			graph.add_edge(3, 0, 10)
			graph.add_edge(3, 1, 2)
			graph.add_edge(3, 2, 1)
			graph.add_edge(3, 4, 6)
			graph.add_edge(4, 1, 3)
			graph.add_edge(4, 2, 4)
			graph.add_edge(4, 3, 9)
			graph.floyd_warshall()
			graph.show_min(1, 4)
			graph.show_min(0, 3)



