

import unittest

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

from diffusers import KandinskyPriorPipeline, 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      		=				KandinskyPriorPipeline
      __UpperCAmelCase      		=				['prompt']
      __UpperCAmelCase      		=				['prompt', 'negative_prompt']
      __UpperCAmelCase      		=				[
          'num_images_per_prompt',
          'generator',
          'num_inference_steps',
          'latents',
          'negative_prompt',
          'guidance_scale',
          'output_type',
          'return_dict',
      ]
      __UpperCAmelCase      		=				False
      @property
      def 	_lowerCAmelCase					(				self					:							List[str]    ):
           return 32
      @property
      def 	_lowerCAmelCase					(				self					:							Dict    ):
           return 32
      @property
      def 	_lowerCAmelCase					(				self					:							int    ):
           return self.time_input_dim
      @property
      def 	_lowerCAmelCase					(				self					:							Optional[int]    ):
           return self.time_input_dim * 4
      @property
      def 	_lowerCAmelCase					(				self					:							int    ):
           return 100
      @property
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )
           return tokenizer
      @property
      def 	_lowerCAmelCase					(				self					:							int    ):
           torch.manual_seed(0    )
           SCREAMING_SNAKE_CASE										=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(snake_case    )
      @property
      def 	_lowerCAmelCase					(				self					:							int    ):
           torch.manual_seed(0    )

           SCREAMING_SNAKE_CASE										={
               'num_attention_heads': 2,
               'attention_head_dim': 12,
               'embedding_dim': self.text_embedder_hidden_size,
               'num_layers': 1,
           }

           SCREAMING_SNAKE_CASE										=PriorTransformer(**snake_case    )
           # 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
           SCREAMING_SNAKE_CASE										=nn.Parameter(torch.ones(model.clip_std.shape    )    )
           return model
      @property
      def 	_lowerCAmelCase					(				self					:							Tuple    ):
           torch.manual_seed(0    )
           SCREAMING_SNAKE_CASE										=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      ,)

           SCREAMING_SNAKE_CASE										=CLIPVisionModelWithProjection(snake_case    )
           return model
      @property
      def 	_lowerCAmelCase					(				self					:							str    ):
           SCREAMING_SNAKE_CASE										=CLIPImageProcessor(
               crop_size=224      ,do_center_crop=snake_case      ,do_normalize=snake_case      ,do_resize=snake_case      ,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 	_lowerCAmelCase					(				self					:							Union[str, Any]    ):
           SCREAMING_SNAKE_CASE										=self.dummy_prior
           SCREAMING_SNAKE_CASE										=self.dummy_image_encoder
           SCREAMING_SNAKE_CASE										=self.dummy_text_encoder
           SCREAMING_SNAKE_CASE										=self.dummy_tokenizer
           SCREAMING_SNAKE_CASE										=self.dummy_image_processor

           SCREAMING_SNAKE_CASE										=UnCLIPScheduler(
               variance_type='fixed_small_log'      ,prediction_type='sample'      ,num_train_timesteps=1000      ,clip_sample=snake_case      ,clip_sample_range=10.0      ,)

           SCREAMING_SNAKE_CASE										={
               'prior': prior,
               'image_encoder': image_encoder,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'scheduler': scheduler,
               'image_processor': image_processor,
           }

           return components
      def 	_lowerCAmelCase					(				self					:							List[str]      ,snake_case					:							int      ,snake_case					:							Any=0    ):
           if str(snake_case    ).startswith('mps'    ):
                SCREAMING_SNAKE_CASE										=torch.manual_seed(snake_case    )
           else:
                SCREAMING_SNAKE_CASE										=torch.Generator(device=snake_case    ).manual_seed(snake_case    )
           SCREAMING_SNAKE_CASE										={
               'prompt': 'horse',
               'generator': generator,
               'guidance_scale': 4.0,
               'num_inference_steps': 2,
               'output_type': 'np',
           }
           return inputs
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										='cpu'

           SCREAMING_SNAKE_CASE										=self.get_dummy_components()

           SCREAMING_SNAKE_CASE										=self.pipeline_class(**snake_case    )
           SCREAMING_SNAKE_CASE										=pipe.to(snake_case    )

           pipe.set_progress_bar_config(disable=snake_case    )

           SCREAMING_SNAKE_CASE										=pipe(**self.get_dummy_inputs(snake_case    )    )
           SCREAMING_SNAKE_CASE										=output.image_embeds

           SCREAMING_SNAKE_CASE										=pipe(
               **self.get_dummy_inputs(snake_case    )      ,return_dict=snake_case      ,)[0]

           SCREAMING_SNAKE_CASE										=image[0, -10:]
           SCREAMING_SNAKE_CASE										=image_from_tuple[0, -10:]

           assert image.shape == (1, 32)

           SCREAMING_SNAKE_CASE										=np.array(
               [-0.0_532, 1.7_120, 0.3_656, -1.0_852, -0.8_946, -1.1_756, 0.4_348, 0.2_482, 0.5_146, -0.1_156]    )

           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 	_lowerCAmelCase					(				self					:							Tuple    ):
           SCREAMING_SNAKE_CASE										=torch_device == 'cpu'
           SCREAMING_SNAKE_CASE										=True
           SCREAMING_SNAKE_CASE										=False

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


      @skip_mps
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										=torch_device == 'cpu'
           SCREAMING_SNAKE_CASE										=False

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




def       snake_case__    (       lowerCAmelCase_,   lowerCAmelCase_,   lowerCAmelCase_      ):





     """simple docstring"""







     if power < 0:
          return -1
     base %= mod
     SCREAMING_SNAKE_CASE										=1

     while power > 0:
          if power & 1:
               SCREAMING_SNAKE_CASE										=(result * base) % mod
          SCREAMING_SNAKE_CASE										=power >> 1
          SCREAMING_SNAKE_CASE										=(base * base) % mod

     return result







def       snake_case__    (       ):





     """simple docstring"""







     print(modular_exponential(3,   200,   13      )      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 main()

