






import unittest

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

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

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


class  __lowercase (		lowercase_     , unittest.TestCase					):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE				  =			KandinskyPriorPipeline
     SCREAMING_SNAKE_CASE				  =			["prompt"]
     SCREAMING_SNAKE_CASE				  =			["prompt", "negative_prompt"]
     SCREAMING_SNAKE_CASE				  =			[
         "num_images_per_prompt",
         "generator",
         "num_inference_steps",
         "latents",
         "negative_prompt",
         "guidance_scale",
         "output_type",
         "return_dict",
     ]
     SCREAMING_SNAKE_CASE				  =			False




     @property
     def 						lowerCAmelCase_       (			self    :     List[Any]			):


         """simple docstring"""



         return 32




     @property
     def 						lowerCAmelCase_       (			self    :     Optional[int]			):


         """simple docstring"""



         return 32




     @property
     def 						lowerCAmelCase_       (			self    :     Optional[int]			):


         """simple docstring"""



         return self.time_input_dim




     @property
     def 						lowerCAmelCase_       (			self    :     Optional[Any]			):


         """simple docstring"""



         return self.time_input_dim * 4




     @property
     def 						lowerCAmelCase_       (			self    :     int			):


         """simple docstring"""



         return 100




     @property
     def 						lowerCAmelCase_       (			self    :     Optional[Any]			):


         """simple docstring"""



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




     @property
     def 						lowerCAmelCase_       (			self    :     Tuple			):


         """simple docstring"""



         torch.manual_seed(0			)
         __A             =		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-05	,		num_attention_heads=4	,		num_hidden_layers=5	,		pad_token_id=1	,		vocab_size=1_000	,		)
         return CLIPTextModelWithProjection(UpperCamelCase_			)




     @property
     def 						lowerCAmelCase_       (			self    :     Union[str, Any]			):


         """simple docstring"""



         torch.manual_seed(0			)

         __A             =		{
             """num_attention_heads""": 2,
             """attention_head_dim""": 12,
             """embedding_dim""": self.text_embedder_hidden_size,
             """num_layers""": 1,
         }

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




     @property
     def 						lowerCAmelCase_       (			self    :     str			):


         """simple docstring"""



         torch.manual_seed(0			)
         __A             =		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	,		)

         __A             =		CLIPVisionModelWithProjection(UpperCamelCase_			)
         return model




     @property
     def 						lowerCAmelCase_       (			self    :     str			):


         """simple docstring"""



         __A             =		CLIPImageProcessor(
             crop_size=224	,		do_center_crop=UpperCamelCase_	,		do_normalize=UpperCamelCase_	,		do_resize=UpperCamelCase_	,		image_mean=[0.48145466, 0.4578275, 0.40821073]	,		image_std=[0.26862954, 0.26130258, 0.27577711]	,		resample=3	,		size=224	,		)

         return image_processor




     def 						lowerCAmelCase_       (			self    :     List[str]			):


         """simple docstring"""



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

         __A             =		UnCLIPScheduler(
             variance_type="""fixed_small_log"""	,		prediction_type="""sample"""	,		num_train_timesteps=1_000	,		clip_sample=UpperCamelCase_	,		clip_sample_range=10.0	,		)

         __A             =		{
             """prior""": prior,
             """image_encoder""": image_encoder,
             """text_encoder""": text_encoder,
             """tokenizer""": tokenizer,
             """scheduler""": scheduler,
             """image_processor""": image_processor,
         }

         return components




     def 						lowerCAmelCase_       (			self    :     Tuple	,		UpperCamelCase_    :     int	,		UpperCamelCase_    :     Any=0			):


         """simple docstring"""



         if str(UpperCamelCase_			).startswith("""mps"""			):
             __A             =		torch.manual_seed(UpperCamelCase_			)
         else:
             __A             =		torch.Generator(device=UpperCamelCase_			).manual_seed(UpperCamelCase_			)
         __A             =		{
             """prompt""": """horse""",
             """generator""": generator,
             """guidance_scale""": 4.0,
             """num_inference_steps""": 2,
             """output_type""": """np""",
         }
         return inputs




     def 						lowerCAmelCase_       (			self    :     List[str]			):


         """simple docstring"""



         __A             =		"""cpu"""

         __A             =		self.get_dummy_components()

         __A             =		self.pipeline_class(**UpperCamelCase_			)
         __A             =		pipe.to(UpperCamelCase_			)

         pipe.set_progress_bar_config(disable=UpperCamelCase_			)

         __A             =		pipe(**self.get_dummy_inputs(UpperCamelCase_			)			)
         __A             =		output.image_embeds

         __A             =		pipe(
             **self.get_dummy_inputs(UpperCamelCase_			)	,		return_dict=UpperCamelCase_	,		)[0]

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

         assert image.shape == (1, 32)

         __A             =		np.array(
             [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156]			)

         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 						lowerCAmelCase_       (			self    :     Optional[int]			):


         """simple docstring"""



         __A             =		torch_device == """cpu"""
         __A             =		True
         __A             =		False

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





     @skip_mps
     def 						lowerCAmelCase_       (			self    :     Dict			):


         """simple docstring"""



         __A             =		torch_device == """cpu"""
         __A             =		False

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












def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int     ,			__lowercase				:     int      )  -> int:





    """simple docstring"""

    __A             =		1.0
    for i in range(1     ,			r + 1      ):
        ret *= (n + 1 - i) / i
    return round(__lowercase      )



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int      )  -> int:





    """simple docstring"""

    return choose(8 + n     ,			__lowercase      ) + choose(9 + n     ,			__lowercase      ) - 1_0



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int      )  -> int:





    """simple docstring"""

    return sum(non_bouncy_exact(__lowercase      ) for i in range(1     ,			n + 1      )      )



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int = 1_0_0      )  -> int:





    """simple docstring"""

    return non_bouncy_upto(__lowercase      )


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




