


"""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      __lowerCamelCase	(       _lowercase	,       unittest.TestCase					):

     '''simple docstring'''
     A_							:						Optional[Any]     =		KandinskyPipeline
     A_							:						Any     =		[
         'prompt',
         'image_embeds',
         'negative_image_embeds',
     ]
     A_							:						Optional[Any]     =		['prompt', 'negative_prompt', 'image_embeds', 'negative_image_embeds']
     A_							:						List[str]     =		[
         'generator',
         'height',
         'width',
         'latents',
         'guidance_scale',
         'negative_prompt',
         'num_inference_steps',
         'return_dict',
         'guidance_scale',
         'num_images_per_prompt',
         'output_type',
         'return_dict',
     ]
     A_							:						int     =		False


     @property
     def 				_UpperCAmelCase   (   self				)							->				Any:
          return 32


     @property
     def 				_UpperCAmelCase   (   self				)							->				Optional[Any]:
          return 32


     @property
     def 				_UpperCAmelCase   (   self				)							->				List[Any]:
          return self.time_input_dim


     @property
     def 				_UpperCAmelCase   (   self				)							->				Union[str, Any]:
          return self.time_input_dim * 4


     @property
     def 				_UpperCAmelCase   (   self				)							->				Dict:
          return 100


     @property
     def 				_UpperCAmelCase   (   self				)							->				List[str]:
          _a     						=					XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''				)
          return tokenizer


     @property
     def 				_UpperCAmelCase   (   self				)							->				Union[str, Any]:
          torch.manual_seed(0				)
          _a     						=					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     ,					)

          _a     						=					MultilingualCLIP(__lowerCAmelCase				)
          _a     						=					text_encoder.eval()

          return text_encoder


     @property
     def 				_UpperCAmelCase   (   self				)							->				Optional[Any]:
          torch.manual_seed(0				)

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

          _a     						=					UNetaDConditionModel(**__lowerCAmelCase				)
          return model


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


     def 				_UpperCAmelCase   (   self				)							->				Dict:
          _a     						=					self.dummy_text_encoder
          _a     						=					self.dummy_tokenizer
          _a     						=					self.dummy_unet
          _a     						=					self.dummy_movq

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

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


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

          _a     						=					self.get_dummy_components()

          _a     						=					self.pipeline_class(**__lowerCAmelCase				)
          _a     						=					pipe.to(__lowerCAmelCase				)

          pipe.set_progress_bar_config(disable=__lowerCAmelCase				)

          _a     						=					pipe(**self.get_dummy_inputs(__lowerCAmelCase				)				)
          _a     						=					output.images

          _a     						=					pipe(
              **self.get_dummy_inputs(__lowerCAmelCase				)     ,					return_dict=__lowerCAmelCase     ,					)[0]

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

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

          _a     						=					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      __lowerCamelCase	(       unittest.TestCase					):

     '''simple docstring'''


     def 				_UpperCAmelCase   (   self				)							->				str:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()





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

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

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

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

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

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

          _a     						=					output.images[0]

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

          assert_mean_pixel_difference(__lowerCAmelCase     ,					__lowerCAmelCase				)






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCAmelCase 	=      {"configuration_visual_bert": ["VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VisualBertConfig"]}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase 	=      [
				    "VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "VisualBertForMultipleChoice",
				    "VisualBertForPreTraining",
				    "VisualBertForQuestionAnswering",
				    "VisualBertForRegionToPhraseAlignment",
				    "VisualBertForVisualReasoning",
				    "VisualBertLayer",
				    "VisualBertModel",
				    "VisualBertPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_visual_bert import (
								    VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VisualBertForMultipleChoice,
								    VisualBertForPreTraining,
								    VisualBertForQuestionAnswering,
								    VisualBertForRegionToPhraseAlignment,
								    VisualBertForVisualReasoning,
								    VisualBertLayer,
								    VisualBertModel,
								    VisualBertPreTrainedModel,
								)


else:
				import sys

				__lowerCAmelCase 	=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





