

import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    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					(      lowerCAmelCase__       ,	lowerCAmelCase__       ,	unittest.TestCase    ):
  __lowerCAmelCase       :		Optional[Any]  	=					StableDiffusionXLPipeline
  __lowerCAmelCase       :		Dict  	=					TEXT_TO_IMAGE_PARAMS
  __lowerCAmelCase       :		Optional[int]  	=					TEXT_TO_IMAGE_BATCH_PARAMS
  __lowerCAmelCase       :		int  	=					TEXT_TO_IMAGE_IMAGE_PARAMS
  __lowerCAmelCase       :		Union[str, Any]  	=					TEXT_TO_IMAGE_IMAGE_PARAMS

  def   lowerCAmelCase__       (   self):
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  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')  ,						attention_head_dim=(2, 4)  ,						use_linear_projection=_A  ,						addition_embed_type='text_time'  ,						addition_time_embed_dim=8  ,						transformer_layers_per_block=(1, 2)  ,						projection_class_embeddings_input_dim=80  ,						cross_attention_dim=64  ,						)
      SCREAMING_SNAKE_CASE_													=  EulerDiscreteScheduler(
          beta_start=0.0_0_0_8_5  ,						beta_end=0.0_1_2  ,						steps_offset=1  ,						beta_schedule='scaled_linear'  ,						timestep_spacing='leading'  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  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)
      SCREAMING_SNAKE_CASE_													=  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=32  ,						)
      SCREAMING_SNAKE_CASE_													=  CLIPTextModel(_A)
      SCREAMING_SNAKE_CASE_													=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  ,						local_files_only=_A)

      SCREAMING_SNAKE_CASE_													=  CLIPTextModelWithProjection(_A)
      SCREAMING_SNAKE_CASE_													=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  ,						local_files_only=_A)

      SCREAMING_SNAKE_CASE_													=  {
          'unet': unet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'text_encoder_2': text_encoder_a,
          'tokenizer_2': tokenizer_a,
          # "safety_checker": None,
          # "feature_extractor": None,
      }
      return components

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A=0):
      if str(_A).startswith('mps'):
          SCREAMING_SNAKE_CASE_													=  torch.manual_seed(_A)
      else:
          SCREAMING_SNAKE_CASE_													=  torch.Generator(device=_A).manual_seed(_A)
      SCREAMING_SNAKE_CASE_													=  {
          'prompt': 'A painting of a squirrel eating a burger',
          'generator': generator,
          'num_inference_steps': 2,
          'guidance_scale': 5.0,
          'output_type': 'numpy',
      }
      return inputs

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  'cpu'  # ensure determinism for the device-dependent torch.Generator
      SCREAMING_SNAKE_CASE_													=  self.get_dummy_components()
      SCREAMING_SNAKE_CASE_													=  StableDiffusionXLPipeline(**_A)
      SCREAMING_SNAKE_CASE_													=  sd_pipe.to(_A)
      sd_pipe.set_progress_bar_config(disable=_A)

      SCREAMING_SNAKE_CASE_													=  self.get_dummy_inputs(_A)
      SCREAMING_SNAKE_CASE_													=  sd_pipe(**_A).images
      SCREAMING_SNAKE_CASE_													=  image[0, -3:, -3:, -1]

      assert image.shape == (1, 64, 64, 3)
      SCREAMING_SNAKE_CASE_													=  np.array([0.5_8_7_3, 0.6_1_2_8, 0.4_7_9_7, 0.5_1_2_2, 0.5_6_7_4, 0.4_6_3_9, 0.5_2_2_7, 0.5_1_4_9, 0.4_7_4_7])

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

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self.get_dummy_components()
      SCREAMING_SNAKE_CASE_													=  StableDiffusionXLPipeline(**_A)
      SCREAMING_SNAKE_CASE_													=  sd_pipe.to(_A)
      SCREAMING_SNAKE_CASE_													=  sd_pipe.to(_A)
      sd_pipe.set_progress_bar_config(disable=_A)

      # forward without prompt embeds
      SCREAMING_SNAKE_CASE_													=  self.get_dummy_inputs(_A)
      SCREAMING_SNAKE_CASE_													=  3 * ['this is a negative prompt']
      SCREAMING_SNAKE_CASE_													=  negative_prompt
      SCREAMING_SNAKE_CASE_													=  3 * [inputs['prompt']]

      SCREAMING_SNAKE_CASE_													=  sd_pipe(**_A)
      SCREAMING_SNAKE_CASE_													=  output.images[0, -3:, -3:, -1]

      # forward with prompt embeds
      SCREAMING_SNAKE_CASE_													=  self.get_dummy_inputs(_A)
      SCREAMING_SNAKE_CASE_													=  3 * ['this is a negative prompt']
      SCREAMING_SNAKE_CASE_													=  3 * [inputs.pop('prompt')]

      (
          (
          SCREAMING_SNAKE_CASE_
      )							,     (
          SCREAMING_SNAKE_CASE_
      )							,     (
          SCREAMING_SNAKE_CASE_
      )							,     (
          SCREAMING_SNAKE_CASE_
      )							,     
      )													=  sd_pipe.encode_prompt(_A  ,						negative_prompt=_A)

      SCREAMING_SNAKE_CASE_													=  sd_pipe(
          **_A  ,						prompt_embeds=_A  ,						negative_prompt_embeds=_A  ,						pooled_prompt_embeds=_A  ,						negative_pooled_prompt_embeds=_A  ,						)
      SCREAMING_SNAKE_CASE_													=  output.images[0, -3:, -3:, -1]

      # make sure that it's equal
      assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1E-4

  def   lowerCAmelCase__       (   self):
      super().test_attention_slicing_forward_pass(expected_max_diff=3E-3)


  def   lowerCAmelCase__       (   self):
      super().test_inference_batch_single_identical(expected_max_diff=3E-3)






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

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

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A="cpu"  ,						_A=torch.floataa  ,						_A=0):
      SCREAMING_SNAKE_CASE_													=  torch.Generator(device=_A).manual_seed(_A)
      SCREAMING_SNAKE_CASE_													=  np.random.RandomState(_A).standard_normal((1, 4, 64, 64))
      SCREAMING_SNAKE_CASE_													=  torch.from_numpy(_A).to(device=_A  ,						dtype=_A)
      SCREAMING_SNAKE_CASE_													=  {
          'prompt': 'a photograph of an astronaut riding a horse',
          'latents': latents,
          'generator': generator,
          'num_inference_steps': 3,
          'guidance_scale': 7.5,
          'output_type': 'numpy',
      }
      return inputs


  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base')
      pipe.to(_A)
      pipe.set_progress_bar_config(disable=_A)

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

      assert image.shape == (1, 512, 512, 3)
      SCREAMING_SNAKE_CASE_													=  np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6])
      assert np.abs(image_slice - expected_slice).max() < 7E-3





