




'''simple docstring'''




def   a_							(   __snake_case							:    List[Any]     , __snake_case							:    int     )							->		int:



       """simple docstring"""
       return (input_a, input_a).count(0     ) % 2





def   a_							(   )							->		None:



       """simple docstring"""
       assert xor_gate(0     , 0     ) == 0
       assert xor_gate(0     , 1     ) == 1
       assert xor_gate(1     , 0     ) == 1
       assert xor_gate(1     , 1     ) == 0


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










'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class 						__UpperCamelCase (				lowerCamelCase__    ,      unittest.TestCase       ):
       lowercase			:					Tuple   		=KandinskyPipeline
       lowercase			:					Optional[int]   		=[
           'prompt',
           'image_embeds',
           'negative_image_embeds',
       ]
       lowercase			:					Union[str, Any]   		=['prompt', 'negative_prompt', 'image_embeds', 'negative_image_embeds']
       lowercase			:					Dict   		=[
           'generator',
           'height',
           'width',
           'latents',
           'guidance_scale',
           'negative_prompt',
           'num_inference_steps',
           'return_dict',
           'guidance_scale',
           'num_images_per_prompt',
           'output_type',
           'return_dict',
       ]
       lowercase			:					Dict   		=False






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              return 32






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              return 32






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              return self.time_input_dim






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              return self.time_input_dim * 4






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              return 100






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              lowerCamelCase_							=XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''						)
              return tokenizer






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              torch.manual_seed(0						)
              lowerCamelCase_							=MCLIPConfig(
                  numDims=self.cross_attention_dim,	transformerDimensions=self.text_embedder_hidden_size,	hidden_size=self.text_embedder_hidden_size,	intermediate_size=37,	num_attention_heads=4,	num_hidden_layers=5,	vocab_size=1_005,	)

              lowerCamelCase_							=MultilingualCLIP(lowerCAmelCase						)
              lowerCamelCase_							=text_encoder.eval()

              return text_encoder






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              torch.manual_seed(0						)

              lowerCamelCase_							={
                  '''in_channels''': 4,
                  # Out channels is double in channels because predicts mean and variance
                  '''out_channels''': 8,
                  '''addition_embed_type''': '''text_image''',
                  '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
                  '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
                  '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
                  '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
                  '''layers_per_block''': 1,
                  '''encoder_hid_dim''': self.text_embedder_hidden_size,
                  '''encoder_hid_dim_type''': '''text_image_proj''',
                  '''cross_attention_dim''': self.cross_attention_dim,
                  '''attention_head_dim''': 4,
                  '''resnet_time_scale_shift''': '''scale_shift''',
                  '''class_embed_type''': None,
              }

              lowerCamelCase_							=UNetaDConditionModel(**lowerCAmelCase						)
              return model






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              return {
                  "block_out_channels": [32, 64],
                  "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
                  "in_channels": 3,
                  "latent_channels": 4,
                  "layers_per_block": 1,
                  "norm_num_groups": 8,
                  "norm_type": "spatial",
                  "num_vq_embeddings": 12,
                  "out_channels": 3,
                  "up_block_types": [
                      "AttnUpDecoderBlock2D",
                      "UpDecoderBlock2D",
                  ],
                  "vq_embed_dim": 4,
              }






       @property
       def   lowercase__  (							self						):



              """simple docstring"""







              torch.manual_seed(0						)
              lowerCamelCase_							=VQModel(**self.dummy_movq_kwargs						)
              return model






       def   lowercase__  (							self						):



              """simple docstring"""







              lowerCamelCase_							=self.dummy_text_encoder
              lowerCamelCase_							=self.dummy_tokenizer
              lowerCamelCase_							=self.dummy_unet
              lowerCamelCase_							=self.dummy_movq

              lowerCamelCase_							=DDIMScheduler(
                  num_train_timesteps=1_000,	beta_schedule='''linear''',	beta_start=0.0_0_0_8_5,	beta_end=0.0_1_2,	clip_sample=lowerCAmelCase,	set_alpha_to_one=lowerCAmelCase,	steps_offset=1,	prediction_type='''epsilon''',	thresholding=lowerCAmelCase,	)

              lowerCamelCase_							={
                  '''text_encoder''': text_encoder,
                  '''tokenizer''': tokenizer,
                  '''unet''': unet,
                  '''scheduler''': scheduler,
                  '''movq''': movq,
              }
              return components






       def   lowercase__  (							self,	lowerCAmelCase,	lowerCAmelCase=0						):



              """simple docstring"""







              lowerCamelCase_							=floats_tensor((1, self.cross_attention_dim),	rng=random.Random(lowerCAmelCase						)						).to(lowerCAmelCase						)
              lowerCamelCase_							=floats_tensor((1, self.cross_attention_dim),	rng=random.Random(seed + 1						)						).to(lowerCAmelCase						)
              if str(lowerCAmelCase						).startswith('''mps'''						):
                     lowerCamelCase_							=torch.manual_seed(lowerCAmelCase						)
              else:
                     lowerCamelCase_							=torch.Generator(device=lowerCAmelCase						).manual_seed(lowerCAmelCase						)
              lowerCamelCase_							={
                  '''prompt''': '''horse''',
                  '''image_embeds''': image_embeds,
                  '''negative_image_embeds''': negative_image_embeds,
                  '''generator''': generator,
                  '''height''': 64,
                  '''width''': 64,
                  '''guidance_scale''': 4.0,
                  '''num_inference_steps''': 2,
                  '''output_type''': '''np''',
              }
              return inputs






       def   lowercase__  (							self						):



              """simple docstring"""







              lowerCamelCase_							='''cpu'''

              lowerCamelCase_							=self.get_dummy_components()

              lowerCamelCase_							=self.pipeline_class(**lowerCAmelCase						)
              lowerCamelCase_							=pipe.to(lowerCAmelCase						)

              pipe.set_progress_bar_config(disable=lowerCAmelCase						)

              lowerCamelCase_							=pipe(**self.get_dummy_inputs(lowerCAmelCase						)						)
              lowerCamelCase_							=output.images

              lowerCamelCase_							=pipe(
                  **self.get_dummy_inputs(lowerCAmelCase						),	return_dict=lowerCAmelCase,	)[0]

              lowerCamelCase_							=image[0, -3:, -3:, -1]
              lowerCamelCase_							=image_from_tuple[0, -3:, -3:, -1]

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

              lowerCamelCase_							=np.array(
                  [0.3_2_8_6_6_3, 1.0, 0.2_3_2_1_6_8_7_3, 1.0, 0.9_2_7_1_7_5_6_4, 0.4_6_3_9_0_4_6, 0.9_6_8_9_4_7_7_7, 0.3_1_7_1_3_3_7_8, 0.6_2_9_3_9_5_3]						)

              assert (
                  np.abs(image_slice.flatten() - expected_slice						).max() < 1e-2
              ), f''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
              assert (
                  np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < 1e-2
              ), f''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''





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






       def   lowercase__  (							self						):



              """simple docstring"""







              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       def   lowercase__  (							self						):



              """simple docstring"""







              lowerCamelCase_							=load_numpy(
                  '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
                  '''/kandinsky/kandinsky_text2img_cat_fp16.npy'''						)

              lowerCamelCase_							=KandinskyPriorPipeline.from_pretrained(
                  '''kandinsky-community/kandinsky-2-1-prior''',	torch_dtype=torch.floataa						)
              pipe_prior.to(lowerCAmelCase						)

              lowerCamelCase_							=KandinskyPipeline.from_pretrained('''kandinsky-community/kandinsky-2-1''',	torch_dtype=torch.floataa						)
              lowerCamelCase_							=pipeline.to(lowerCAmelCase						)
              pipeline.set_progress_bar_config(disable=lowerCAmelCase						)

              lowerCamelCase_							='''red cat, 4k photo'''

              lowerCamelCase_							=torch.Generator(device='''cuda'''						).manual_seed(0						)
              lowerCamelCase_,   lowerCamelCase_							=pipe_prior(
                  lowerCAmelCase,	generator=lowerCAmelCase,	num_inference_steps=5,	negative_prompt='''''',	).to_tuple()

              lowerCamelCase_							=torch.Generator(device='''cuda'''						).manual_seed(0						)
              lowerCamelCase_							=pipeline(
                  lowerCAmelCase,	image_embeds=lowerCAmelCase,	negative_image_embeds=lowerCAmelCase,	generator=lowerCAmelCase,	num_inference_steps=100,	output_type='''np''',	)

              lowerCamelCase_							=output.images[0]

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

              assert_mean_pixel_difference(lowerCAmelCase,	lowerCAmelCase						)




