





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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


enable_full_determinism()

@skip_mps
class SCREAMING_SNAKE_CASE_ (					__a							,       __a							,       unittest.TestCase   ):





     """simple docstring"""


     A__				 =    StableDiffusionPanoramaPipeline
     A__				 =    TEXT_TO_IMAGE_PARAMS
     A__				 =    TEXT_TO_IMAGE_BATCH_PARAMS
     A__				 =    TEXT_TO_IMAGE_IMAGE_PARAMS
     A__				 =    TEXT_TO_IMAGE_IMAGE_PARAMS





     def 					__magic_name__ ( self	):
          torch.manual_seed(0	)
          lowerCamelCase__       =       UNetaDConditionModel(
              block_out_channels=(32, 64)	,  layers_per_block=1	,  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()
          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	,  )
          torch.manual_seed(0	)
          lowerCamelCase__       =       CLIPTextConfig(
              bos_token_id=0	,  eos_token_id=2	,  hidden_size=32	,  intermediate_size=37	,  layer_norm_eps=1E-05	,  num_attention_heads=4	,  num_hidden_layers=5	,  pad_token_id=1	,  vocab_size=1000	,  )
          lowerCamelCase__       =       CLIPTextModel(A__	)
          lowerCamelCase__       =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

          lowerCamelCase__       =       {
              "unet": unet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "safety_checker": None,
              "feature_extractor": None,
          }
          return components





     def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase=0	):
          lowerCamelCase__       =       torch.manual_seed(A__	)
          lowerCamelCase__       =       {
              "prompt": "a photo of the dolomites",
              "generator": generator,
              # Setting height and width to None to prevent OOMs on CPU.
              "height": None,
              "width": None,
              "num_inference_steps": 1,
              "guidance_scale": 6.0,
              "output_type": "numpy",
          }
          return inputs





     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       =       self.get_dummy_components()
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline(**A__	)
          lowerCamelCase__       =       sd_pipe.to(A__	)
          sd_pipe.set_progress_bar_config(disable=A__	)

          lowerCamelCase__       =       self.get_dummy_inputs(A__	)
          lowerCamelCase__       =       sd_pipe(**A__	).images
          lowerCamelCase__       =       image[0, -3:, -3:, -1]
          assert image.shape == (1, 64, 64, 3)

          lowerCamelCase__       =       np.array([0.6_186, 0.5_374, 0.4_915, 0.4_135, 0.4_114, 0.4_563, 0.5_128, 0.4_977, 0.4_757]	)

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





     def 					__magic_name__ ( self	):
          super().test_inference_batch_consistent(batch_sizes=[1, 2]	)





     def 					__magic_name__ ( self	):
          super().test_inference_batch_single_identical(batch_size=2	,  expected_max_diff=3.25E-3	)





     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       =       self.get_dummy_components()
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline(**A__	)
          lowerCamelCase__       =       sd_pipe.to(A__	)
          sd_pipe.set_progress_bar_config(disable=A__	)

          lowerCamelCase__       =       self.get_dummy_inputs(A__	)
          lowerCamelCase__       =       "french fries"
          lowerCamelCase__       =       sd_pipe(**A__	,  negative_prompt=A__	)
          lowerCamelCase__       =       output.images
          lowerCamelCase__       =       image[0, -3:, -3:, -1]

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

          lowerCamelCase__       =       np.array([0.6_187, 0.5_375, 0.4_915, 0.4_136, 0.4_114, 0.4_563, 0.5_128, 0.4_976, 0.4_757]	)

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





     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       =       self.get_dummy_components()
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline(**A__	)
          lowerCamelCase__       =       sd_pipe.to(A__	)
          sd_pipe.set_progress_bar_config(disable=A__	)

          lowerCamelCase__       =       self.get_dummy_inputs(A__	)
          lowerCamelCase__       =       sd_pipe(**A__	,  view_batch_size=2	)
          lowerCamelCase__       =       output.images
          lowerCamelCase__       =       image[0, -3:, -3:, -1]

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

          lowerCamelCase__       =       np.array([0.6_187, 0.5_375, 0.4_915, 0.4_136, 0.4_114, 0.4_563, 0.5_128, 0.4_976, 0.4_757]	)

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





     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       =       self.get_dummy_components()
          lowerCamelCase__       =       EulerAncestralDiscreteScheduler(
              beta_start=0.00_085	,  beta_end=0.012	,  beta_schedule="scaled_linear"	)
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline(**A__	)
          lowerCamelCase__       =       sd_pipe.to(A__	)
          sd_pipe.set_progress_bar_config(disable=A__	)

          lowerCamelCase__       =       self.get_dummy_inputs(A__	)
          lowerCamelCase__       =       sd_pipe(**A__	).images
          lowerCamelCase__       =       image[0, -3:, -3:, -1]

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

          lowerCamelCase__       =       np.array([0.4_024, 0.6_510, 0.4_901, 0.5_378, 0.5_813, 0.5_622, 0.4_795, 0.4_467, 0.4_952]	)

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






     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       =       self.get_dummy_components()
          lowerCamelCase__       =       PNDMScheduler(
              beta_start=0.00_085	,  beta_end=0.012	,  beta_schedule="scaled_linear"	,  skip_prk_steps=A__	)
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline(**A__	)
          lowerCamelCase__       =       sd_pipe.to(A__	)
          sd_pipe.set_progress_bar_config(disable=A__	)

          lowerCamelCase__       =       self.get_dummy_inputs(A__	)
          lowerCamelCase__       =       sd_pipe(**A__	).images
          lowerCamelCase__       =       image[0, -3:, -3:, -1]

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

          lowerCamelCase__       =       np.array([0.6_391, 0.6_291, 0.4_861, 0.5_134, 0.5_552, 0.4_578, 0.5_032, 0.5_023, 0.4_539]	)

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

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





     """simple docstring"""


     def 					__magic_name__ ( self	):
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()





     def 					__magic_name__ ( self	,  _lowerCAmelCase=0	):
          lowerCamelCase__       =       torch.manual_seed(A__	)
          lowerCamelCase__       =       {
              "prompt": "a photo of the dolomites",
              "generator": generator,
              "num_inference_steps": 3,
              "guidance_scale": 7.5,
              "output_type": "numpy",
          }
          return inputs





     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       "stabilityai/stable-diffusion-2-base"
          lowerCamelCase__       =       DDIMScheduler.from_pretrained(A__	,  subfolder="scheduler"	)
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline.from_pretrained(A__	,  scheduler=A__	,  safety_checker=A__	)
          pipe.to(A__	)
          pipe.set_progress_bar_config(disable=A__	)
          pipe.enable_attention_slicing()

          lowerCamelCase__       =       self.get_inputs()
          lowerCamelCase__       =       pipe(**A__	).images
          lowerCamelCase__       =       image[0, -3:, -3:, -1].flatten()

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

          lowerCamelCase__       =       np.array(
              [
                  0.36_968_392,
                  0.27_025_372,
                  0.32_446_766,
                  0.28_379_387,
                  0.36_363_274,
                  0.30_733_347,
                  0.27_100_027,
                  0.27_054_125,
                  0.25_536_096,
              ]	)

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





     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline.from_pretrained(
              "stabilityai/stable-diffusion-2-base"	,  safety_checker=A__	)
          lowerCamelCase__       =       LMSDiscreteScheduler.from_config(pipe.scheduler.config	)
          pipe.to(A__	)
          pipe.set_progress_bar_config(disable=A__	)
          pipe.enable_attention_slicing()

          lowerCamelCase__       =       self.get_inputs()
          lowerCamelCase__       =       pipe(**A__	).images
          lowerCamelCase__       =       image[0, -3:, -3:, -1].flatten()

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

          lowerCamelCase__       =       np.array(
              [
                  [
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                  ]
              ]	)

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





     def 					__magic_name__ ( self	):
          lowerCamelCase__       =       0

          def callback_fn(_lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	) -> None:
               lowerCamelCase__       =       True
               nonlocal number_of_steps
               number_of_steps += 1
               if step == 1:
                    lowerCamelCase__       =       latents.detach().cpu().numpy()
                    assert latents.shape == (1, 4, 64, 256)
                    lowerCamelCase__       =       latents[0, -3:, -3:, -1]

                    lowerCamelCase__       =       np.array(
                        [
                            0.18_681_869,
                            0.33_907_816,
                            0.5_361_276,
                            0.14_432_865,
                            -0.02_856_611,
                            -0.73_941_123,
                            0.23_397_987,
                            0.47_322_682,
                            -0.37_823_164,
                        ]	)
                    assert np.abs(latents_slice.flatten() - expected_slice	).max() < 5E-2
               elif step == 2:
                    lowerCamelCase__       =       latents.detach().cpu().numpy()
                    assert latents.shape == (1, 4, 64, 256)
                    lowerCamelCase__       =       latents[0, -3:, -3:, -1]

                    lowerCamelCase__       =       np.array(
                        [
                            0.18_539_645,
                            0.33_987_248,
                            0.5_378_559,
                            0.14_437_142,
                            -0.02_455_261,
                            -0.7_338_317,
                            0.23_990_755,
                            0.47_356_272,
                            -0.3_786_505,
                        ]	)

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

          lowerCamelCase__       =       False

          lowerCamelCase__       =       "stabilityai/stable-diffusion-2-base"
          lowerCamelCase__       =       DDIMScheduler.from_pretrained(A__	,  subfolder="scheduler"	)
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline.from_pretrained(A__	,  scheduler=A__	,  safety_checker=A__	)
          lowerCamelCase__       =       pipe.to(A__	)
          pipe.set_progress_bar_config(disable=A__	)
          pipe.enable_attention_slicing()

          lowerCamelCase__       =       self.get_inputs()
          pipe(**A__	,  callback=A__	,  callback_steps=1	)
          assert callback_fn.has_been_called
          assert number_of_steps == 3






     def 					__magic_name__ ( self	):
          torch.cuda.empty_cache()
          torch.cuda.reset_max_memory_allocated()
          torch.cuda.reset_peak_memory_stats()

          lowerCamelCase__       =       "stabilityai/stable-diffusion-2-base"
          lowerCamelCase__       =       DDIMScheduler.from_pretrained(A__	,  subfolder="scheduler"	)
          lowerCamelCase__       =       StableDiffusionPanoramaPipeline.from_pretrained(A__	,  scheduler=A__	,  safety_checker=A__	)
          lowerCamelCase__       =       pipe.to(A__	)
          pipe.set_progress_bar_config(disable=A__	)
          pipe.enable_attention_slicing(1	)
          pipe.enable_sequential_cpu_offload()

          lowerCamelCase__       =       self.get_inputs()
          lowerCamelCase__       =       pipe(**A__	)

          lowerCamelCase__       =       torch.cuda.max_memory_allocated()
          # make sure that less than 5.2 GB is allocated
          assert mem_bytes < 5.5 * 10**9








