




'''simple docstring'''







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class 			_a  (	__a							,							__a							,							unittest.TestCase ):
       __a				:     str   				=					StableDiffusionSAGPipeline
       __a				:     List[Any]   				=					TEXT_TO_IMAGE_PARAMS
       __a				:     Dict   				=					TEXT_TO_IMAGE_BATCH_PARAMS
       __a				:     Optional[Any]   				=					TEXT_TO_IMAGE_IMAGE_PARAMS
       __a				:     Tuple   				=					TEXT_TO_IMAGE_IMAGE_PARAMS
       __a				:     int   				=					False
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           torch.manual_seed(0				)
           UpperCAmelCase			       =		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   ,				)
           UpperCAmelCase			       =		DDIMScheduler(
               beta_start=0.0_0085   ,				beta_end=0.012   ,				beta_schedule='''scaled_linear'''   ,				clip_sample=lowercase   ,				set_alpha_to_one=lowercase   ,				)
           torch.manual_seed(0				)
           UpperCAmelCase			       =		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				)
           UpperCAmelCase			       =		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=1_000   ,				)
           UpperCAmelCase			       =		CLIPTextModel(lowercase				)
           UpperCAmelCase			       =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

           UpperCAmelCase			       =		{
               '''unet''': unet,
               '''scheduler''': scheduler,
               '''vae''': vae,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''safety_checker''': None,
               '''feature_extractor''': None,
           }
           return components
       def     A      (	self						:	List[str]   ,				lowercase						:	Dict   ,				lowercase						:	Optional[int]=0				):



           '''simple docstring'''

           if str(lowercase				).startswith('''mps'''				):
               UpperCAmelCase			       =		torch.manual_seed(lowercase				)
           else:
               UpperCAmelCase			       =		torch.Generator(device=lowercase				).manual_seed(lowercase				)
           UpperCAmelCase			       =		{
               '''prompt''': '''.''',
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''guidance_scale''': 1.0,
               '''sag_scale''': 1.0,
               '''output_type''': '''numpy''',
           }
           return inputs







       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           super().test_inference_batch_single_identical(expected_max_diff=3E-3				)






@slow
@require_torch_gpu
class 			_a  (	unittest.TestCase ):
       def     A      (	self						:	Any				):



           '''simple docstring'''

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



           '''simple docstring'''

           UpperCAmelCase			       =		StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''				)
           UpperCAmelCase			       =		sag_pipe.to(lowercase				)
           sag_pipe.set_progress_bar_config(disable=lowercase				)

           UpperCAmelCase			       =		'''.'''
           UpperCAmelCase			       =		torch.manual_seed(0				)
           UpperCAmelCase			       =		sag_pipe(
               [prompt]   ,				generator=lowercase   ,				guidance_scale=7.5   ,				sag_scale=1.0   ,				num_inference_steps=20   ,				output_type='''np'''				)

           UpperCAmelCase			       =		output.images

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

           assert image.shape == (1, 512, 512, 3)
           UpperCAmelCase			       =		np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]				)

           assert np.abs(image_slice.flatten() - expected_slice				).max() < 5E-2
       def     A      (	self						:	Dict				):



           '''simple docstring'''

           UpperCAmelCase			       =		StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
           UpperCAmelCase			       =		sag_pipe.to(lowercase				)
           sag_pipe.set_progress_bar_config(disable=lowercase				)

           UpperCAmelCase			       =		'''.'''
           UpperCAmelCase			       =		torch.manual_seed(0				)
           UpperCAmelCase			       =		sag_pipe(
               [prompt]   ,				generator=lowercase   ,				guidance_scale=7.5   ,				sag_scale=1.0   ,				num_inference_steps=20   ,				output_type='''np'''				)

           UpperCAmelCase			       =		output.images

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

           assert image.shape == (1, 512, 512, 3)
           UpperCAmelCase			       =		np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]				)

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







       def     A      (	self						:	Tuple				):



           '''simple docstring'''

           UpperCAmelCase			       =		StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
           UpperCAmelCase			       =		sag_pipe.to(lowercase				)
           sag_pipe.set_progress_bar_config(disable=lowercase				)

           UpperCAmelCase			       =		'''.'''
           UpperCAmelCase			       =		torch.manual_seed(0				)
           UpperCAmelCase			       =		sag_pipe(
               [prompt]   ,				width=768   ,				height=512   ,				generator=lowercase   ,				guidance_scale=7.5   ,				sag_scale=1.0   ,				num_inference_steps=20   ,				output_type='''np'''   ,				)

           UpperCAmelCase			       =		output.images

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










