






"""simple docstring"""
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_      (	snake_case_  ,						snake_case_  ,						unittest.TestCase ):







      '''simple docstring'''

      lowerCamelCase__       :				int =	StableDiffusionParadigmsPipeline
      lowerCamelCase__       :				str =	TEXT_TO_IMAGE_PARAMS
      lowerCamelCase__       :				int =	TEXT_TO_IMAGE_BATCH_PARAMS
      lowerCamelCase__       :				Optional[int] =	TEXT_TO_IMAGE_IMAGE_PARAMS
      lowerCamelCase__       :				Any =	TEXT_TO_IMAGE_IMAGE_PARAMS




      def 			a__							(self					):

       '''simple docstring'''



       torch.manual_seed(0					)
       lowerCamelCase__     :			str     				=						UNetaDConditionModel(
           block_out_channels=(3_2, 6_4),     layers_per_block=2,     sample_size=3_2,     in_channels=4,     out_channels=4,     down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),     up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'),     cross_attention_dim=3_2,     attention_head_dim=(2, 4),     use_linear_projection=lowerCamelCase_,     )
       lowerCamelCase__     :			Any     				=						DDIMParallelScheduler(
           beta_start=0.00_085,     beta_end=0.012,     beta_schedule='scaled_linear',     clip_sample=lowerCamelCase_,     set_alpha_to_one=lowerCamelCase_,     )
       torch.manual_seed(0					)
       lowerCamelCase__     :			Optional[int]     				=						AutoencoderKL(
           block_out_channels=[3_2, 6_4],     in_channels=3,     out_channels=3,     down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'],     up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'],     latent_channels=4,     sample_size=1_2_8,     )
       torch.manual_seed(0					)
       lowerCamelCase__     :			Union[str, Any]     				=						CLIPTextConfig(
           bos_token_id=0,     eos_token_id=2,     hidden_size=3_2,     intermediate_size=3_7,     layer_norm_eps=1e-05,     num_attention_heads=4,     num_hidden_layers=5,     pad_token_id=1,     vocab_size=1_0_0_0,     hidden_act='gelu',     projection_dim=5_1_2,     )
       lowerCamelCase__     :			int     				=						CLIPTextModel(lowerCamelCase_					)
       lowerCamelCase__     :			Union[str, Any]     				=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

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




      def 			a__							(self,     lowerCamelCase_,     lowerCamelCase_=0					):

       '''simple docstring'''



       if str(lowerCamelCase_					).startswith('mps'					):
        lowerCamelCase__     :			Optional[int]     				=						torch.manual_seed(lowerCamelCase_					)
       else:
        lowerCamelCase__     :			Dict     				=						torch.Generator(device=lowerCamelCase_					).manual_seed(lowerCamelCase_					)
       lowerCamelCase__     :			str     				=						{
           'prompt': 'a photograph of an astronaut riding a horse',
           'generator': generator,
           'num_inference_steps': 1_0,
           'guidance_scale': 6.0,
           'output_type': 'numpy',
           'parallel': 3,
           'debug': True,
       }
       return inputs




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			List[str]     				=						'cpu'  # ensure determinism for the device-dependent torch.Generator
       lowerCamelCase__     :			List[str]     				=						self.get_dummy_components()
       lowerCamelCase__     :			List[str]     				=						StableDiffusionParadigmsPipeline(**lowerCamelCase_					)
       lowerCamelCase__     :			Union[str, Any]     				=						sd_pipe.to(lowerCamelCase_					)
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

       lowerCamelCase__     :			Optional[Any]     				=						self.get_dummy_inputs(lowerCamelCase_					)
       lowerCamelCase__     :			Dict     				=						sd_pipe(**lowerCamelCase_					).images
       lowerCamelCase__     :			int     				=						image[0, -3:, -3:, -1]
       assert image.shape == (1, 6_4, 6_4, 3)

       lowerCamelCase__     :			Tuple     				=						np.array([0.4_773, 0.5_417, 0.4_723, 0.4_925, 0.5_631, 0.4_752, 0.5_240, 0.4_935, 0.5_023]					)

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




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Union[str, Any]     				=						'cpu'  # ensure determinism for the device-dependent torch.Generator
       lowerCamelCase__     :			Union[str, Any]     				=						self.get_dummy_components()
       torch.manual_seed(0					)
       lowerCamelCase__     :			Optional[Any]     				=						DDPMParallelScheduler()
       torch.manual_seed(0					)
       lowerCamelCase__     :			List[str]     				=						StableDiffusionParadigmsPipeline(**lowerCamelCase_					)
       lowerCamelCase__     :			Union[str, Any]     				=						sd_pipe.to(lowerCamelCase_					)
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

       lowerCamelCase__     :			List[str]     				=						self.get_dummy_inputs(lowerCamelCase_					)
       lowerCamelCase__     :			List[Any]     				=						sd_pipe(**lowerCamelCase_					).images
       lowerCamelCase__     :			int     				=						image[0, -3:, -3:, -1]
       assert image.shape == (1, 6_4, 6_4, 3)

       lowerCamelCase__     :			Optional[int]     				=						np.array([0.3_573, 0.4_420, 0.4_960, 0.4_799, 0.3_796, 0.3_879, 0.4_819, 0.4_365, 0.4_468]					)

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




      def 			a__							(self					):

       '''simple docstring'''



       super().test_inference_batch_consistent(batch_sizes=[1, 2]					)




      def 			a__							(self					):

       '''simple docstring'''



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





      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Optional[Any]     				=						'cpu'  # ensure determinism for the device-dependent torch.Generator
       lowerCamelCase__     :			Union[str, Any]     				=						self.get_dummy_components()
       lowerCamelCase__     :			Union[str, Any]     				=						StableDiffusionParadigmsPipeline(**lowerCamelCase_					)
       lowerCamelCase__     :			Dict     				=						sd_pipe.to(lowerCamelCase_					)
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

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

       assert image.shape == (1, 6_4, 6_4, 3)

       lowerCamelCase__     :			str     				=						np.array([0.4_771, 0.5_420, 0.4_683, 0.4_918, 0.5_636, 0.4_725, 0.5_230, 0.4_923, 0.5_015]					)

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



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







      '''simple docstring'''

      def 			a__							(self					):

       '''simple docstring'''



       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()




      def 			a__							(self,     lowerCamelCase_=0					):

       '''simple docstring'''



       lowerCamelCase__     :			Optional[int]     				=						torch.Generator(device=lowerCamelCase_					).manual_seed(lowerCamelCase_					)
       lowerCamelCase__     :			Optional[Any]     				=						{
           'prompt': 'a photograph of an astronaut riding a horse',
           'generator': generator,
           'num_inference_steps': 1_0,
           'guidance_scale': 7.5,
           'output_type': 'numpy',
           'parallel': 3,
           'debug': True,
       }
       return inputs





      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Any     				=						'stabilityai/stable-diffusion-2-base'
       lowerCamelCase__     :			int     				=						DDIMParallelScheduler.from_pretrained(lowerCamelCase_,     subfolder='scheduler'					)
       lowerCamelCase__     :			Union[str, Any]     				=						StableDiffusionParadigmsPipeline.from_pretrained(lowerCamelCase_,     scheduler=lowerCamelCase_,     safety_checker=lowerCamelCase_					)
       pipe.to(lowerCamelCase_					)
       pipe.set_progress_bar_config(disable=lowerCamelCase_					)
       pipe.enable_attention_slicing()

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

       assert image.shape == (1, 5_1_2, 5_1_2, 3)

       lowerCamelCase__     :			str     				=						np.array([0.9_622, 0.9_602, 0.9_748, 0.9_591, 0.9_630, 0.9_691, 0.9_661, 0.9_631, 0.9_741]					)

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









