





'''simple docstring'''



import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


class       __SCREAMING_SNAKE_CASE	(						unittest.TestCase			):



     '''simple docstring'''






     def 	UpperCamelCase(					self	):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()

     @property
     def 	UpperCamelCase(					self	):
       _snake_case     		=				1
       _snake_case     		=				3
       _snake_case     		=				(32, 32)

       _snake_case     		=				floats_tensor((batch_size, num_channels) + sizes						,   rng=random.Random(0	)	).to(lowerCamelCase	)
       return image

     @property
     def 	UpperCamelCase(					self	):
       torch.manual_seed(0	)
       _snake_case     		=				UNetaDConditionModel(
           block_out_channels=(32, 32, 64)						,   layers_per_block=2						,   sample_size=32						,   in_channels=7						,   out_channels=4						,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D")						,   up_block_types=("CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "UpBlock2D")						,   cross_attention_dim=32						,   attention_head_dim=8						,   use_linear_projection=lowerCamelCase						,   only_cross_attention=(True, True, False)						,   num_class_embeds=100						,   )
       return model

     @property
     def 	UpperCamelCase(					self	):
       torch.manual_seed(0	)
       _snake_case     		=				AutoencoderKL(
           block_out_channels=[32, 32, 64]						,   in_channels=3						,   out_channels=3						,   down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D", "DownEncoderBlock2D"]						,   up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]						,   latent_channels=4						,   )
       return model

     @property
     def 	UpperCamelCase(					self	):
       torch.manual_seed(0	)
       _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=1_000						,   hidden_act="gelu"						,   projection_dim=512						,   )
       return CLIPTextModel(lowerCamelCase	)

     def 	UpperCamelCase(					self	):
       _snake_case     		=				"cpu"  # ensure determinism for the device-dependent torch.Generator
       _snake_case     		=				self.dummy_cond_unet_upscale
       _snake_case     		=				DDPMScheduler()
       _snake_case     		=				DDIMScheduler(prediction_type="v_prediction"	)
       _snake_case     		=				self.dummy_vae
       _snake_case     		=				self.dummy_text_encoder
       _snake_case     		=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

       _snake_case     		=				self.dummy_image.cpu().permute(0						,   2						,   3						,   1	)[0]
       _snake_case     		=				Image.fromarray(np.uinta(lowerCamelCase	)	).convert("RGB"	).resize((64, 64)	)

       # make sure here that pndm scheduler skips prk
       _snake_case     		=				StableDiffusionUpscalePipeline(
           unet=lowerCamelCase						,   low_res_scheduler=lowerCamelCase						,   scheduler=lowerCamelCase						,   vae=lowerCamelCase						,   text_encoder=lowerCamelCase						,   tokenizer=lowerCamelCase						,   max_noise_level=350						,   )
       _snake_case     		=				sd_pipe.to(lowerCamelCase	)
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase	)

       _snake_case     		=				"A painting of a squirrel eating a burger"
       _snake_case     		=				torch.Generator(device=lowerCamelCase	).manual_seed(0	)
       _snake_case     		=				sd_pipe(
           [prompt]						,   image=lowerCamelCase						,   generator=lowerCamelCase						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type="np"						,   )

       _snake_case     		=				output.images

       _snake_case     		=				torch.Generator(device=lowerCamelCase	).manual_seed(0	)
       _snake_case     		=				sd_pipe(
           [prompt]						,   image=lowerCamelCase						,   generator=lowerCamelCase						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type="np"						,   return_dict=lowerCamelCase						,   )[0]

       _snake_case     		=				image[0, -3:, -3:, -1]
       _snake_case     		=				image_from_tuple[0, -3:, -3:, -1]

       _snake_case     		=				low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)
       _snake_case     		=				np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]	)

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

     def 	UpperCamelCase(					self	):
       _snake_case     		=				"cpu"  # ensure determinism for the device-dependent torch.Generator
       _snake_case     		=				self.dummy_cond_unet_upscale
       _snake_case     		=				DDPMScheduler()
       _snake_case     		=				DDIMScheduler(prediction_type="v_prediction"	)
       _snake_case     		=				self.dummy_vae
       _snake_case     		=				self.dummy_text_encoder
       _snake_case     		=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

       _snake_case     		=				self.dummy_image.cpu().permute(0						,   2						,   3						,   1	)[0]
       _snake_case     		=				Image.fromarray(np.uinta(lowerCamelCase	)	).convert("RGB"	).resize((64, 64)	)

       # make sure here that pndm scheduler skips prk
       _snake_case     		=				StableDiffusionUpscalePipeline(
           unet=lowerCamelCase						,   low_res_scheduler=lowerCamelCase						,   scheduler=lowerCamelCase						,   vae=lowerCamelCase						,   text_encoder=lowerCamelCase						,   tokenizer=lowerCamelCase						,   max_noise_level=350						,   )
       _snake_case     		=				sd_pipe.to(lowerCamelCase	)
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase	)

       _snake_case     		=				"A painting of a squirrel eating a burger"
       _snake_case     		=				sd_pipe(
           2 * [prompt]						,   image=2 * [low_res_image]						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type="np"						,   )
       _snake_case     		=				output.images
       assert image.shape[0] == 2

       _snake_case     		=				torch.Generator(device=lowerCamelCase	).manual_seed(0	)
       _snake_case     		=				sd_pipe(
           [prompt]						,   image=lowerCamelCase						,   generator=lowerCamelCase						,   num_images_per_prompt=2						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type="np"						,   )
       _snake_case     		=				output.images
       assert image.shape[0] == 2






     @unittest.skipIf(torch_device != "cuda"						,   "This test requires a GPU"	)
     def 	UpperCamelCase(					self	):
       _snake_case     		=				self.dummy_cond_unet_upscale
       _snake_case     		=				DDPMScheduler()
       _snake_case     		=				DDIMScheduler(prediction_type="v_prediction"	)
       _snake_case     		=				self.dummy_vae
       _snake_case     		=				self.dummy_text_encoder
       _snake_case     		=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

       _snake_case     		=				self.dummy_image.cpu().permute(0						,   2						,   3						,   1	)[0]
       _snake_case     		=				Image.fromarray(np.uinta(lowerCamelCase	)	).convert("RGB"	).resize((64, 64)	)

       # put models in fp16, except vae as it overflows in fp16
       _snake_case     		=				unet.half()
       _snake_case     		=				text_encoder.half()

       # make sure here that pndm scheduler skips prk
       _snake_case     		=				StableDiffusionUpscalePipeline(
           unet=lowerCamelCase						,   low_res_scheduler=lowerCamelCase						,   scheduler=lowerCamelCase						,   vae=lowerCamelCase						,   text_encoder=lowerCamelCase						,   tokenizer=lowerCamelCase						,   max_noise_level=350						,   )
       _snake_case     		=				sd_pipe.to(lowerCamelCase	)
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase	)

       _snake_case     		=				"A painting of a squirrel eating a burger"
       _snake_case     		=				torch.manual_seed(0	)
       _snake_case     		=				sd_pipe(
           [prompt]						,   image=lowerCamelCase						,   generator=lowerCamelCase						,   num_inference_steps=2						,   output_type="np"						,   ).images

       _snake_case     		=				low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)







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



     '''simple docstring'''






     def 	UpperCamelCase(					self	):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()

     def 	UpperCamelCase(					self	):
       _snake_case     		=				load_image(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           "/sd2-upscale/low_res_cat.png"	)
       _snake_case     		=				load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
           "/upsampled_cat.npy"	)

       _snake_case     		=				"stabilityai/stable-diffusion-x4-upscaler"
       _snake_case     		=				StableDiffusionUpscalePipeline.from_pretrained(lowerCamelCase	)
       pipe.to(lowerCamelCase	)
       pipe.set_progress_bar_config(disable=lowerCamelCase	)
       pipe.enable_attention_slicing()

       _snake_case     		=				"a cat sitting on a park bench"

       _snake_case     		=				torch.manual_seed(0	)
       _snake_case     		=				pipe(
           prompt=lowerCamelCase						,   image=lowerCamelCase						,   generator=lowerCamelCase						,   output_type="np"						,   )
       _snake_case     		=				output.images[0]

       assert image.shape == (512, 512, 3)
       assert np.abs(expected_image - image	).max() < 1e-3

     def 	UpperCamelCase(					self	):
       _snake_case     		=				load_image(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           "/sd2-upscale/low_res_cat.png"	)
       _snake_case     		=				load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
           "/upsampled_cat_fp16.npy"	)

       _snake_case     		=				"stabilityai/stable-diffusion-x4-upscaler"
       _snake_case     		=				StableDiffusionUpscalePipeline.from_pretrained(
           lowerCamelCase						,   torch_dtype=torch.floataa						,   )
       pipe.to(lowerCamelCase	)
       pipe.set_progress_bar_config(disable=lowerCamelCase	)
       pipe.enable_attention_slicing()

       _snake_case     		=				"a cat sitting on a park bench"

       _snake_case     		=				torch.manual_seed(0	)
       _snake_case     		=				pipe(
           prompt=lowerCamelCase						,   image=lowerCamelCase						,   generator=lowerCamelCase						,   output_type="np"						,   )
       _snake_case     		=				output.images[0]

       assert image.shape == (512, 512, 3)
       assert np.abs(expected_image - image	).max() < 5e-1






     def 	UpperCamelCase(					self	):
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       _snake_case     		=				load_image(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           "/sd2-upscale/low_res_cat.png"	)

       _snake_case     		=				"stabilityai/stable-diffusion-x4-upscaler"
       _snake_case     		=				StableDiffusionUpscalePipeline.from_pretrained(
           lowerCamelCase						,   torch_dtype=torch.floataa						,   )
       pipe.to(lowerCamelCase	)
       pipe.set_progress_bar_config(disable=lowerCamelCase	)
       pipe.enable_attention_slicing(1	)
       pipe.enable_sequential_cpu_offload()

       _snake_case     		=				"a cat sitting on a park bench"

       _snake_case     		=				torch.manual_seed(0	)
       _snake_case     		=				pipe(
           prompt=lowerCamelCase						,   image=lowerCamelCase						,   generator=lowerCamelCase						,   num_inference_steps=5						,   output_type="np"						,   )

       _snake_case     		=				torch.cuda.max_memory_allocated()
       # make sure that less than 2.9 GB is allocated
       assert mem_bytes < 2.9 * 10**9









