'''simple docstring'''




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      lowerCamelCase_     (_lowerCamelCase							,			unittest.TestCase   ):
						'''simple docstring'''

						__UpperCamelCase:  Union[str, Any]      =						KandinskyVaaPriorEmbaEmbPipeline
						__UpperCamelCase:  int      =						["prompt", "image"]
						__UpperCamelCase:  Dict      =						["prompt", "image"]
						__UpperCamelCase:  Tuple      =						[
						    "num_images_per_prompt",
						    "strength",
						    "generator",
						    "num_inference_steps",
						    "latents",
						    "negative_prompt",
						    "guidance_scale",
						    "output_type",
						    "return_dict",
						]
						__UpperCamelCase:  Optional[Any]      =						False




						@property
						def 					_A     (	self						:    Dict	):
													return 32




						@property
						def 					_A     (	self						:    List[str]	):
													return 32




						@property
						def 					_A     (	self						:    Optional[Any]	):
													return self.time_input_dim




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




						@property
						def 					_A     (	self						:    List[Any]	):
													return 100




						@property
						def 					_A     (	self						:    str	):
													_UpperCAmelCase					:  Dict											=   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)
													return tokenizer




						@property
						def 					_A     (	self						:    Dict	):
													torch.manual_seed(0	)
													_UpperCAmelCase					:  Tuple											=   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(__UpperCamelCase	)




						@property
						def 					_A     (	self						:    str	):
													torch.manual_seed(0	)

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

													_UpperCAmelCase					:  str											=   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
													_UpperCAmelCase					:  str											=   nn.Parameter(torch.ones(model.clip_std.shape	)	)
													return model




						@property
						def 					_A     (	self						:    Optional[int]	):
													torch.manual_seed(0	)
													_UpperCAmelCase					:  str											=   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					:  Union[str, Any]											=   CLIPVisionModelWithProjection(__UpperCamelCase	)
													return model




						@property
						def 					_A     (	self						:    str	):
													_UpperCAmelCase					:  Optional[Any]											=   CLIPImageProcessor(
													    crop_size=224						, do_center_crop=__UpperCamelCase						, do_normalize=__UpperCamelCase						, do_resize=__UpperCamelCase						, 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 					_A     (	self						:    Any	):
													_UpperCAmelCase					:  Dict											=   self.dummy_prior
													_UpperCAmelCase					:  Tuple											=   self.dummy_image_encoder
													_UpperCAmelCase					:  List[str]											=   self.dummy_text_encoder
													_UpperCAmelCase					:  Optional[Any]											=   self.dummy_tokenizer
													_UpperCAmelCase					:  List[str]											=   self.dummy_image_processor

													_UpperCAmelCase					:  List[str]											=   UnCLIPScheduler(
													    variance_type="fixed_small_log"						, prediction_type="sample"						, num_train_timesteps=1000						, clip_sample=__UpperCamelCase						, clip_sample_range=10.0						, )

													_UpperCAmelCase					:  List[str]											=   {
													    'prior': prior,
													    'image_encoder': image_encoder,
													    'text_encoder': text_encoder,
													    'tokenizer': tokenizer,
													    'scheduler': scheduler,
													    'image_processor': image_processor,
													}

													return components




						def 					_A     (	self						:    Optional[int]						, A						:    Tuple						, A						:    Any=0	):







													if str(__UpperCamelCase	).startswith("mps"	):
																				_UpperCAmelCase					:  str											=   torch.manual_seed(__UpperCamelCase	)
													else:
																				_UpperCAmelCase					:  Optional[Any]											=   torch.Generator(device=__UpperCamelCase	).manual_seed(__UpperCamelCase	)

													_UpperCAmelCase					:  Optional[int]											=   floats_tensor((1, 3, 64, 64)						, rng=random.Random(__UpperCamelCase	)	).to(__UpperCamelCase	)
													_UpperCAmelCase					:  Tuple											=   image.cpu().permute(0						, 2						, 3						, 1	)[0]
													_UpperCAmelCase					:  int											=   Image.fromarray(np.uinta(__UpperCamelCase	)	).convert("RGB"	).resize((256, 256)	)

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




						def 					_A     (	self						:    Optional[Any]	):
													_UpperCAmelCase					:  List[str]											=   'cpu'

													_UpperCAmelCase					:  Dict											=   self.get_dummy_components()

													_UpperCAmelCase					:  Union[str, Any]											=   self.pipeline_class(**__UpperCamelCase	)
													_UpperCAmelCase					:  List[str]											=   pipe.to(__UpperCamelCase	)

													pipe.set_progress_bar_config(disable=__UpperCamelCase	)

													_UpperCAmelCase					:  str											=   pipe(**self.get_dummy_inputs(__UpperCamelCase	)	)
													_UpperCAmelCase					:  Any											=   output.image_embeds

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

													_UpperCAmelCase					:  List[str]											=   image[0, -10:]
													_UpperCAmelCase					:  Optional[int]											=   image_from_tuple[0, -10:]

													assert image.shape == (1, 32)

													_UpperCAmelCase					:  List[str]											=   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 					_A     (	self						:    List[Any]	):
													_UpperCAmelCase					:  Optional[Any]											=   torch_device == 'cpu'
													_UpperCAmelCase					:  Optional[int]											=   True
													_UpperCAmelCase					:  Any											=   False

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





						@skip_mps
						def 					_A     (	self						:    Union[str, Any]	):
													_UpperCAmelCase					:  List[Any]											=   torch_device == 'cpu'
													_UpperCAmelCase					:  Union[str, Any]											=   False

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


'''simple docstring'''




def      UpperCamelCase_							( _UpperCAmelCase  :				int   )   ->   bool:


       """simple docstring"""







       _UpperCAmelCase					:  Optional[int]											=   9

       while num > 0:
              if num % 10 != digit:
                     return False
              num //= 100
              digit -= 1

       return True

def      UpperCamelCase_							( )   ->   int:


       """simple docstring"""







       _UpperCAmelCase					:  Optional[Any]											=   138_902_663

       while not is_square_form(num * num   ):
              if num % 10 == 3:
                     num -= 6  # (3 - 6) % 10 = 7
              else:
                     num -= 4  # (7 - 4) % 10 = 3

       return num * 10


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

