





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaImgaImgPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
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  lowerCAmelCase							(       lowercase_							,							unittest.TestCase ):
  __lowerCamelCase		=      KandinskyVaaImgaImgPipeline
  __lowerCamelCase		=      ['image_embeds', 'negative_image_embeds', 'image']
  __lowerCamelCase		=      [
      'image_embeds',
      'negative_image_embeds',
      'image',
  ]
  __lowerCamelCase		=      [
      'generator',
      'height',
      'width',
      'strength',
      'guidance_scale',
      'num_inference_steps',
      'return_dict',
      'guidance_scale',
      'num_images_per_prompt',
      'output_type',
      'return_dict',
  ]
  __lowerCamelCase		=      False







  @property
  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     return 32







  @property
  def   UpperCAmelCase					(      self  :Union[str, Any] ):






     '''simple docstring'''





     return 32







  @property
  def   UpperCAmelCase					(      self  :List[str] ):






     '''simple docstring'''





     return self.time_input_dim







  @property
  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     return self.time_input_dim * 4







  @property
  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





     return 1_00







  @property
  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     torch.manual_seed(0 )

     lowercase__			       =  {
         "in_channels": 4,
         # Out channels is double in channels because predicts mean and variance
         "out_channels": 8,
         "addition_embed_type": "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": "image_proj",
         "cross_attention_dim": self.cross_attention_dim,
         "attention_head_dim": 4,
         "resnet_time_scale_shift": "scale_shift",
         "class_embed_type": None,
     }

     lowercase__			       =  UNetaDConditionModel(**lowercase_ )
     return model







  @property
  def   UpperCAmelCase					(      self  :List[Any] ):






     '''simple docstring'''





     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  :List[str] ):






     '''simple docstring'''





     torch.manual_seed(0 )
     lowercase__			       =  VQModel(**self.dummy_movq_kwargs )
     return model







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     lowercase__			       =  self.dummy_unet
     lowercase__			       =  self.dummy_movq

     lowercase__			       =  {
         "num_train_timesteps": 10_00,
         "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,
     }

     lowercase__			       =  DDIMScheduler(**lowercase_ )

     lowercase__			       =  {
         "unet": unet,
         "scheduler": scheduler,
         "movq": movq,
     }

     return components







  def   UpperCAmelCase					(      self  :int   ,							_lowercase  :Dict   ,							_lowercase  :Optional[Any]=0 ):






     '''simple docstring'''





     lowercase__			       =  floats_tensor((1, self.text_embedder_hidden_size)   ,							rng=random.Random(lowercase_ ) ).to(lowercase_ )
     lowercase__			       =  floats_tensor((1, self.text_embedder_hidden_size)   ,							rng=random.Random(seed + 1 ) ).to(
         lowercase_ )
     # create init_image
     lowercase__			       =  floats_tensor((1, 3, 64, 64)   ,							rng=random.Random(lowercase_ ) ).to(lowercase_ )
     lowercase__			       =  image.cpu().permute(0   ,							2   ,							3   ,							1 )[0]
     lowercase__			       =  Image.fromarray(np.uinta(lowercase_ ) ).convert("RGB" ).resize((2_56, 2_56) )

     if str(lowercase_ ).startswith("mps" ):
        lowercase__			       =  torch.manual_seed(lowercase_ )
     else:
        lowercase__			       =  torch.Generator(device=lowercase_ ).manual_seed(lowercase_ )
     lowercase__			       =  {
         "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] ):






     '''simple docstring'''





     lowercase__			       =  "cpu"

     lowercase__			       =  self.get_dummy_components()

     lowercase__			       =  self.pipeline_class(**lowercase_ )
     lowercase__			       =  pipe.to(lowercase_ )

     pipe.set_progress_bar_config(disable=lowercase_ )

     lowercase__			       =  pipe(**self.get_dummy_inputs(lowercase_ ) )
     lowercase__			       =  output.images

     lowercase__			       =  pipe(
         **self.get_dummy_inputs(lowercase_ )   ,							return_dict=lowercase_   ,							)[0]

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

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

     lowercase__			       =  np.array(
         [0.6199778, 0.63984406, 0.46145785, 0.62944984, 0.5622215, 0.47306132, 0.47441456, 0.4607606, 0.48719263] )
     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 ):







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()







  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





     lowercase__			       =  load_numpy(
         "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
         "/kandinskyv22/kandinskyv22_img2img_frog.npy" )

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

     lowercase__			       =  KandinskyVaaPriorPipeline.from_pretrained(
         "kandinsky-community/kandinsky-2-2-prior"   ,							torch_dtype=torch.floataa )
     pipe_prior.to(lowercase_ )

     lowercase__			       =  KandinskyVaaImgaImgPipeline.from_pretrained(
         "kandinsky-community/kandinsky-2-2-decoder"   ,							torch_dtype=torch.floataa )
     lowercase__			       =  pipeline.to(lowercase_ )

     pipeline.set_progress_bar_config(disable=lowercase_ )

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

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

     lowercase__			       =  output.images[0]

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

     assert_mean_pixel_difference(lowercase_   ,							lowercase_ )