'''simple docstring'''



def 				snake_case_      (		SCREAMING_SNAKE_CASE__       ):







  '''simple docstring'''



  _snake_case     		=				[0 for i in range(len(SCREAMING_SNAKE_CASE__       )       )]

  # initialize interval's left pointer and right pointer
  _snake_case		,		_snake_case     		=				0, 0

  for i in range(1					,	len(SCREAMING_SNAKE_CASE__       )       ):
    # case when current index is inside the interval
    if i <= right_pointer:
      _snake_case     		=				min(right_pointer - i + 1					,	z_result[i - left_pointer]       )
      _snake_case     		=				min_edge

    while go_next(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__       ):
      z_result[i] += 1

    # if new index's result gives us more right interval,
    # we've to update left_pointer and right_pointer
    if i + z_result[i] - 1 > right_pointer:
      _snake_case		,		_snake_case     		=				i, i + z_result[i] - 1

  return z_result




def 				snake_case_      (		SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__       ):







  '''simple docstring'''



  return i + z_result[i] < len(SCREAMING_SNAKE_CASE__       ) and s[z_result[i]] == s[i + z_result[i]]




def 				snake_case_      (		SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__       ):







  '''simple docstring'''



  _snake_case     		=				0
  # concatenate 'pattern' and 'input_str' and call z_function
  # with concatenated string
  _snake_case     		=				z_function(pattern + input_str       )

  for val in z_result:
    # if value is greater then length of the pattern string
    # that means this index is starting position of substring
    # which is equal to pattern string
    if val >= len(SCREAMING_SNAKE_CASE__       ):
      answer += 1

  return answer


if __name__ == "__main__":
 import doctest

 doctest.testmod()