from __future__ import annotations

lowercase__				:     str 		=						[
    [-1, 0],  # left
    [0, -1],  # down
    [1, 0],  # right
    [0, 1],  # up
]


def 						lowerCamelCase__    (		_A     ,	_A     ,	_A     ,	_A     ,	_A     ,	):







	'''simple docstring'''





	snake_case_		    =     [
	    [0 for col in range(len(grid[0]							)							)] for row in range(len(_A							)							)
	]  # the reference grid
	snake_case_		    =     1
	snake_case_		    =     [
	    [0 for col in range(len(grid[0]							)							)] for row in range(len(_A							)							)
	]  # the action grid

	snake_case_		    =     init[0]
	snake_case_		    =     init[1]
	snake_case_		    =     0
	snake_case_		    =     g + heuristic[x][y]  # cost from starting cell to destination cell
	snake_case_		    =     [[f, g, x, y]]

	snake_case_		    =     False  # flag that is set when search is complete
	snake_case_		    =     False  # flag set if we can't find expand

	while not found and not resign:
		if len(_A							) == 0:
			raise ValueError("Algorithm is unable to find solution"							)
		else:  # to choose the least costliest action so as to move closer to the goal
			cell.sort()
			cell.reverse()
			snake_case_		    =     cell.pop()
			snake_case_		    =     next_cell[2]
			snake_case_		    =     next_cell[3]
			snake_case_		    =     next_cell[1]

			if x == goal[0] and y == goal[1]:
				snake_case_		    =     True
			else:
				for i in range(len(_A							)							):  # to try out different valid actions
					snake_case_		    =     x + DIRECTIONS[i][0]
					snake_case_		    =     y + DIRECTIONS[i][1]
					if xa >= 0 and xa < len(_A							) and ya >= 0 and ya < len(grid[0]							):
						if closed[xa][ya] == 0 and grid[xa][ya] == 0:
							snake_case_		    =     g + cost
							snake_case_		    =     ga + heuristic[xa][ya]
							cell.append([fa, ga, xa, ya]							)
							snake_case_		    =     1
							snake_case_		    =     i
	snake_case_		    =     []
	snake_case_		    =     goal[0]
	snake_case_		    =     goal[1]
	invpath.append([x, y]							)  # we get the reverse path from here
	while x != init[0] or y != init[1]:
		snake_case_		    =     x - DIRECTIONS[action[x][y]][0]
		snake_case_		    =     y - DIRECTIONS[action[x][y]][1]
		snake_case_		    =     xa
		snake_case_		    =     ya
		invpath.append([x, y]							)

	snake_case_		    =     []
	for i in range(len(_A							)							):
		path.append(invpath[len(_A							) - 1 - i]							)
	return path, action


if __name__ == "__main__":
		lowercase__				:     Union[str, Any] 		=						[
		    [0, 1, 0, 0, 0, 0],
		    [0, 1, 0, 0, 0, 0],  # 0 are free path whereas 1's are obstacles
		    [0, 1, 0, 0, 0, 0],
		    [0, 1, 0, 0, 1, 0],
		    [0, 0, 0, 0, 1, 0],
		]

		lowercase__				:     Optional[Any] 		=						[0, 0]
		# all coordinates are given in format [y,x]
		lowercase__				:     Tuple 		=						[len(grid) - 1, len(grid[0]) - 1]
		lowercase__				:     Dict 		=						1

		# the cost map which pushes the path closer to the goal
		lowercase__				:     Any 		=						[[0 for row in range(len(grid[0]))] for col in range(len(grid))]
		for i in range(len(grid)):
				for j in range(len(grid[0])):
						lowercase__				:     Union[str, Any] 		=						abs(i - goal[0]) + abs(j - goal[1])
						if grid[i][j] == 1:
								# added extra penalty in the heuristic map
								lowercase__				:     int 		=						99

		lowercase__		,       lowercase__				:     Tuple 		=						search(grid, init, goal, cost, heuristic)

		print("ACTION MAP")
		for i in range(len(action)):
				print(action[i])

		for i in range(len(path)):
				print(path[i])