from __future__ import annotations

from collections import deque





class  lowerCAmelCase							:







  def __init__(      self  :List[Any]   ,							_lowercase  :list[str] ):






     '''simple docstring'''





     lowercase__			       =  []
     self.adlist.append(
         {"value": "", "next_states": [], "fail_state": 0, "output": []} )

     for keyword in keywords:
        self.add_keyword(_lowercase )
     self.set_fail_transitions()







  def   UpperCAmelCase					(      self  :str   ,							_lowercase  :int   ,							_lowercase  :str ):






     '''simple docstring'''





     for state in self.adlist[current_state]["next_states"]:
        if char == self.adlist[state]["value"]:
           return state
     return None







  def   UpperCAmelCase					(      self  :List[str]   ,							_lowercase  :str ):






     '''simple docstring'''





     lowercase__			       =  0
     for character in keyword:
        lowercase__			       =  self.find_next_state(_lowercase   ,							_lowercase )
        if next_state is None:
           self.adlist.append(
               {
                   "value": character,
                   "next_states": [],
                   "fail_state": 0,
                   "output": [],
               } )
           self.adlist[current_state]["next_states"].append(len(self.adlist ) - 1 )
           lowercase__			       =  len(self.adlist ) - 1
        else:
           lowercase__			       =  next_state
     self.adlist[current_state]["output"].append(_lowercase )







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     lowercase__			       =  deque()
     for node in self.adlist[0]["next_states"]:
        q.append(_lowercase )
        lowercase__			       =  0
     while q:
        lowercase__			       =  q.popleft()
        for child in self.adlist[r]["next_states"]:
           q.append(_lowercase )
           lowercase__			       =  self.adlist[r]["fail_state"]
           while (
               self.find_next_state(_lowercase   ,							self.adlist[child]["value"] ) is None
               and state != 0
           ):
              lowercase__			       =  self.adlist[state]["fail_state"]
           lowercase__			       =  self.find_next_state(
               _lowercase   ,							self.adlist[child]["value"] )
           if self.adlist[child]["fail_state"] is None:
              lowercase__			       =  0
           lowercase__			       =  (
               self.adlist[child]["output"]
               + self.adlist[self.adlist[child]["fail_state"]]["output"]
           )







  def   UpperCAmelCase					(      self  :Optional[Any]   ,							_lowercase  :str ):






     '''simple docstring'''





     lowercase__			       =  {}  # returns a dict with keywords and list of its occurrences
     lowercase__			       =  0
     for i in range(len(_lowercase ) ):
        while (
            self.find_next_state(_lowercase   ,							string[i] ) is None
            and current_state != 0
        ):
           lowercase__			       =  self.adlist[current_state]["fail_state"]
        lowercase__			       =  self.find_next_state(_lowercase   ,							string[i] )
        if next_state is None:
           lowercase__			       =  0
        else:
           lowercase__			       =  next_state
           for key in self.adlist[current_state]["output"]:
              if key not in result:
                 lowercase__			       =  []
              result[key].append(i - len(_lowercase ) + 1 )
     return result


if __name__ == "__main__":
  import doctest

  doctest.testmod()