"""simple docstring"""
from cva import destroyAllWindows, imread, imshow, waitKey






def        lowerCamelCase_  (						_lowerCamelCase			,   _lowerCamelCase				):
 lowerCamelCase__				,     lowerCamelCase__     :			Optional[Any]     				=						img.shape[0], img.shape[1]

 def to_grayscale(_lowerCamelCase			,   _lowerCamelCase			,   _lowerCamelCase				):
  return 0.2_126 * red + 0.587 * green + 0.114 * blue

 def normalize(_lowerCamelCase				):
  return min(_lowerCamelCase			,   255				)

 for i in range(_lowerCamelCase				):
  for j in range(_lowerCamelCase				):
   lowerCamelCase__     :			List[Any]     				=						int(to_grayscale(*img[i][j]				)				)
   lowerCamelCase__     :			Optional[int]     				=						[
       normalize(_lowerCamelCase				),
       normalize(greyscale + factor				),
       normalize(greyscale + 2 * factor				),
   ]

 return img


if __name__ == "__main__":
      # read original image
      A_			: List[str]				=			{
          percentage: imread("image_data/lena.jpg", 1) for percentage in (10, 20, 30, 40)
      }

      for percentage, img in images.items():
            make_sepia(img, percentage)

      for percentage, img in images.items():
            imshow(f"Original image with sepia (factor: {percentage})", img)

      waitKey(0)
      destroyAllWindows()

