





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 			__A(    __UpperCAmelCase    ,      unittest.TestCase			):
     __A							=							KandinskyVaaPriorEmbaEmbPipeline
     __A							=							["prompt", "image"]
     __A							=							["prompt", "image"]
     __A							=							[
         "num_images_per_prompt",
         "strength",
         "generator",
         "num_inference_steps",
         "latents",
         "negative_prompt",
         "guidance_scale",
         "output_type",
         "return_dict",
     ]
     __A							=							False

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            return 32

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            return 32

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            return self.time_input_dim

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            return self.time_input_dim * 4

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            return 100

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )
            return tokenizer

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            torch.manual_seed(0   )
            _UpperCamelCase														=    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=37,							layer_norm_eps=1E-0_5,							num_attention_heads=4,							num_hidden_layers=5,							pad_token_id=1,							vocab_size=1000,							)
            return CLIPTextModelWithProjection(A   )

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            torch.manual_seed(0   )

            _UpperCamelCase														=    {
                '''num_attention_heads''': 2,
                '''attention_head_dim''': 12,
                '''embedding_dim''': self.text_embedder_hidden_size,
                '''num_layers''': 1,
            }

            _UpperCamelCase														=    PriorTransformer(**A   )
            # 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														=    nn.Parameter(torch.ones(model.clip_std.shape   )   )
            return model

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            torch.manual_seed(0   )
            _UpperCamelCase														=    CLIPVisionConfig(
                hidden_size=self.text_embedder_hidden_size,							image_size=224,							projection_dim=self.text_embedder_hidden_size,							intermediate_size=37,							num_attention_heads=4,							num_channels=3,							num_hidden_layers=5,							patch_size=14,							)

            _UpperCamelCase														=    CLIPVisionModelWithProjection(A   )
            return model

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    CLIPImageProcessor(
                crop_size=224,							do_center_crop=A,							do_normalize=A,							do_resize=A,							image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073],							image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711],							resample=3,							size=224,							)

            return image_processor

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.dummy_prior
            _UpperCamelCase														=    self.dummy_image_encoder
            _UpperCamelCase														=    self.dummy_text_encoder
            _UpperCamelCase														=    self.dummy_tokenizer
            _UpperCamelCase														=    self.dummy_image_processor

            _UpperCamelCase														=    UnCLIPScheduler(
                variance_type='''fixed_small_log''',							prediction_type='''sample''',							num_train_timesteps=1000,							clip_sample=A,							clip_sample_range=10.0,							)

            _UpperCamelCase														=    {
                '''prior''': prior,
                '''image_encoder''': image_encoder,
                '''text_encoder''': text_encoder,
                '''tokenizer''': tokenizer,
                '''scheduler''': scheduler,
                '''image_processor''': image_processor,
            }

            return components

     def 						_UpperCamelCase  (   self,							A,							A=0   ):





            """simple docstring"""

            if str(A   ).startswith('''mps'''   ):
                   _UpperCamelCase														=    torch.manual_seed(A   )
            else:
                   _UpperCamelCase														=    torch.Generator(device=A   ).manual_seed(A   )

            _UpperCamelCase														=    floats_tensor((1, 3, 64, 64),							rng=random.Random(A   )   ).to(A   )
            _UpperCamelCase														=    image.cpu().permute(0,							2,							3,							1   )[0]
            _UpperCamelCase														=    Image.fromarray(np.uinta(A   )   ).convert('''RGB'''   ).resize((256, 256)   )

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

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    '''cpu'''

            _UpperCamelCase														=    self.get_dummy_components()

            _UpperCamelCase														=    self.pipeline_class(**A   )
            _UpperCamelCase														=    pipe.to(A   )

            pipe.set_progress_bar_config(disable=A   )

            _UpperCamelCase														=    pipe(**self.get_dummy_inputs(A   )   )
            _UpperCamelCase														=    output.image_embeds

            _UpperCamelCase														=    pipe(
                **self.get_dummy_inputs(A   ),							return_dict=A,							)[0]

            _UpperCamelCase														=    image[0, -10:]
            _UpperCamelCase														=    image_from_tuple[0, -10:]

            assert image.shape == (1, 32)

            _UpperCamelCase														=    np.array(
                [
                    0.1_071_284,
                    1.3_330_271,
                    0.61_260_223,
                    -0.6_691_065,
                    -0.3_846_852,
                    -1.0_303_661,
                    0.22_716_111,
                    0.03_348_901,
                    0.30_040_675,
                    -0.24_805_029,
                ]   )

            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 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    torch_device == '''cpu'''
            _UpperCamelCase														=    True
            _UpperCamelCase														=    False

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



     @skip_mps
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    torch_device == '''cpu'''
            _UpperCamelCase														=    False

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













import math
from decimal import Decimal, getcontext


def      SCREAMING_SNAKE_CASE      (   lowerCAmelCase = 4_000_000       ):

       try:
              _UpperCamelCase														=    int(lowerCAmelCase       )
       except (TypeError, ValueError):
              raise TypeError('''Parameter n must be int or castable to int.'''       )
       if n <= 0:
              raise ValueError('''Parameter n must be greater than or equal to one.'''       )
       _UpperCamelCase														=    100
       _UpperCamelCase														=    (Decimal(5       ) ** Decimal(0.5       ) + 1) / Decimal(2       )

       _UpperCamelCase														=    (math.floor(math.log(n * (phi + 2)     ,							lowerCAmelCase       ) - 1       ) // 3) * 3 + 2
       _UpperCamelCase														=    Decimal(round(phi ** Decimal(index + 1       )       )       ) / (phi + 2)
       _UpperCamelCase														=    num // 2
       return int(lowerCAmelCase       )


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






