




import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available


if is_torch_available():
		import numpy as np
		import torch

if is_vision_available():
		from PIL import Image





def 	__A	(			__lowerCamelCase					,    __lowerCamelCase=False					,    __lowerCamelCase=False					,    __lowerCamelCase=False					)   -> List[str]:
	assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

	a		       =							[]
	for i in range(image_processor_tester.batch_size					):
		if equal_resolution:
			a		       =							a		       =							image_processor_tester.max_resolution
		else:
			# To avoid getting image width/height 0
			a		       =							image_processor_tester.min_resolution
			if getattr(__lowerCamelCase					,    """size_divisor"""					,    __lowerCamelCase					):
				# If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
				a		       =							max(image_processor_tester.size_divisor					,    __lowerCamelCase					)
			a       ,				a		       =							np.random.choice(np.arange(__lowerCamelCase					,    image_processor_tester.max_resolution					)					,    2					)
		image_inputs.append(
		    np.random.randint(255					,    size=(image_processor_tester.num_channels, width, height)					,    dtype=np.uinta					)					)

	if not numpify and not torchify:
		# PIL expects the channel dimension as last dimension
		a		       =							[Image.fromarray(np.moveaxis(__lowerCamelCase					,    0					,    -1					)					) for image in image_inputs]

	if torchify:
		a		       =							[torch.from_numpy(__lowerCamelCase					) for image in image_inputs]

	return image_inputs





def 	__A	(			__lowerCamelCase					,    __lowerCamelCase=10					,    __lowerCamelCase=10					,    __lowerCamelCase=False					,    __lowerCamelCase=False					)   -> Union[str, Any]:
	a		       =							[]
	for i in range(image_processor_tester.num_frames					):
		video.append(np.random.randint(255					,    size=(image_processor_tester.num_channels, width, height)					,    dtype=np.uinta					)					)

	if not numpify and not torchify:
		# PIL expects the channel dimension as last dimension
		a		       =							[Image.fromarray(np.moveaxis(__lowerCamelCase					,    0					,    -1					)					) for frame in video]

	if torchify:
		a		       =							[torch.from_numpy(__lowerCamelCase					) for frame in video]

	return video





def 	__A	(			__lowerCamelCase					,    __lowerCamelCase=False					,    __lowerCamelCase=False					,    __lowerCamelCase=False					)   -> Tuple:
	assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

	a		       =							[]
	for i in range(image_processor_tester.batch_size					):
		if equal_resolution:
			a		       =							a		       =							image_processor_tester.max_resolution
		else:
			a       ,				a		       =							np.random.choice(
			    np.arange(image_processor_tester.min_resolution					,    image_processor_tester.max_resolution					)					,    2					)
			a		       =							prepare_video(
			    image_processor_tester=__lowerCamelCase					,    width=__lowerCamelCase					,    height=__lowerCamelCase					,    numpify=__lowerCamelCase					,    torchify=__lowerCamelCase					,    )
		video_inputs.append(__lowerCamelCase					)

	return video_inputs



