






import random
import unittest

import numpy as np
import torch
from PIL import Image
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorEmbaEmbPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




class        _lowerCAmelCase( UpperCAmelCase_							,			unittest.TestCase      ):





       """simple docstring"""







       a       :	Tuple								=KandinskyVaaPriorEmbaEmbPipeline
       a       :	Dict								=['''prompt''', '''image''']
       a       :	Optional[int]								=['''prompt''', '''image''']
       a       :	Dict								=[
           '''num_images_per_prompt''',
           '''strength''',
           '''generator''',
           '''num_inference_steps''',
           '''latents''',
           '''negative_prompt''',
           '''guidance_scale''',
           '''output_type''',
           '''return_dict''',
       ]
       a       :	int								=False





       @property
       def     _a					(      self							):
         return 3_2





       @property
       def     _a					(      self							):
         return 3_2





       @property
       def     _a					(      self							):
         return self.time_input_dim





       @property
       def     _a					(      self							):
         return self.time_input_dim * 4





       @property
       def     _a					(      self							):
         return 1_0_0





       @property
       def     _a					(      self							):
         UpperCamelCase_:      Optional[Any]					   =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'							)
         return tokenizer





       @property
       def     _a					(      self							):
         torch.manual_seed(0							)
         UpperCamelCase_:      str					   =       CLIPTextConfig(
             bos_token_id=0						,    eos_token_id=2						,    hidden_size=self.text_embedder_hidden_size						,    projection_dim=self.text_embedder_hidden_size						,    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						,    )
         return CLIPTextModelWithProjection(_lowerCamelCase							)





       @property
       def     _a					(      self							):
         torch.manual_seed(0							)

         UpperCamelCase_:      int					   =       {
             'num_attention_heads': 2,
             'attention_head_dim': 1_2,
             'embedding_dim': self.text_embedder_hidden_size,
             'num_layers': 1,
         }

         UpperCamelCase_:      Optional[Any]					   =       PriorTransformer(**_lowerCamelCase							)
         # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
         UpperCamelCase_:      Any					   =       nn.Parameter(torch.ones(model.clip_std.shape							)							)
         return model





       @property
       def     _a					(      self							):
         torch.manual_seed(0							)
         UpperCamelCase_:      int					   =       CLIPVisionConfig(
             hidden_size=self.text_embedder_hidden_size						,    image_size=2_2_4						,    projection_dim=self.text_embedder_hidden_size						,    intermediate_size=3_7						,    num_attention_heads=4						,    num_channels=3						,    num_hidden_layers=5						,    patch_size=1_4						,    )

         UpperCamelCase_:      Any					   =       CLIPVisionModelWithProjection(_lowerCamelCase							)
         return model





       @property
       def     _a					(      self							):
         UpperCamelCase_:      Tuple					   =       CLIPImageProcessor(
             crop_size=2_2_4						,    do_center_crop=_lowerCamelCase						,    do_normalize=_lowerCamelCase						,    do_resize=_lowerCamelCase						,    image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]						,    image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]						,    resample=3						,    size=2_2_4						,    )

         return image_processor





       def     _a					(      self							):
         UpperCamelCase_:      Tuple					   =       self.dummy_prior
         UpperCamelCase_:      Any					   =       self.dummy_image_encoder
         UpperCamelCase_:      int					   =       self.dummy_text_encoder
         UpperCamelCase_:      Dict					   =       self.dummy_tokenizer
         UpperCamelCase_:      Union[str, Any]					   =       self.dummy_image_processor

         UpperCamelCase_:      Dict					   =       UnCLIPScheduler(
             variance_type='fixed_small_log'						,    prediction_type='sample'						,    num_train_timesteps=1_0_0_0						,    clip_sample=_lowerCamelCase						,    clip_sample_range=1_0.0						,    )

         UpperCamelCase_:      Optional[int]					   =       {
             'prior': prior,
             'image_encoder': image_encoder,
             'text_encoder': text_encoder,
             'tokenizer': tokenizer,
             'scheduler': scheduler,
             'image_processor': image_processor,
         }

         return components





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase=0							):
         if str(_lowerCamelCase							).startswith('mps'							):
           UpperCamelCase_:      Optional[Any]					   =       torch.manual_seed(_lowerCamelCase							)
         else:
           UpperCamelCase_:      str					   =       torch.Generator(device=_lowerCamelCase							).manual_seed(_lowerCamelCase							)

         UpperCamelCase_:      List[str]					   =       floats_tensor((1, 3, 6_4, 6_4)						,    rng=random.Random(_lowerCamelCase							)							).to(_lowerCamelCase							)
         UpperCamelCase_:      Dict					   =       image.cpu().permute(0						,    2						,    3						,    1							)[0]
         UpperCamelCase_:      Optional[int]					   =       Image.fromarray(np.uinta(_lowerCamelCase							)							).convert('RGB'							).resize((2_5_6, 2_5_6)							)

         UpperCamelCase_:      Dict					   =       {
             'prompt': 'horse',
             'image': init_image,
             'strength': 0.5,
             'generator': generator,
             'guidance_scale': 4.0,
             'num_inference_steps': 2,
             'output_type': 'np',
         }
         return inputs





       def     _a					(      self							):
         UpperCamelCase_:      List[str]					   =       'cpu'

         UpperCamelCase_:      Any					   =       self.get_dummy_components()

         UpperCamelCase_:      Any					   =       self.pipeline_class(**_lowerCamelCase							)
         UpperCamelCase_:      List[str]					   =       pipe.to(_lowerCamelCase							)

         pipe.set_progress_bar_config(disable=_lowerCamelCase							)

         UpperCamelCase_:      List[str]					   =       pipe(**self.get_dummy_inputs(_lowerCamelCase							)							)
         UpperCamelCase_:      Optional[int]					   =       output.image_embeds

         UpperCamelCase_:      List[str]					   =       pipe(
             **self.get_dummy_inputs(_lowerCamelCase							)						,    return_dict=_lowerCamelCase						,    )[0]

         UpperCamelCase_:      Optional[Any]					   =       image[0, -1_0:]
         UpperCamelCase_:      Optional[Any]					   =       image_from_tuple[0, -1_0:]

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

         UpperCamelCase_:      Optional[Any]					   =       np.array(
             [
                 0.1_0_7_1_2_8_4,
                 1.3_3_3_0_2_7_1,
                 0.6_1_2_6_0_2_2_3,
                 -0.6_6_9_1_0_6_5,
                 -0.3_8_4_6_8_5_2,
                 -1.0_3_0_3_6_6_1,
                 0.2_2_7_1_6_1_1_1,
                 0.0_3_3_4_8_9_0_1,
                 0.3_0_0_4_0_6_7_5,
                 -0.2_4_8_0_5_0_2_9,
             ]							)

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





       @skip_mps
       def     _a					(      self							):
         UpperCamelCase_:      List[str]					   =       torch_device == 'cpu'
         UpperCamelCase_:      Tuple					   =       True
         UpperCamelCase_:      Union[str, Any]					   =       False

         self._test_inference_batch_single_identical(
             test_max_difference=_lowerCamelCase						,    relax_max_difference=_lowerCamelCase						,    test_mean_pixel_difference=_lowerCamelCase						,    )





       @skip_mps
       def     _a					(      self							):
         UpperCamelCase_:      Any					   =       torch_device == 'cpu'
         UpperCamelCase_:      List[Any]					   =       False

         self._test_attention_slicing_forward_pass(
             test_max_difference=_lowerCamelCase						,    test_mean_pixel_difference=_lowerCamelCase						,    )







def 						snake_case      (UpperCAmelCase__ = 4_0_0_0_0_0_0						) ->       int:

  if n <= 1:
    return 0
  UpperCamelCase_:      Dict					   =       0
  UpperCamelCase_:      Union[str, Any]					   =       2
  UpperCamelCase_:      int					   =       0
  while 4 * b + a <= n:
    UpperCamelCase_   ,UpperCamelCase_:      List[str]					   =       b, 4 * b + a
    count += a
  return count + b


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