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

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




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




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




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




      @property
      def 					_A     (	self						:    List[Any]	):
             return self.time_input_dim * 4




      @property
      def 					_A     (	self						:    Union[str, Any]	):
             return 100




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




      @property
      def 					_A     (	self						:    List[str]	):
             torch.manual_seed(0	)
             _UpperCAmelCase					:  Optional[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(A	)




      @property
      def 					_A     (	self						:    Optional[int]	):
             torch.manual_seed(0	)

             _UpperCAmelCase					:  Optional[int]											=   {
                 "num_attention_heads": 2,
                 "attention_head_dim": 12,
                 "embedding_dim": self.text_embedder_hidden_size,
                 "num_layers": 1,
             }

             _UpperCAmelCase					:  List[str]											=   PriorTransformer(**A	)
             # 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					:  Any											=   nn.Parameter(torch.ones(model.clip_std.shape	)	)
             return model




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




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

             _UpperCAmelCase					:  str											=   UnCLIPScheduler(
                 variance_type="fixed_small_log"						, prediction_type="sample"						, num_train_timesteps=1000						, clip_sample=A						, clip_sample_range=10.0						, )

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

             return components




      def 					_A     (	self						:    List[str]						, A						:    str						, A						:    Any=0	):
             if str(A	).startswith("mps"	):
                    _UpperCAmelCase					:  Optional[Any]											=   torch.manual_seed(A	)
             else:
                    _UpperCAmelCase					:  str											=   torch.Generator(device=A	).manual_seed(A	)

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

             _UpperCAmelCase					:  int											=   {
                 "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						:    Tuple	):
             _UpperCAmelCase					:  List[Any]											=   "cpu"

             _UpperCAmelCase					:  Dict											=   self.get_dummy_components()

             _UpperCAmelCase					:  List[str]											=   self.pipeline_class(**A	)
             _UpperCAmelCase					:  Dict											=   pipe.to(A	)

             pipe.set_progress_bar_config(disable=A	)

             _UpperCAmelCase					:  Union[str, Any]											=   pipe(**self.get_dummy_inputs(A	)	)
             _UpperCAmelCase					:  Dict											=   output.image_embeds

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

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

             assert image.shape == (1, 32)

             _UpperCAmelCase					:  List[Any]											=   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					:  Dict											=   torch_device == "cpu"
             _UpperCAmelCase					:  str											=   True
             _UpperCAmelCase					:  Dict											=   False

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





      @skip_mps
      def 					_A     (	self						:    Optional[Any]	):
             _UpperCAmelCase					:  Optional[int]											=   torch_device == "cpu"
             _UpperCAmelCase					:  Dict											=   False

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


'''simple docstring'''




def      UpperCamelCase_							( _UpperCAmelCase  :				Optional[int]      ,     _UpperCAmelCase  :				List[Any]   )   ->   List[str]:


       """simple docstring"""







       if len(str(_UpperCAmelCase   )   ) == 1 or len(str(_UpperCAmelCase   )   ) == 1:
              return a * b

       _UpperCAmelCase					:  Any											=   max(len(str(_UpperCAmelCase   )   )      ,     len(str(_UpperCAmelCase   )   )   )
       _UpperCAmelCase					:  Any											=   ma // 2

       _UpperCAmelCase				,  _UpperCAmelCase					:  Union[str, Any]											=   divmod(_UpperCAmelCase      ,     10**ma   )
       _UpperCAmelCase				,  _UpperCAmelCase					:  int											=   divmod(_UpperCAmelCase      ,     10**ma   )

       _UpperCAmelCase					:  List[str]											=   karatsuba(_UpperCAmelCase      ,     _UpperCAmelCase   )
       _UpperCAmelCase					:  int											=   karatsuba((aa + aa)      ,     (ba + ba)   )
       _UpperCAmelCase					:  Any											=   karatsuba(_UpperCAmelCase      ,     _UpperCAmelCase   )

       return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)

def      UpperCamelCase_							( )   ->   List[str]:


       """simple docstring"""







       print(karatsuba(15_463      ,     23_489   )   )


if __name__ == "__main__":
  main()

