



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  _snake_case	(    __UpperCamelCase			,		__UpperCamelCase			,		unittest.TestCase):
				UpperCamelCase__ :    Dict   						=StableDiffusionParadigmsPipeline
				UpperCamelCase__ :    Optional[int]   						=TEXT_TO_IMAGE_PARAMS
				UpperCamelCase__ :    Optional[int]   						=TEXT_TO_IMAGE_BATCH_PARAMS
				UpperCamelCase__ :    Dict   						=TEXT_TO_IMAGE_IMAGE_PARAMS
				UpperCamelCase__ :    List[str]   						=TEXT_TO_IMAGE_IMAGE_PARAMS




				def 							A__					(  self    :  Optional[Any]  ):
							torch.manual_seed(0  )
							lowercase__         = 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=__lowercase,    )
							lowercase__         = DDIMParallelScheduler(
							    beta_start=0.00085,    beta_end=0.012,    beta_schedule="scaled_linear",    clip_sample=__lowercase,    set_alpha_to_one=__lowercase,    )
							torch.manual_seed(0  )
							lowercase__         = 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  )
							lowercase__         = 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,    )
							lowercase__         = CLIPTextModel(__lowercase  )
							lowercase__         = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"  )

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




				def 							A__					(  self    :  int,    __lowercase    :  str,    __lowercase    :  int=0  ):
							if str(__lowercase  ).startswith("mps"  ):
										lowercase__         = torch.manual_seed(__lowercase  )
							else:
										lowercase__         = torch.Generator(device=__lowercase  ).manual_seed(__lowercase  )
							lowercase__         = {
							    '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 							A__					(  self    :  List[str]  ):
							lowercase__         = 'cpu'  # ensure determinism for the device-dependent torch.Generator
							lowercase__         = self.get_dummy_components()
							lowercase__         = StableDiffusionParadigmsPipeline(**__lowercase  )
							lowercase__         = sd_pipe.to(__lowercase  )
							sd_pipe.set_progress_bar_config(disable=__lowercase  )

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

							lowercase__         = 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 							A__					(  self    :  Optional[int]  ):
							lowercase__         = 'cpu'  # ensure determinism for the device-dependent torch.Generator
							lowercase__         = self.get_dummy_components()
							torch.manual_seed(0  )
							lowercase__         = DDPMParallelScheduler()
							torch.manual_seed(0  )
							lowercase__         = StableDiffusionParadigmsPipeline(**__lowercase  )
							lowercase__         = sd_pipe.to(__lowercase  )
							sd_pipe.set_progress_bar_config(disable=__lowercase  )

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

							lowercase__         = 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 							A__					(  self    :  str  ):
							super().test_inference_batch_consistent(batch_sizes=[1, 2]  )




				def 							A__					(  self    :  Any  ):
							super().test_inference_batch_single_identical(batch_size=2,    expected_max_diff=3e-3  )




				def 							A__					(  self    :  Optional[int]  ):
							lowercase__         = 'cpu'  # ensure determinism for the device-dependent torch.Generator
							lowercase__         = self.get_dummy_components()
							lowercase__         = StableDiffusionParadigmsPipeline(**__lowercase  )
							lowercase__         = sd_pipe.to(__lowercase  )
							sd_pipe.set_progress_bar_config(disable=__lowercase  )

							lowercase__         = self.get_dummy_inputs(__lowercase  )
							lowercase__         = 'french fries'
							lowercase__         = sd_pipe(**__lowercase,    negative_prompt=__lowercase  )
							lowercase__         = output.images
							lowercase__         = image[0, -3:, -3:, -1]

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

							lowercase__         = 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  _snake_case	(    unittest.TestCase):




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




				def 							A__					(  self    :  Optional[Any],    __lowercase    :  str=0  ):
							lowercase__         = torch.Generator(device=__lowercase  ).manual_seed(__lowercase  )
							lowercase__         = {
							    '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 							A__					(  self    :  int  ):
							lowercase__         = 'stabilityai/stable-diffusion-2-base'
							lowercase__         = DDIMParallelScheduler.from_pretrained(__lowercase,    subfolder="scheduler"  )
							lowercase__         = StableDiffusionParadigmsPipeline.from_pretrained(__lowercase,    scheduler=__lowercase,    safety_checker=__lowercase  )
							pipe.to(__lowercase  )
							pipe.set_progress_bar_config(disable=__lowercase  )
							pipe.enable_attention_slicing()

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

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

							lowercase__         = 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








from __future__ import annotations
def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase					,     __lowerCamelCase		:							str							=						m - 1, 0
 while i >= 0 and j < n:
  if key == mat[i][j]:
   print(f'Key {key} found at row- {i + 1} column- {j + 1}'						)
   return
  if key < mat[i][j]:
   i -= 1
  else:
   j += 1
 print(f'Key {key} not found'						)
def       UpperCamelCase__     (  ):
 __lowerCamelCase		:							List[Any]							=						[[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
 __lowerCamelCase		:							int							=						int(input('Enter the element to be searched:'						)						)
 print(SCREAMING_SNAKE_CASE__						)
 search_in_a_sorted_matrix(SCREAMING_SNAKE_CASE__			,       len(SCREAMING_SNAKE_CASE__						)			,       len(mat[0]						)			,       SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()

