


import unittest

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

from diffusers import KandinskyVaaPriorPipeline, 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        a	(_lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							str  						=						KandinskyVaaPriorPipeline
							__UpperCAmelCase					:							Dict  						=						["prompt"]
							__UpperCAmelCase					:							Any  						=						["prompt", "negative_prompt"]
							__UpperCAmelCase					:							Dict  						=						[
							    "num_images_per_prompt",
							    "generator",
							    "num_inference_steps",
							    "latents",
							    "negative_prompt",
							    "guidance_scale",
							    "output_type",
							    "return_dict",
							]
							__UpperCAmelCase					:							int  						=						False

							@property
							def 					__snake_case      (							self :						Tuple       )			->					Optional[int]:
														return 32

							@property
							def 					__snake_case      (							self :						Union[str, Any]       )			->					Any:
														return 32

							@property
							def 					__snake_case      (							self :						List[Any]       )			->					Union[str, Any]:
														return self.time_input_dim

							@property
							def 					__snake_case      (							self :						Optional[int]       )			->					Tuple:
														return self.time_input_dim * 4

							@property
							def 					__snake_case      (							self :						str       )			->					Any:
														return 100

							@property
							def 					__snake_case      (							self :						List[str]       )			->					Union[str, Any]:
														__snake_case	:    Union[str, Any]											=     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )
														return tokenizer

							@property
							def 					__snake_case      (							self :						Dict       )			->					List[str]:
														torch.manual_seed(0       )
														__snake_case	:    Any											=     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=1000					,			)
														return CLIPTextModelWithProjection(lowerCamelCase       )

							@property
							def 					__snake_case      (							self :						Tuple       )			->					Dict:
														torch.manual_seed(0       )

														__snake_case	:    List[str]											=     {
														    "num_attention_heads": 2,
														    "attention_head_dim": 12,
														    "embedding_dim": self.text_embedder_hidden_size,
														    "num_layers": 1,
														}

														__snake_case	:    List[str]											=     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
														__snake_case	:    Optional[int]											=     nn.Parameter(torch.ones(model.clip_std.shape       )       )
														return model

							@property
							def 					__snake_case      (							self :						List[Any]       )			->					Dict:
														torch.manual_seed(0       )
														__snake_case	:    Optional[int]											=     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					,			)

														__snake_case	:    Any											=     CLIPVisionModelWithProjection(lowerCamelCase       )
														return model

							@property
							def 					__snake_case      (							self :						Tuple       )			->					Optional[Any]:
														__snake_case	:    Union[str, Any]											=     CLIPImageProcessor(
														    crop_size=224					,			do_center_crop=lowerCamelCase					,			do_normalize=lowerCamelCase					,			do_resize=lowerCamelCase					,			image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]					,			image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]					,			resample=3					,			size=224					,			)

														return image_processor

							def 					__snake_case      (							self :						List[str]       )			->					Any:
														__snake_case	:    Optional[int]											=     self.dummy_prior
														__snake_case	:    Union[str, Any]											=     self.dummy_image_encoder
														__snake_case	:    List[Any]											=     self.dummy_text_encoder
														__snake_case	:    Tuple											=     self.dummy_tokenizer
														__snake_case	:    List[str]											=     self.dummy_image_processor

														__snake_case	:    int											=     UnCLIPScheduler(
														    variance_type="fixed_small_log"					,			prediction_type="sample"					,			num_train_timesteps=1000					,			clip_sample=lowerCamelCase					,			clip_sample_range=10.0					,			)

														__snake_case	:    List[str]											=     {
														    "prior": prior,
														    "image_encoder": image_encoder,
														    "text_encoder": text_encoder,
														    "tokenizer": tokenizer,
														    "scheduler": scheduler,
														    "image_processor": image_processor,
														}

														return components

							def 					__snake_case      (							self :						str					,			lowerCamelCase :						List[Any]					,			lowerCamelCase :						Optional[int]=0       )			->					List[Any]:
														if str(lowerCamelCase       ).startswith("mps"       ):
																					__snake_case	:    List[Any]											=     torch.manual_seed(lowerCamelCase       )
														else:
																					__snake_case	:    Optional[Any]											=     torch.Generator(device=lowerCamelCase       ).manual_seed(lowerCamelCase       )
														__snake_case	:    int											=     {
														    "prompt": "horse",
														    "generator": generator,
														    "guidance_scale": 4.0,
														    "num_inference_steps": 2,
														    "output_type": "np",
														}
														return inputs

							def 					__snake_case      (							self :						Dict       )			->					List[str]:
														__snake_case	:    str											=     "cpu"

														__snake_case	:    Dict											=     self.get_dummy_components()

														__snake_case	:    List[Any]											=     self.pipeline_class(**lowerCamelCase       )
														__snake_case	:    Tuple											=     pipe.to(lowerCamelCase       )

														pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    List[str]											=     pipe(**self.get_dummy_inputs(lowerCamelCase       )       )
														__snake_case	:    Any											=     output.image_embeds

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

														__snake_case	:    Optional[int]											=     image[0, -10:]
														__snake_case	:    Optional[int]											=     image_from_tuple[0, -10:]

														assert image.shape == (1, 32)

														__snake_case	:    Union[str, Any]											=     np.array(
														    [-0.05_32, 1.71_20, 0.36_56, -1.08_52, -0.89_46, -1.17_56, 0.43_48, 0.24_82, 0.51_46, -0.11_56]       )

														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 					__snake_case      (							self :						Union[str, Any]       )			->					Union[str, Any]:
														__snake_case	:    Optional[int]											=     torch_device == "cpu"
														__snake_case	:    List[str]											=     True
														__snake_case	:    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 					__snake_case      (							self :						int       )			->					int:
														__snake_case	:    List[str]											=     torch_device == "cpu"
														__snake_case	:    Optional[int]											=     False

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





def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase			):
							return int((input_a, input_a).count(0			) == 0			)







def        lowerCAmelCase_  (      ):
							assert and_gate(0							,			0			) == 0
							assert and_gate(0							,			1			) == 0
							assert and_gate(1							,			0			) == 0
							assert and_gate(1							,			1			) == 1


if __name__ == "__main__":
			test_and_gate()
			print(and_gate(1, 0))
			print(and_gate(0, 0))
			print(and_gate(0, 1))
			print(and_gate(1, 1))

