





import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()





class 				A_				(      UpperCamelCase_					,	UpperCamelCase_					,	UpperCamelCase_					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : Optional[Any]      =  StableUnCLIPImgaImgPipeline
       SCREAMING_SNAKE_CASE_      : List[Any]      =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS
       SCREAMING_SNAKE_CASE_      : Union[str, Any]      =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       SCREAMING_SNAKE_CASE_      : List[Any]      =  frozenset(
           []	)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
       SCREAMING_SNAKE_CASE_      : str      =  frozenset([]	)







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Dict:
         _lowercase							= 32
         _lowercase							= embedder_hidden_size

         # image encoding components

         _lowercase							= CLIPImageProcessor(crop_size=32						,size=32  )

         torch.manual_seed(0  )
         _lowercase							= CLIPVisionModelWithProjection(
             CLIPVisionConfig(
                 hidden_size=__A						,projection_dim=__A						,num_hidden_layers=5						,num_attention_heads=4						,image_size=32						,intermediate_size=37						,patch_size=1						,)  )

         # regular denoising components

         torch.manual_seed(0  )
         _lowercase							= StableUnCLIPImageNormalizer(embedding_dim=__A  )
         _lowercase							= DDPMScheduler(beta_schedule='squaredcos_cap_v2'  )

         torch.manual_seed(0  )
         _lowercase							= CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

         torch.manual_seed(0  )
         _lowercase							= CLIPTextModel(
             CLIPTextConfig(
                 bos_token_id=0						,eos_token_id=2						,hidden_size=__A						,projection_dim=32						,intermediate_size=37						,layer_norm_eps=1e-05						,num_attention_heads=4						,num_hidden_layers=5						,pad_token_id=1						,vocab_size=1000						,)  )

         torch.manual_seed(0  )
         _lowercase							= UNetaDConditionModel(
             sample_size=32						,in_channels=4						,out_channels=4						,down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')						,up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')						,block_out_channels=(32, 64)						,attention_head_dim=(2, 4)						,class_embed_type='projection'						,projection_class_embeddings_input_dim=embedder_projection_dim * 2						,cross_attention_dim=__A						,layers_per_block=1						,upcast_attention=__A						,use_linear_projection=__A						,)

         torch.manual_seed(0  )
         _lowercase							= DDIMScheduler(
             beta_schedule='scaled_linear'						,beta_start=0.00085						,beta_end=0.012						,prediction_type='v_prediction'						,set_alpha_to_one=__A						,steps_offset=1						,)

         torch.manual_seed(0  )
         _lowercase							= AutoencoderKL()

         _lowercase							= {
             # image encoding components
             '''feature_extractor''': feature_extractor,
             '''image_encoder''': image_encoder.eval(),
             # image noising components
             '''image_normalizer''': image_normalizer.eval(),
             '''image_noising_scheduler''': image_noising_scheduler,
             # regular denoising components
             '''tokenizer''': tokenizer,
             '''text_encoder''': text_encoder.eval(),
             '''unet''': unet.eval(),
             '''scheduler''': scheduler,
             '''vae''': vae.eval(),
         }

         return components







       def    __UpperCAmelCase (    self	:	List[Any]						,__A	:	int						,__A	:	Union[str, Any]=0						,__A	:	Dict=True  )						->					Tuple:
         if str(__A  ).startswith('mps'  ):
           _lowercase							= torch.manual_seed(__A  )
         else:
           _lowercase							= torch.Generator(device=__A  ).manual_seed(__A  )

         _lowercase							= floats_tensor((1, 3, 32, 32)						,rng=random.Random(__A  )  ).to(__A  )

         if pil_image:
           _lowercase							= input_image * 0.5 + 0.5
           _lowercase							= input_image.clamp(0						,1  )
           _lowercase							= input_image.cpu().permute(0						,2						,3						,1  ).float().numpy()
           _lowercase							= DiffusionPipeline.numpy_to_pil(__A  )[0]

         return {
             "prompt": "An anime racoon running a marathon",
             "image": input_image,
             "generator": generator,
             "num_inference_steps": 2,
             "output_type": "np",
         }







       @skip_mps
       def    __UpperCAmelCase (    self	:	Any  )						->					Optional[Any]:
         _lowercase							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
         _lowercase							= self.get_dummy_components()
         _lowercase							= StableUnCLIPImgaImgPipeline(**__A  )
         _lowercase							= sd_pipe.to(__A  )
         sd_pipe.set_progress_bar_config(disable=__A  )

         _lowercase							= self.get_dummy_inputs(__A  )
         inputs.update({'image_embeds': None}  )
         _lowercase							= sd_pipe(**__A  ).images
         _lowercase							= image[0, -3:, -3:, -1]

         assert image.shape == (1, 32, 32, 3)
         _lowercase							= np.array([0.3872, 0.7224, 0.5601, 0.4741, 0.6872, 0.5814, 0.4636, 0.3867, 0.5078]  )

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







       def    __UpperCAmelCase (    self	:	Dict  )						->					List[str]:
         _lowercase							= torch_device in ['''cpu''', '''mps''']

         self._test_attention_slicing_forward_pass(test_max_difference=__A  )







       def    __UpperCAmelCase (    self	:	Any  )						->					Tuple:
         _lowercase							= torch_device in ['''cpu''', '''mps''']

         self._test_inference_batch_single_identical(test_max_difference=__A  )







       @unittest.skipIf(
           torch_device != 'cuda' or not is_xformers_available()						,reason='XFormers attention is only available with CUDA and `xformers` installed'						,)
       def    __UpperCAmelCase (    self	:	str  )						->					Any:
         self._test_xformers_attention_forwardGenerator_pass(test_max_difference=__A  )





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







       """simple docstring"""





       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					Optional[Any]:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()







       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					str:
         _lowercase							= load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'  )

         _lowercase							= load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy'  )

         _lowercase							= StableUnCLIPImgaImgPipeline.from_pretrained(
             'fusing/stable-unclip-2-1-l-img2img'						,torch_dtype=torch.floataa  )
         pipe.to(__A  )
         pipe.set_progress_bar_config(disable=__A  )
         # stable unclip will oom when integration tests are run on a V100,
         # so turn on memory savings
         pipe.enable_attention_slicing()
         pipe.enable_sequential_cpu_offload()

         _lowercase							= torch.Generator(device='cpu'  ).manual_seed(0  )
         _lowercase							= pipe(__A						,'anime turle'						,generator=__A						,output_type='np'  )

         _lowercase							= output.images[0]

         assert image.shape == (768, 768, 3)

         assert_mean_pixel_difference(__A						,__A  )







       def    __UpperCAmelCase (    self	:	int  )						->					Optional[int]:
         _lowercase							= load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'  )

         _lowercase							= load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy'  )

         _lowercase							= StableUnCLIPImgaImgPipeline.from_pretrained(
             'fusing/stable-unclip-2-1-h-img2img'						,torch_dtype=torch.floataa  )
         pipe.to(__A  )
         pipe.set_progress_bar_config(disable=__A  )
         # stable unclip will oom when integration tests are run on a V100,
         # so turn on memory savings
         pipe.enable_attention_slicing()
         pipe.enable_sequential_cpu_offload()

         _lowercase							= torch.Generator(device='cpu'  ).manual_seed(0  )
         _lowercase							= pipe(__A						,'anime turle'						,generator=__A						,output_type='np'  )

         _lowercase							= output.images[0]

         assert image.shape == (768, 768, 3)

         assert_mean_pixel_difference(__A						,__A  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Any:
         _lowercase							= load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'  )

         torch.cuda.empty_cache()
         torch.cuda.reset_max_memory_allocated()
         torch.cuda.reset_peak_memory_stats()

         _lowercase							= StableUnCLIPImgaImgPipeline.from_pretrained(
             'fusing/stable-unclip-2-1-h-img2img'						,torch_dtype=torch.floataa  )
         _lowercase							= pipe.to(__A  )
         pipe.set_progress_bar_config(disable=__A  )
         pipe.enable_attention_slicing()
         pipe.enable_sequential_cpu_offload()

         _lowercase							= pipe(
             __A						,'anime turtle'						,num_inference_steps=2						,output_type='np'						,)

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






from itertools import count

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :int = 50     )      ->						int:
  _lowercase							= [1] * min_block_length

  for n in count(snake_case__     ):
    fill_count_functions.append(1     )

    for block_length in range(snake_case__			,							n + 1     ):
      for block_start in range(n - block_length     ):
        fill_count_functions[n] += fill_count_functions[
            n - block_start - block_length - 1
        ]

      fill_count_functions[n] += 1

    if fill_count_functions[n] > 100_0000:
      break

  return n


if __name__ == "__main__":
      print(F"""{solution() = }""")