def    __UpperCamelCase      (    a,     a) ->Dict:
					print("\nThe shortest path matrix using Floyd Warshall algorithm\n")
					for i in range(a):
										for j in range(a):
															if dist[i][j] != float("inf"):
																				print(int(dist[i][j]),     end="\t")
															else:
																				print("INF",     end="\t")
										print()





def    __UpperCamelCase      (    a,     a) ->Optional[int]:
					lowerCamelCase__       =       [[float("inf") for _ in range(a)] for _ in range(a)]

					for i in range(a):
										for j in range(a):
															lowerCamelCase__       =       graph[i][j]

															# check vertex k against all other vertices (i, j)
					for k in range(a):
										# looping through rows of graph array
										for i in range(a):
															# looping through columns of graph array
															for j in range(a):
																				if (
																				    dist[i][k] != float("inf")
																				    and dist[k][j] != float("inf")
																				    and dist[i][k] + dist[k][j] < dist[i][j]
																				):
																									lowerCamelCase__       =       dist[i][k] + dist[k][j]

					_print_dist(a,     a)
					return dist, v


if __name__ == "__main__":
						A_												=     int(input("Enter number of vertices: "))
						A_												=     int(input("Enter number of edges: "))

						A_												=     [[float("inf") for i in range(v)] for j in range(v)]

						for i in range(v):
												A_												=     0.0

												# src and dst are indices that must be within the array size graph[e][v]
												# failure to follow this will result in an error
						for i in range(e):
												print("\nEdge ", i + 1)
												A_												=     int(input("Enter source:"))
												A_												=     int(input("Enter destination:"))
												A_												=     float(input("Enter weight:"))
												A_												=     weight

						floyd_warshall(graph, v)

						# Example Input
						# Enter number of vertices: 3
						# Enter number of edges: 2

						# # generated graph from vertex and edge inputs
						# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
						# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

						# specify source, destination and weight for edge #1
						# Edge  1
						# Enter source:1
						# Enter destination:2
						# Enter weight:2

						# specify source, destination and weight for edge #2
						# Edge  2
						# Enter source:2
						# Enter destination:1
						# Enter weight:1

						# # Expected Output from the vertice, edge and src, dst, weight inputs!!
						# 0		INF	INF
						# INF	0	2
						# INF	1	0

