

import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length
def        UpperCAmelCase_     (		_A       ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__					=					int(_A       )
     SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__					=					t // 36_00, (t // 60) % 60, t % 60
     return F'''{h}:{m:02d}:{s:02d}''' if h != 0 else F'''{m:02d}:{s:02d}'''
def        UpperCAmelCase_     (		_A   ,	_A   ,	_A   ,	_A   ,	_A=3_00       ):





     '''simple docstring'''




     return F'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''
def        UpperCAmelCase_     (		_A       ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__					=					'''<table border="1" class="dataframe">\n'''
     html_code += """  <thead>\n <tr style="text-align: left;">\n"""
     for i in items[0]:
          html_code += F'''      <th>{i}</th>\n'''
     html_code += "    </tr>\n  </thead>\n  <tbody>\n"
     for line in items[1:]:
          html_code += "    <tr>\n"
          for elt in line:
               SCREAMING_SNAKE_CASE__					=					F'''{elt:.6f}''' if isinstance(_A   ,	_A       ) else str(_A       )
               html_code += F'''      <td>{elt}</td>\n'''
          html_code += "    </tr>\n"
     html_code += "  </tbody>\n</table><p>"
     return html_code






class  UpperCAmelCase__	:






  """simple docstring"""


  a     =      5
  a     =      0.2






  def __init__(							self		:	Optional[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Optional[str] = None			,     __lowerCamelCase		:	bool = True			,     __lowerCamelCase		:	Optional["NotebookTrainingTracker"] = None			,     __lowerCamelCase		:	int = 300			,     )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					total
       SCREAMING_SNAKE_CASE__					=					'''''' if prefix is None else prefix
       SCREAMING_SNAKE_CASE__					=					leave
       SCREAMING_SNAKE_CASE__					=					parent
       SCREAMING_SNAKE_CASE__					=					width
       SCREAMING_SNAKE_CASE__					=					None
       SCREAMING_SNAKE_CASE__					=					None
       SCREAMING_SNAKE_CASE__					=					None






  def    lowercase_	(							self		:	Optional[int]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	bool = False			,     __lowerCamelCase		:	str = None      )	->							Optional[Any]:
       SCREAMING_SNAKE_CASE__					=					value
       if comment is not None:
            SCREAMING_SNAKE_CASE__					=					comment
       if self.last_value is None:
            SCREAMING_SNAKE_CASE__					=					SCREAMING_SNAKE_CASE__					=					time.time()
            SCREAMING_SNAKE_CASE__					=					SCREAMING_SNAKE_CASE__					=					value
            SCREAMING_SNAKE_CASE__					=					SCREAMING_SNAKE_CASE__					=					None
            SCREAMING_SNAKE_CASE__					=					self.warmup
            SCREAMING_SNAKE_CASE__					=					1
            self.update_bar(__lowerCamelCase      )
       elif value <= self.last_value and not force_update:
            return
       elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for			,     self.total      ):
            if self.first_calls > 0:
                 self.first_calls -= 1
            SCREAMING_SNAKE_CASE__					=					time.time()
            SCREAMING_SNAKE_CASE__					=					current_time - self.start_time
            # We could have value = self.start_value if the update is called twixe with the same start value.
            if value > self.start_value:
                 SCREAMING_SNAKE_CASE__					=					self.elapsed_time / (value - self.start_value)
            else:
                 SCREAMING_SNAKE_CASE__					=					None
            if value >= self.total:
                 SCREAMING_SNAKE_CASE__					=					self.total
                 SCREAMING_SNAKE_CASE__					=					None
                 if not self.leave:
                      self.close()
            elif self.average_time_per_item is not None:
                 SCREAMING_SNAKE_CASE__					=					self.average_time_per_item * (self.total - value)
            self.update_bar(__lowerCamelCase      )
            SCREAMING_SNAKE_CASE__					=					value
            SCREAMING_SNAKE_CASE__					=					current_time
            if self.average_time_per_item is None:
                 SCREAMING_SNAKE_CASE__					=					1
            else:
                 SCREAMING_SNAKE_CASE__					=					max(int(self.update_every / self.average_time_per_item      )			,     1      )






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Optional[int]=None      )	->							str:
       SCREAMING_SNAKE_CASE__					=					''' ''' * (len(str(self.total      )      ) - len(str(__lowerCamelCase      )      )) + str(__lowerCamelCase      )
       if self.elapsed_time is None:
            SCREAMING_SNAKE_CASE__					=					f'''[{spaced_value}/{self.total} : < :'''
       elif self.predicted_remaining is None:
            SCREAMING_SNAKE_CASE__					=					f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time      )}'''
       else:
            SCREAMING_SNAKE_CASE__					=					(
                f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time      )} <'''
                f''' {format_time(self.predicted_remaining      )}'''
            )
            self.label += f''', {1/self.average_time_per_item:.2f} it/s'''
       self.label += "]" if self.comment is None or len(self.comment      ) == 0 else f''', {self.comment}]'''
       self.display()






  def    lowercase_	(							self		:	int      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					html_progress_bar(self.value			,     self.total			,     self.prefix			,     self.label			,     self.width      )
       if self.parent is not None:
            # If this is a child bar, the parent will take care of the display.
            self.parent.display()
            return
       if self.output is None:
            SCREAMING_SNAKE_CASE__					=					disp.display(disp.HTML(self.html_code      )			,     display_id=__lowerCamelCase      )
       else:
            self.output.update(disp.HTML(self.html_code      )      )







  def    lowercase_	(							self		:	int      )	->							Union[str, Any]:
       if self.parent is None and self.output is not None:
            self.output.update(disp.HTML(''''''      )      )






class  UpperCAmelCase__	( A__ ):






  """simple docstring"""


  def __init__(							self		:	Tuple			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	str=None      )	->							List[Any]:
       super().__init__(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					None if column_names is None else [column_names]
       SCREAMING_SNAKE_CASE__					=					None






  def    lowercase_	(							self		:	Tuple      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					html_progress_bar(self.value			,     self.total			,     self.prefix			,     self.label			,     self.width      )
       if self.inner_table is not None:
            self.html_code += text_to_html_table(self.inner_table      )
       if self.child_bar is not None:
            self.html_code += self.child_bar.html_code
       if self.output is None:
            SCREAMING_SNAKE_CASE__					=					disp.display(disp.HTML(self.html_code      )			,     display_id=__lowerCamelCase      )
       else:
            self.output.update(disp.HTML(self.html_code      )      )






  def    lowercase_	(							self		:	Any			,     __lowerCamelCase		:	List[Any]      )	->							Optional[int]:
       if self.inner_table is None:
            SCREAMING_SNAKE_CASE__					=					[list(values.keys()      ), list(values.values()      )]
       else:
            SCREAMING_SNAKE_CASE__					=					self.inner_table[0]
            if len(self.inner_table      ) == 1:
                 # We give a chance to update the column names at the first iteration
                 for key in values.keys():
                      if key not in columns:
                           columns.append(__lowerCamelCase      )
                 SCREAMING_SNAKE_CASE__					=					columns
            self.inner_table.append([values[c] for c in columns]      )






  def    lowercase_	(							self		:	Any			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Optional[Any]=None			,     __lowerCamelCase		:	Union[str, Any]=300      )	->							Optional[int]:
       SCREAMING_SNAKE_CASE__					=					NotebookProgressBar(__lowerCamelCase			,     prefix=__lowerCamelCase			,     parent=self			,     width=__lowerCamelCase      )
       return self.child_bar







  def    lowercase_	(							self		:	Any      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					None
       self.display()






class  UpperCAmelCase__	( A__ ):






  """simple docstring"""


  def __init__(							self		:	str      )	->							Optional[int]:
       SCREAMING_SNAKE_CASE__					=					None
       SCREAMING_SNAKE_CASE__					=					None
       SCREAMING_SNAKE_CASE__					=					False






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	int			,     **__lowerCamelCase		:	str      )	->							int:
       SCREAMING_SNAKE_CASE__					=					'''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
       SCREAMING_SNAKE_CASE__					=					0
       SCREAMING_SNAKE_CASE__					=					0
       SCREAMING_SNAKE_CASE__					=					[self.first_column] + ['''Training Loss''']
       if args.evaluation_strategy != IntervalStrategy.NO:
            column_names.append('''Validation Loss'''      )
       SCREAMING_SNAKE_CASE__					=					NotebookTrainingTracker(state.max_steps			,     __lowerCamelCase      )






  def    lowercase_	(							self		:	Dict			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Any			,     **__lowerCamelCase		:	str      )	->							int:
       SCREAMING_SNAKE_CASE__					=					int(state.epoch      ) if int(state.epoch      ) == state.epoch else f'''{state.epoch:.2f}'''
       self.training_tracker.update(
           state.global_step + 1			,     comment=f'''Epoch {epoch}/{state.num_train_epochs}'''			,     force_update=self._force_next_update			,     )
       SCREAMING_SNAKE_CASE__					=					False






  def    lowercase_	(							self		:	Tuple			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	str=None			,     **__lowerCamelCase		:	Tuple      )	->							Tuple:
       if not has_length(__lowerCamelCase      ):
            return
       if self.prediction_bar is None:
            if self.training_tracker is not None:
                 SCREAMING_SNAKE_CASE__					=					self.training_tracker.add_child(len(__lowerCamelCase      )      )
            else:
                 SCREAMING_SNAKE_CASE__					=					NotebookProgressBar(len(__lowerCamelCase      )      )
            self.prediction_bar.update(1      )
       else:
            self.prediction_bar.update(self.prediction_bar.value + 1      )






  def    lowercase_	(							self		:	Any			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	str			,     **__lowerCamelCase		:	Any      )	->							Dict:
       if self.prediction_bar is not None:
            self.prediction_bar.close()
       SCREAMING_SNAKE_CASE__					=					None






  def    lowercase_	(							self		:	List[str]			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	str=None			,     **__lowerCamelCase		:	Union[str, Any]      )	->							Any:
       # Only for when there is no evaluation
       if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
            SCREAMING_SNAKE_CASE__					=					{'''Training Loss''': logs['''loss''']}
            # First column is necessarily Step sine we're not in epoch eval strategy
            SCREAMING_SNAKE_CASE__					=					state.global_step
            self.training_tracker.write_line(__lowerCamelCase      )






  def    lowercase_	(							self		:	List[Any]			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	str=None			,     **__lowerCamelCase		:	Union[str, Any]      )	->							Any:
       if self.training_tracker is not None:
            SCREAMING_SNAKE_CASE__					=					{'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
            for log in reversed(state.log_history      ):
                 if "loss" in log:
                      SCREAMING_SNAKE_CASE__					=					log['''loss''']
                      break

            if self.first_column == "Epoch":
                 SCREAMING_SNAKE_CASE__					=					int(state.epoch      )
            else:
                 SCREAMING_SNAKE_CASE__					=					state.global_step
            SCREAMING_SNAKE_CASE__					=					'''eval'''
            for k in metrics:
                 if k.endswith('''_loss'''      ):
                      SCREAMING_SNAKE_CASE__					=					re.sub(r'''\_loss$'''			,     ''''''			,     __lowerCamelCase      )
            SCREAMING_SNAKE_CASE__					=					metrics.pop('''total_flos'''			,     __lowerCamelCase      )
            SCREAMING_SNAKE_CASE__					=					metrics.pop('''epoch'''			,     __lowerCamelCase      )
            SCREAMING_SNAKE_CASE__					=					metrics.pop(f'''{metric_key_prefix}_runtime'''			,     __lowerCamelCase      )
            SCREAMING_SNAKE_CASE__					=					metrics.pop(f'''{metric_key_prefix}_samples_per_second'''			,     __lowerCamelCase      )
            SCREAMING_SNAKE_CASE__					=					metrics.pop(f'''{metric_key_prefix}_steps_per_second'''			,     __lowerCamelCase      )
            SCREAMING_SNAKE_CASE__					=					metrics.pop(f'''{metric_key_prefix}_jit_compilation_time'''			,     __lowerCamelCase      )
            for k, v in metrics.items():
                 if k == f'''{metric_key_prefix}_loss''':
                      SCREAMING_SNAKE_CASE__					=					v
                 else:
                      SCREAMING_SNAKE_CASE__					=					k.split('''_'''      )
                      SCREAMING_SNAKE_CASE__					=					''' '''.join([part.capitalize() for part in splits[1:]]      )
                      SCREAMING_SNAKE_CASE__					=					v
            self.training_tracker.write_line(__lowerCamelCase      )
            self.training_tracker.remove_child()
            SCREAMING_SNAKE_CASE__					=					None
            # Evaluation takes a long time so we should force the next update.
            SCREAMING_SNAKE_CASE__					=					True







  def    lowercase_	(							self		:	Optional[Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	int			,     **__lowerCamelCase		:	Union[str, Any]      )	->							Union[str, Any]:
       self.training_tracker.update(
           state.global_step			,     comment=f'''Epoch {int(state.epoch      )}/{state.num_train_epochs}'''			,     force_update=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					None





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  UpperCAmelCase__	( A__		,  unittest.TestCase ):






  """simple docstring"""


  a     =      KandinskyImgaImgPipeline
  a     =      ["prompt", "image_embeds", "negative_image_embeds", "image"]
  a     =      [
      "prompt",
      "negative_prompt",
      "image_embeds",
      "negative_image_embeds",
      "image",
  ]
  a     =      [
      "generator",
      "height",
      "width",
      "strength",
      "guidance_scale",
      "negative_prompt",
      "num_inference_steps",
      "return_dict",
      "guidance_scale",
      "num_images_per_prompt",
      "output_type",
      "return_dict",
  ]
  a     =      False






  @property
  def    lowercase_	(							self		:	str      )	->							List[str]:
       return 32






  @property
  def    lowercase_	(							self		:	Optional[int]      )	->							int:
       return 32






  @property
  def    lowercase_	(							self		:	Union[str, Any]      )	->							int:
       return self.time_input_dim






  @property
  def    lowercase_	(							self		:	List[str]      )	->							int:
       return self.time_input_dim * 4






  @property
  def    lowercase_	(							self		:	Union[str, Any]      )	->							Any:
       return 100






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






  @property
  def    lowercase_	(							self		:	List[Any]      )	->							List[Any]:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					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			,     )

       SCREAMING_SNAKE_CASE__					=					MultilingualCLIP(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					text_encoder.eval()

       return text_encoder






  @property
  def    lowercase_	(							self		:	str      )	->							Dict:
       torch.manual_seed(0      )

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

       SCREAMING_SNAKE_CASE__					=					UNetaDConditionModel(**__lowerCamelCase      )
       return model






  @property
  def    lowercase_	(							self		:	Dict      )	->							Optional[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    lowercase_	(							self		:	Tuple      )	->							Optional[int]:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					VQModel(**self.dummy_movq_kwargs      )
       return model






  def    lowercase_	(							self		:	int      )	->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__					=					self.dummy_text_encoder
       SCREAMING_SNAKE_CASE__					=					self.dummy_tokenizer
       SCREAMING_SNAKE_CASE__					=					self.dummy_unet
       SCREAMING_SNAKE_CASE__					=					self.dummy_movq

       SCREAMING_SNAKE_CASE__					=					{
           '''num_train_timesteps''': 1000,
           '''beta_schedule''': '''linear''',
           '''beta_start''': 0.00085,
           '''beta_end''': 0.012,
           '''clip_sample''': False,
           '''set_alpha_to_one''': False,
           '''steps_offset''': 0,
           '''prediction_type''': '''epsilon''',
           '''thresholding''': False,
       }

       SCREAMING_SNAKE_CASE__					=					DDIMScheduler(**__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					{
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''movq''': movq,
       }

       return components






  def    lowercase_	(							self		:	List[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Union[str, Any]=0      )	->							str:
       SCREAMING_SNAKE_CASE__					=					floats_tensor((1, self.cross_attention_dim)			,     rng=random.Random(__lowerCamelCase      )      ).to(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					floats_tensor((1, self.cross_attention_dim)			,     rng=random.Random(seed + 1      )      ).to(__lowerCamelCase      )
       # create init_image
       SCREAMING_SNAKE_CASE__					=					floats_tensor((1, 3, 64, 64)			,     rng=random.Random(__lowerCamelCase      )      ).to(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					image.cpu().permute(0			,     2			,     3			,     1      )[0]
       SCREAMING_SNAKE_CASE__					=					Image.fromarray(np.uinta(__lowerCamelCase      )      ).convert('''RGB'''      ).resize((256, 256)      )

       if str(__lowerCamelCase      ).startswith('''mps'''      ):
            SCREAMING_SNAKE_CASE__					=					torch.manual_seed(__lowerCamelCase      )
       else:
            SCREAMING_SNAKE_CASE__					=					torch.Generator(device=__lowerCamelCase      ).manual_seed(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					{
           '''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    lowercase_	(							self		:	int      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''

       SCREAMING_SNAKE_CASE__					=					self.get_dummy_components()

       SCREAMING_SNAKE_CASE__					=					self.pipeline_class(**__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					pipe.to(__lowerCamelCase      )

       pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					pipe(**self.get_dummy_inputs(__lowerCamelCase      )      )
       SCREAMING_SNAKE_CASE__					=					output.images

       SCREAMING_SNAKE_CASE__					=					pipe(
           **self.get_dummy_inputs(__lowerCamelCase      )			,     return_dict=__lowerCamelCase			,     )[0]

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

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

       SCREAMING_SNAKE_CASE__					=					np.array(
           [0.61474943, 0.6073539, 0.43308544, 0.5928269, 0.47493595, 0.46755973, 0.4613838, 0.45368797, 0.50119233]      )
       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  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


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







  def    lowercase_	(							self		:	List[str]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/kandinsky/kandinsky_img2img_frog.npy'''      )

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

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

       SCREAMING_SNAKE_CASE__					=					KandinskyImgaImgPipeline.from_pretrained(
           '''kandinsky-community/kandinsky-2-1'''			,     torch_dtype=torch.floataa      )
       SCREAMING_SNAKE_CASE__					=					pipeline.to(__lowerCamelCase      )

       pipeline.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					torch.Generator(device='''cpu'''      ).manual_seed(0      )
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__					=					pipe_prior(
           __lowerCamelCase			,     generator=__lowerCamelCase			,     num_inference_steps=5			,     negative_prompt=''''''			,     ).to_tuple()

       SCREAMING_SNAKE_CASE__					=					pipeline(
           __lowerCamelCase			,     image=__lowerCamelCase			,     image_embeds=__lowerCamelCase			,     negative_image_embeds=__lowerCamelCase			,     generator=__lowerCamelCase			,     num_inference_steps=100			,     height=768			,     width=768			,     strength=0.2			,     output_type='''np'''			,     )

       SCREAMING_SNAKE_CASE__					=					output.images[0]

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

       assert_mean_pixel_difference(__lowerCamelCase			,     __lowerCamelCase      )


