import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, 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    A_ (       a_			,       unittest.TestCase ):
  _SCREAMING_SNAKE_CASE    				=			KandinskyImgaImgPipeline
  _SCREAMING_SNAKE_CASE    				=			["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""]
  _SCREAMING_SNAKE_CASE    				=			[
      """prompt""",
      """negative_prompt""",
      """image_embeds""",
      """negative_image_embeds""",
      """image""",
  ]
  _SCREAMING_SNAKE_CASE    				=			[
      """generator""",
      """height""",
      """width""",
      """strength""",
      """guidance_scale""",
      """negative_prompt""",
      """num_inference_steps""",
      """return_dict""",
      """guidance_scale""",
      """num_images_per_prompt""",
      """output_type""",
      """return_dict""",
  ]
  _SCREAMING_SNAKE_CASE    				=			False

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

  @property
  def 		_UpperCAmelCase   (		self :      Union[str, Any]       ):
   return 32

  @property
  def 		_UpperCAmelCase   (		self :      Optional[int]       ):
   return self.time_input_dim

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

  @property
  def 		_UpperCAmelCase   (		self :      int       ):
   return 1_00

  @property
  def 		_UpperCAmelCase   (		self :      Optional[int]       ):
   __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=10_05     ,							)

   __a       =  MultilingualCLIP(__SCREAMING_SNAKE_CASE       )
   __a       =  text_encoder.eval()

   return text_encoder

  @property
  def 		_UpperCAmelCase   (		self :      Union[str, 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(**__SCREAMING_SNAKE_CASE       )
   return model

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

  def 		_UpperCAmelCase   (		self :      List[Any]       ):
   __a       =  self.dummy_text_encoder
   __a       =  self.dummy_tokenizer
   __a       =  self.dummy_unet
   __a       =  self.dummy_movq

   __a       =  {
       "num_train_timesteps": 10_00,
       "beta_schedule": "linear",
       "beta_start": 0.0_00_85,
       "beta_end": 0.0_12,
       "clip_sample": False,
       "set_alpha_to_one": False,
       "steps_offset": 0,
       "prediction_type": "epsilon",
       "thresholding": False,
   }

   __a       =  DDIMScheduler(**__SCREAMING_SNAKE_CASE       )

   __a       =  {
       "text_encoder": text_encoder,
       "tokenizer": tokenizer,
       "unet": unet,
       "scheduler": scheduler,
       "movq": movq,
   }

   return components

  def 		_UpperCAmelCase   (		self :      Tuple     ,							__SCREAMING_SNAKE_CASE :      Union[str, Any]     ,							__SCREAMING_SNAKE_CASE :      int=0       ):
   __a       =  floats_tensor((1, self.cross_attention_dim)     ,							rng=random.Random(__SCREAMING_SNAKE_CASE       )       ).to(__SCREAMING_SNAKE_CASE       )
   __a       =  floats_tensor((1, self.cross_attention_dim)     ,							rng=random.Random(seed + 1       )       ).to(__SCREAMING_SNAKE_CASE       )
   # create init_image
   __a       =  floats_tensor((1, 3, 64, 64)     ,							rng=random.Random(__SCREAMING_SNAKE_CASE       )       ).to(__SCREAMING_SNAKE_CASE       )
   __a       =  image.cpu().permute(0     ,							2     ,							3     ,							1       )[0]
   __a       =  Image.fromarray(np.uinta(__SCREAMING_SNAKE_CASE       )       ).convert("RGB"       ).resize((2_56, 2_56)       )

   if str(__SCREAMING_SNAKE_CASE       ).startswith("mps"       ):
    __a       =  torch.manual_seed(__SCREAMING_SNAKE_CASE       )
   else:
    __a       =  torch.Generator(device=__SCREAMING_SNAKE_CASE       ).manual_seed(__SCREAMING_SNAKE_CASE       )
   __a       =  {
       "prompt": "horse",
       "image": init_image,
       "image_embeds": image_embeds,
       "negative_image_embeds": negative_image_embeds,
       "generator": generator,
       "height": 64,
       "width": 64,
       "num_inference_steps": 10,
       "guidance_scale": 7.0,
       "strength": 0.2,
       "output_type": "np",
   }
   return inputs

  def 		_UpperCAmelCase   (		self :      Optional[Any]       ):
   __a       =  "cpu"

   __a       =  self.get_dummy_components()

   __a       =  self.pipeline_class(**__SCREAMING_SNAKE_CASE       )
   __a       =  pipe.to(__SCREAMING_SNAKE_CASE       )

   pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE       )

   __a       =  pipe(**self.get_dummy_inputs(__SCREAMING_SNAKE_CASE       )       )
   __a       =  output.images

   __a       =  pipe(
       **self.get_dummy_inputs(__SCREAMING_SNAKE_CASE       )     ,							return_dict=__SCREAMING_SNAKE_CASE     ,							)[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.61_47_49_43, 0.6_07_35_39, 0.43_30_85_44, 0.5_92_82_69, 0.47_49_35_95, 0.46_75_59_73, 0.4_61_38_38, 0.45_36_87_97, 0.50_11_92_33]       )
   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    A_ (       unittest.TestCase ):

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

  def 		_UpperCAmelCase   (		self :      Union[str, Any]       ):
   __a       =  load_numpy(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
       "/kandinsky/kandinsky_img2img_frog.npy"       )

   __a       =  load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"       )
   __a       =  "A red cartoon frog, 4k"

   __a       =  KandinskyPriorPipeline.from_pretrained(
       "kandinsky-community/kandinsky-2-1-prior"     ,							torch_dtype=torch.floataa       )
   pipe_prior.to(__SCREAMING_SNAKE_CASE       )

   __a       =  KandinskyImgaImgPipeline.from_pretrained(
       "kandinsky-community/kandinsky-2-1"     ,							torch_dtype=torch.floataa       )
   __a       =  pipeline.to(__SCREAMING_SNAKE_CASE       )

   pipeline.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE       )

   __a       =  torch.Generator(device="cpu"       ).manual_seed(0       )
   __a       ,     __a       =  pipe_prior(
       __SCREAMING_SNAKE_CASE     ,							generator=__SCREAMING_SNAKE_CASE     ,							num_inference_steps=5     ,							negative_prompt=""     ,							).to_tuple()

   __a       =  pipeline(
       __SCREAMING_SNAKE_CASE     ,							image=__SCREAMING_SNAKE_CASE     ,							image_embeds=__SCREAMING_SNAKE_CASE     ,							negative_image_embeds=__SCREAMING_SNAKE_CASE     ,							generator=__SCREAMING_SNAKE_CASE     ,							num_inference_steps=1_00     ,							height=7_68     ,							width=7_68     ,							strength=0.2     ,							output_type="np"     ,							)

   __a       =  output.images[0]

   assert image.shape == (7_68, 7_68, 3)

   assert_mean_pixel_difference(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )



import unittest

from transformers import AutoTokenizer, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow


if is_flax_available():
  import jax.numpy as jnp

  from transformers import FlaxXLMRobertaModel
@require_sentencepiece
@require_tokenizers
@require_flax
class    A_ (       unittest.TestCase ):

  @slow
  def 		_UpperCAmelCase   (		self :      Dict       ):
   __a       =  FlaxXLMRobertaModel.from_pretrained("xlm-roberta-base"       )
   __a       =  AutoTokenizer.from_pretrained("xlm-roberta-base"       )
   __a       =  "The dog is cute and lives in the garden house"
   __a       =  jnp.array([tokenizer.encode(__SCREAMING_SNAKE_CASE       )]       )

   __a       =  (1, 12, 7_68)  # batch_size, sequence_length, embedding_vector_dim
   __a       =  jnp.array(
       [[-0.01_01, 0.12_18, -0.08_03, 0.08_01, 0.13_27, 0.07_76, -0.12_15, 0.23_83, 0.33_38, 0.31_06, 0.03_00, 0.02_52]]       )

   __a       =  model(__SCREAMING_SNAKE_CASE       )["last_hidden_state"]
   self.assertEqual(output.shape     ,							__SCREAMING_SNAKE_CASE       )
   # compare the actual values for a slice of last dim
   self.assertTrue(jnp.allclose(output[:, :, -1]     ,							__SCREAMING_SNAKE_CASE     ,							atol=1E-3       )       )