class 	__lowerCAmelCase			:
							UpperCamelCase__        =						None
							def    lowerCamelCase__							(		self		:List[Any]       ):







								'''simple docstring'''







								a		       =							self.image_processing_class(**self.image_processor_dict       )
								a		       =							json.loads(image_processor.to_json_string()       )
								for key, value in self.image_processor_dict.items():
									self.assertEqual(obj[key]	,   __magic_name__       )
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							self.image_processing_class(**self.image_processor_dict       )

								with tempfile.TemporaryDirectory() as tmpdirname:
									a		       =							os.path.join(__magic_name__	,   """image_processor.json"""       )
									image_processor_first.to_json_file(__magic_name__       )
									a		       =							self.image_processing_class.from_json_file(__magic_name__       )

								self.assertEqual(image_processor_second.to_dict()	,   image_processor_first.to_dict()       )
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								a		       =							self.image_processing_class(**self.image_processor_dict       )

								with tempfile.TemporaryDirectory() as tmpdirname:
									a		       =							image_processor_first.save_pretrained(__magic_name__       )[0]
									check_json_file_has_correct_format(__magic_name__       )
									a		       =							self.image_processing_class.from_pretrained(__magic_name__       )

								self.assertEqual(image_processor_second.to_dict()	,   image_processor_first.to_dict()       )
							def    lowerCamelCase__							(		self		:str       ):







								'''simple docstring'''







								a		       =							self.image_processing_class()
								self.assertIsNotNone(__magic_name__       )





							@require_torch
							@require_vision
							def    lowerCamelCase__							(		self		:str       ):







								'''simple docstring'''







								if self.test_cast_dtype is not None:
									# Initialize image_processor
									a		       =							self.image_processing_class(**self.image_processor_dict       )

									# create random PyTorch tensors
									a		       =							prepare_image_inputs(self.image_processor_tester	,   equal_resolution=__magic_name__	,   torchify=__magic_name__       )

									a		       =							image_processor(__magic_name__	,   return_tensors="""pt"""       )
									# for layoutLM compatiblity
									self.assertEqual(encoding.pixel_values.device	,   torch.device("""cpu"""       )       )
									self.assertEqual(encoding.pixel_values.dtype	,   torch.floataa       )

									a		       =							image_processor(__magic_name__	,   return_tensors="""pt"""       ).to(torch.floataa       )
									self.assertEqual(encoding.pixel_values.device	,   torch.device("""cpu"""       )       )
									self.assertEqual(encoding.pixel_values.dtype	,   torch.floataa       )

									a		       =							image_processor(__magic_name__	,   return_tensors="""pt"""       ).to("""cpu"""	,   torch.bfloataa       )
									self.assertEqual(encoding.pixel_values.device	,   torch.device("""cpu"""       )       )
									self.assertEqual(encoding.pixel_values.dtype	,   torch.bfloataa       )

									with self.assertRaises(__magic_name__       ):
										a		       =							image_processor(__magic_name__	,   return_tensors="""pt"""       ).to(torch.bfloataa	,   """cpu"""       )

									# Try with text + image feature
									a		       =							image_processor(__magic_name__	,   return_tensors="""pt"""       )
									encoding.update({"""input_ids""": torch.LongTensor([[1, 2, 3], [4, 5, 6]]       )}       )
									a		       =							encoding.to(torch.floataa       )

									self.assertEqual(encoding.pixel_values.device	,   torch.device("""cpu"""       )       )
									self.assertEqual(encoding.pixel_values.dtype	,   torch.floataa       )
									self.assertEqual(encoding.input_ids.dtype	,   torch.long       )







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    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 	__lowerCAmelCase			(			__magic_name__   , __magic_name__   , unittest.TestCase				):
							UpperCamelCase__        =						StableDiffusionParadigmsPipeline
							UpperCamelCase__        =						TEXT_TO_IMAGE_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_IMAGE_PARAMS
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								torch.manual_seed(0       )
								a		       =							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	,   attention_head_dim=(2, 4)	,   use_linear_projection=__magic_name__	,   )
								a		       =							DDIMParallelScheduler(
								    beta_start=0.00085	,   beta_end=0.012	,   beta_schedule="""scaled_linear"""	,   clip_sample=__magic_name__	,   set_alpha_to_one=__magic_name__	,   )
								torch.manual_seed(0       )
								a		       =							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	,   sample_size=128	,   )
								torch.manual_seed(0       )
								a		       =							CLIPTextConfig(
								    bos_token_id=0	,   eos_token_id=2	,   hidden_size=32	,   intermediate_size=37	,   layer_norm_eps=1E-0_5	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1000	,   hidden_act="""gelu"""	,   projection_dim=512	,   )
								a		       =							CLIPTextModel(__magic_name__       )
								a		       =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

								a		       =							{
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """safety_checker""": None,
								    """feature_extractor""": None,
								}
								return components
							def    lowerCamelCase__							(		self		:Any	,   __magic_name__		:List[Any]	,   __magic_name__		:Tuple=0       ):







								'''simple docstring'''







								if str(__magic_name__       ).startswith("""mps"""       ):
									a		       =							torch.manual_seed(__magic_name__       )
								else:
									a		       =							torch.Generator(device=__magic_name__       ).manual_seed(__magic_name__       )
								a		       =							{
								    """prompt""": """a photograph of an astronaut riding a horse""",
								    """generator""": generator,
								    """num_inference_steps""": 10,
								    """guidance_scale""": 6.0,
								    """output_type""": """numpy""",
								    """parallel""": 3,
								    """debug""": True,
								}
								return inputs
							def    lowerCamelCase__							(		self		:Dict       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

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

								a		       =							np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								torch.manual_seed(0       )
								a		       =							DDPMParallelScheduler()
								torch.manual_seed(0       )
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

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

								a		       =							np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







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







								'''simple docstring'''







								super().test_inference_batch_single_identical(batch_size=2	,   expected_max_diff=3E-3       )





							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

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

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

								a		       =							np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]       )

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







@slow
@require_torch_gpu
class 	__lowerCAmelCase			(			unittest.TestCase				):
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							def    lowerCamelCase__							(		self		:str	,   __magic_name__		:Union[str, Any]=0       ):







								'''simple docstring'''







								a		       =							torch.Generator(device=__magic_name__       ).manual_seed(__magic_name__       )
								a		       =							{
								    """prompt""": """a photograph of an astronaut riding a horse""",
								    """generator""": generator,
								    """num_inference_steps""": 10,
								    """guidance_scale""": 7.5,
								    """output_type""": """numpy""",
								    """parallel""": 3,
								    """debug""": True,
								}
								return inputs





							def    lowerCamelCase__							(		self		:Dict       ):







								'''simple docstring'''







								a		       =							"""stabilityai/stable-diffusion-2-base"""
								a		       =							DDIMParallelScheduler.from_pretrained(__magic_name__	,   subfolder="""scheduler"""       )
								a		       =							StableDiffusionParadigmsPipeline.from_pretrained(__magic_name__	,   scheduler=__magic_name__	,   safety_checker=__magic_name__       )
								pipe.to(__magic_name__       )
								pipe.set_progress_bar_config(disable=__magic_name__       )
								pipe.enable_attention_slicing()

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

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

								a		       =							np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]       )

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