import cva
import numpy as np


def    _UpperCAmelCase    (					_SCREAMING_SNAKE_CASE   :						np.ndarray	,				_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						int    ):





    """simple docstring"""


    try:
        return int(image[x_coordinate][y_coordinate] >= center    )
    except (IndexError, TypeError):
        return 0


def    _UpperCAmelCase    (					_SCREAMING_SNAKE_CASE   :						np.ndarray	,				_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						int    ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_													=  image[x_coordinate][y_coordinate]
    SCREAMING_SNAKE_CASE_													=  [1, 2, 4, 8, 16, 32, 64, 128]

    # skip get_neighbors_pixel if center is null
    if center is None:
        return 0

    # Starting from the top right, assigning value to pixels clockwise
    SCREAMING_SNAKE_CASE_													=  [
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				x_coordinate - 1	,				y_coordinate + 1	,				_SCREAMING_SNAKE_CASE    ),
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE	,				y_coordinate + 1	,				_SCREAMING_SNAKE_CASE    ),
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				x_coordinate - 1	,				_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE    ),
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				x_coordinate + 1	,				y_coordinate + 1	,				_SCREAMING_SNAKE_CASE    ),
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				x_coordinate + 1	,				_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE    ),
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				x_coordinate + 1	,				y_coordinate - 1	,				_SCREAMING_SNAKE_CASE    ),
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE	,				y_coordinate - 1	,				_SCREAMING_SNAKE_CASE    ),
        get_neighbors_pixel(_SCREAMING_SNAKE_CASE	,				x_coordinate - 1	,				y_coordinate - 1	,				_SCREAMING_SNAKE_CASE    ),
    ]

    # Converting the binary value to decimal.
    return sum(
        binary_value * power for binary_value, power in zip(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE    )    )


if __name__ == "__main__":
       # Reading the image and converting it to grayscale.
       UpperCamelCase__					: Optional[int]								=      cva.imread(
           "digital_image_processing/image_data/lena.jpg", cva.IMREAD_GRAYSCALE
       )

       # Create a numpy array as the same height and width of read image
       UpperCamelCase__					: Dict								=      np.zeros((image.shape[0], image.shape[1]))

       # Iterating through the image and calculating the
       # local binary pattern value for each pixel.
       for i in range(0, image.shape[0]):
              for j in range(0, image.shape[1]):
                     UpperCamelCase__					: Any								=      local_binary_value(image, i, j)

       cva.imshow("local binary pattern", lbp_image)
       cva.waitKey(0)
       cva.destroyAllWindows()


