


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        A_					(       __UpperCamelCase					,      __UpperCamelCase					,      unittest.TestCase    ):




      '''simple docstring'''


      __snake_case					       =   StableDiffusionParadigmsPipeline
      __snake_case					       =   TEXT_TO_IMAGE_PARAMS
      __snake_case					       =   TEXT_TO_IMAGE_BATCH_PARAMS
      __snake_case					       =   TEXT_TO_IMAGE_IMAGE_PARAMS
      __snake_case					       =   TEXT_TO_IMAGE_IMAGE_PARAMS




      def      _snake_case	(				self:       Optional[Any]				):
       torch.manual_seed(0				)
       __lowerCamelCase		:							Tuple							=						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=a						,      )
       __lowerCamelCase		:							Union[str, Any]							=						DDIMParallelScheduler(
           beta_start=0.0_0_0_8_5						,      beta_end=0.0_1_2						,      beta_schedule='scaled_linear'						,      clip_sample=a						,      set_alpha_to_one=a						,      )
       torch.manual_seed(0				)
       __lowerCamelCase		:							Any							=						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				)
       __lowerCamelCase		:							str							=						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						,      hidden_act='gelu'						,      projection_dim=512						,      )
       __lowerCamelCase		:							Dict							=						CLIPTextModel(a				)
       __lowerCamelCase		:							Optional[int]							=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)

       __lowerCamelCase		:							List[Any]							=						{
           'unet': unet,
           'scheduler': scheduler,
           'vae': vae,
           'text_encoder': text_encoder,
           'tokenizer': tokenizer,
           'safety_checker': None,
           'feature_extractor': None,
       }
       return components




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

       __lowerCamelCase		:							Optional[Any]							=						self.get_dummy_inputs(a				)
       __lowerCamelCase		:							List[Any]							=						sd_pipe(**a				).images
       __lowerCamelCase		:							str							=						image[0, -3:, -3:, -1]
       assert image.shape == (1, 64, 64, 3)

       __lowerCamelCase		:							str							=						np.array([0.4_7_7_3, 0.5_4_1_7, 0.4_7_2_3, 0.4_9_2_5, 0.5_6_3_1, 0.4_7_5_2, 0.5_2_4_0, 0.4_9_3_5, 0.5_0_2_3]				)

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




      def      _snake_case	(				self:       Optional[int]				):
       __lowerCamelCase		:							Dict							=						'cpu'  # ensure determinism for the device-dependent torch.Generator
       __lowerCamelCase		:							Union[str, Any]							=						self.get_dummy_components()
       torch.manual_seed(0				)
       __lowerCamelCase		:							Union[str, Any]							=						DDPMParallelScheduler()
       torch.manual_seed(0				)
       __lowerCamelCase		:							Optional[Any]							=						StableDiffusionParadigmsPipeline(**a				)
       __lowerCamelCase		:							Any							=						sd_pipe.to(a				)
       sd_pipe.set_progress_bar_config(disable=a				)

       __lowerCamelCase		:							List[str]							=						self.get_dummy_inputs(a				)
       __lowerCamelCase		:							Optional[Any]							=						sd_pipe(**a				).images
       __lowerCamelCase		:							Any							=						image[0, -3:, -3:, -1]
       assert image.shape == (1, 64, 64, 3)

       __lowerCamelCase		:							int							=						np.array([0.3_5_7_3, 0.4_4_2_0, 0.4_9_6_0, 0.4_7_9_9, 0.3_7_9_6, 0.3_8_7_9, 0.4_8_1_9, 0.4_3_6_5, 0.4_4_6_8]				)

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




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




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




      def      _snake_case	(				self:       Optional[int]				):
       __lowerCamelCase		:							Dict							=						'cpu'  # ensure determinism for the device-dependent torch.Generator
       __lowerCamelCase		:							Any							=						self.get_dummy_components()
       __lowerCamelCase		:							Optional[Any]							=						StableDiffusionParadigmsPipeline(**a				)
       __lowerCamelCase		:							Tuple							=						sd_pipe.to(a				)
       sd_pipe.set_progress_bar_config(disable=a				)

       __lowerCamelCase		:							List[str]							=						self.get_dummy_inputs(a				)
       __lowerCamelCase		:							Union[str, Any]							=						'french fries'
       __lowerCamelCase		:							Any							=						sd_pipe(**a						,      negative_prompt=a				)
       __lowerCamelCase		:							Optional[int]							=						output.images
       __lowerCamelCase		:							Tuple							=						image[0, -3:, -3:, -1]

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

       __lowerCamelCase		:							Dict							=						np.array([0.4_7_7_1, 0.5_4_2_0, 0.4_6_8_3, 0.4_9_1_8, 0.5_6_3_6, 0.4_7_2_5, 0.5_2_3_0, 0.4_9_2_3, 0.5_0_1_5]				)

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



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




      '''simple docstring'''


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




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

       __lowerCamelCase		:							Union[str, Any]							=						self.get_inputs()
       __lowerCamelCase		:							Optional[Any]							=						pipe(**a				).images
       __lowerCamelCase		:							Optional[Any]							=						image[0, -3:, -3:, -1].flatten()

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

       __lowerCamelCase		:							int							=						np.array([0.9_6_2_2, 0.9_6_0_2, 0.9_7_4_8, 0.9_5_9_1, 0.9_6_3_0, 0.9_6_9_1, 0.9_6_6_1, 0.9_6_3_1, 0.9_7_4_1]				)

       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()

