





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						(       UpperCAmelCase_  ,   unittest.TestCase						):
					__A  :     List[Any]            =      KandinskyPipeline
					__A  :     str            =      [
					    """prompt""",
					    """image_embeds""",
					    """negative_image_embeds""",
					]
					__A  :     int            =      ["""prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds"""]
					__A  :     Optional[Any]            =      [
					    """generator""",
					    """height""",
					    """width""",
					    """latents""",
					    """guidance_scale""",
					    """negative_prompt""",
					    """num_inference_steps""",
					    """return_dict""",
					    """guidance_scale""",
					    """num_images_per_prompt""",
					    """output_type""",
					    """return_dict""",
					]
					__A  :     str            =      False





					@property
					def 		UpperCamelCase(    self				):
								return 32





					@property
					def 		UpperCamelCase(    self				):
								return 32





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





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





					@property
					def 		UpperCamelCase(    self				):
								return 100





					@property
					def 		UpperCamelCase(    self				):
								_UpperCAmelCase											=      XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''				)
								return tokenizer





					@property
					def 		UpperCamelCase(    self				):
								torch.manual_seed(0				)
								_UpperCAmelCase											=      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=1005							,       )

								_UpperCAmelCase											=      MultilingualCLIP(__UpperCamelCase				)
								_UpperCAmelCase											=      text_encoder.eval()

								return text_encoder





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

								_UpperCAmelCase											=      {
								    '''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,
								}

								_UpperCAmelCase											=      UNetaDConditionModel(**__UpperCamelCase				)
								return model





					@property
					def 		UpperCamelCase(    self				):
								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 		UpperCamelCase(    self				):
								torch.manual_seed(0				)
								_UpperCAmelCase											=      VQModel(**self.dummy_movq_kwargs				)
								return model





					def 		UpperCamelCase(    self				):
								_UpperCAmelCase											=      self.dummy_text_encoder
								_UpperCAmelCase											=      self.dummy_tokenizer
								_UpperCAmelCase											=      self.dummy_unet
								_UpperCAmelCase											=      self.dummy_movq

								_UpperCAmelCase											=      DDIMScheduler(
								    num_train_timesteps=1000							,       beta_schedule='''linear'''							,       beta_start=0.00085							,       beta_end=0.012							,       clip_sample=__UpperCamelCase							,       set_alpha_to_one=__UpperCamelCase							,       steps_offset=1							,       prediction_type='''epsilon'''							,       thresholding=__UpperCamelCase							,       )

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





					def 		UpperCamelCase(    self							,       _UpperCamelCase							,       _UpperCamelCase=0				):
								_UpperCAmelCase											=      floats_tensor((1, self.cross_attention_dim)							,       rng=random.Random(__UpperCamelCase				)				).to(__UpperCamelCase				)
								_UpperCAmelCase											=      floats_tensor((1, self.cross_attention_dim)							,       rng=random.Random(seed + 1				)				).to(__UpperCamelCase				)
								if str(__UpperCamelCase				).startswith('''mps'''				):
											_UpperCAmelCase											=      torch.manual_seed(__UpperCamelCase				)
								else:
											_UpperCAmelCase											=      torch.Generator(device=__UpperCamelCase				).manual_seed(__UpperCamelCase				)
								_UpperCAmelCase											=      {
								    '''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 		UpperCamelCase(    self				):
								_UpperCAmelCase											=      '''cpu'''

								_UpperCAmelCase											=      self.get_dummy_components()

								_UpperCAmelCase											=      self.pipeline_class(**__UpperCamelCase				)
								_UpperCAmelCase											=      pipe.to(__UpperCamelCase				)

								pipe.set_progress_bar_config(disable=__UpperCamelCase				)

								_UpperCAmelCase											=      pipe(**self.get_dummy_inputs(__UpperCamelCase				)				)
								_UpperCAmelCase											=      output.images

								_UpperCAmelCase											=      pipe(
								    **self.get_dummy_inputs(__UpperCamelCase				)							,       return_dict=__UpperCamelCase							,       )[0]

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

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

								_UpperCAmelCase											=      np.array(
								    [0.328663, 1.0, 0.23216873, 1.0, 0.92717564, 0.4639046, 0.96894777, 0.31713378, 0.6293953]				)

								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 		UpperCamelCase(    self				):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()





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

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

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

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

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

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

								_UpperCAmelCase											=      output.images[0]

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

								assert_mean_pixel_difference(__UpperCamelCase							,       __UpperCamelCase				)






def     A__					(						SCREAMING_SNAKE_CASE_      :			List[Any]							,  SCREAMING_SNAKE_CASE_      :			Dict	)     ->     Any:






   """simple docstring"""







   if n == 0:
      return 1

   elif n % 2 == 1:
      return binary_exponentiation(SCREAMING_SNAKE_CASE_							,  n - 1	) * a

   else:
      _UpperCAmelCase											=      binary_exponentiation(SCREAMING_SNAKE_CASE_							,  n / 2	)
      return b * b


if __name__ == "__main__":
   try:
      UpperCAmelCase_											=  int(input("Enter Base : ").strip())
      UpperCAmelCase_											=  int(input("Enter Power : ").strip())
   except ValueError:
      print("Invalid literal for integer")

   UpperCAmelCase_											=  binary_exponentiation(BASE, POWER)
   print(f'''{BASE}^({POWER}) : {RESULT}''')