

def  _snake_case		(snake_case_					:     int    ,       snake_case_					:     int    ,       snake_case_					:     int    ,       snake_case_					:     int  )							->		int:
  return len_board * len_board_column * row + column





def  _snake_case		(snake_case_					:     list[list[str]]    ,       snake_case_					:     str    ,       snake_case_					:     int    ,       snake_case_					:     int    ,       snake_case_					:     int    ,       snake_case_					:     set[int]    ,       )							->		bool:

  if board[row][column] != word[word_index]:
    return False

  if word_index == len(snake_case_  ) - 1:
    return True

  __UpperCAmelCase	:  Optional[Any]		=     [(0, 1), (0, -1), (-1, 0), (1, 0)]
  __UpperCAmelCase	:  Optional[Any]		=     len(snake_case_  )
  __UpperCAmelCase	:  Tuple		=     len(board[0]  )
  for direction in traverts_directions:
    __UpperCAmelCase	:  str		=     row + direction[0]
    __UpperCAmelCase	:  List[Any]		=     column + direction[1]
    if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
      continue

    __UpperCAmelCase	:  Optional[int]		=     get_point_key(snake_case_    ,       snake_case_    ,       snake_case_    ,       snake_case_  )
    if key in visited_points_set:
      continue

    visited_points_set.add(snake_case_  )
    if exits_word(snake_case_    ,       snake_case_    ,       snake_case_    ,       snake_case_    ,       word_index + 1    ,       snake_case_  ):
      return True

    visited_points_set.remove(snake_case_  )

  return False





def  _snake_case		(snake_case_					:     list[list[str]]    ,       snake_case_					:     str  )							->		bool:
  __UpperCAmelCase	:  int		=     (
      'The board should be a non empty matrix of single chars strings.'
  )

  __UpperCAmelCase	:  Union[str, Any]		=     len(snake_case_  )
  if not isinstance(snake_case_    ,       snake_case_  ) or len(snake_case_  ) == 0:
    raise ValueError(snake_case_  )

  for row in board:
    if not isinstance(snake_case_    ,       snake_case_  ) or len(snake_case_  ) == 0:
      raise ValueError(snake_case_  )

    for item in row:
      if not isinstance(snake_case_    ,       snake_case_  ) or len(snake_case_  ) != 1:
        raise ValueError(snake_case_  )

    # Validate word
  if not isinstance(snake_case_    ,       snake_case_  ) or len(snake_case_  ) == 0:
    raise ValueError(
        'The word parameter should be a string of length greater than 0.'  )

  __UpperCAmelCase	:  Any		=     len(board[0]  )
  for i in range(snake_case_  ):
    for j in range(snake_case_  ):
      if exits_word(
          snake_case_    ,       snake_case_    ,       snake_case_    ,       snake_case_    ,       0    ,       {get_point_key(snake_case_    ,       snake_case_    ,       snake_case_    ,       snake_case_  )}  ):
        return True

  return False


if __name__ == "__main__":
      import doctest

      doctest.testmod()






'''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 				lowercase    (    __lowerCamelCase			,					unittest.TestCase			):
   lowerCamelCase_            =KandinskyPipeline
   lowerCamelCase_            =[
       'prompt',
       'image_embeds',
       'negative_image_embeds',
   ]
   lowerCamelCase_            =['prompt', 'negative_prompt', 'image_embeds', 'negative_image_embeds']
   lowerCamelCase_            =[
       'generator',
       'height',
       'width',
       'latents',
       'guidance_scale',
       'negative_prompt',
       'num_inference_steps',
       'return_dict',
       'guidance_scale',
       'num_images_per_prompt',
       'output_type',
       'return_dict',
   ]
   lowerCamelCase_            =False


   @property
   def __UpperCAmelCase							( self					:						Optional[int])   ->       Union[str, Any]:
         return 32


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


   @property
   def __UpperCAmelCase							( self					:						Optional[Any])   ->       Any:
         return self.time_input_dim


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


   @property
   def __UpperCAmelCase							( self					:						List[str])   ->       str:
         return 100


   @property
   def __UpperCAmelCase							( self					:						Tuple)   ->       List[str]:
         lowercase_     			=   XLMRobertaTokenizerFast.from_pretrained("YiYiXu/tiny-random-mclip-base")
         return tokenizer


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

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

         return text_encoder


   @property
   def __UpperCAmelCase							( self					:						Tuple)   ->       Any:
         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": "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,
         }

         lowercase_     			=   UNetaDConditionModel(**__lowerCAmelCase)
         return model


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


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

         lowercase_     			=   DDIMScheduler(
             num_train_timesteps=1000 ,		beta_schedule="linear" ,		beta_start=0.0_0085 ,		beta_end=0.012 ,		clip_sample=__lowerCAmelCase ,		set_alpha_to_one=__lowerCAmelCase ,		steps_offset=1 ,		prediction_type="epsilon" ,		thresholding=__lowerCAmelCase ,		)

         lowercase_     			=   {
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "unet": unet,
             "scheduler": scheduler,
             "movq": movq,
         }
         return components


   def __UpperCAmelCase							( self					:						Union[str, Any] ,		__lowerCAmelCase					:						Optional[Any] ,		__lowerCAmelCase					:						List[str]=0)   ->       List[Any]:
         lowercase_     			=   floats_tensor((1, self.cross_attention_dim) ,		rng=random.Random(__lowerCAmelCase)).to(__lowerCAmelCase)
         lowercase_     			=   floats_tensor((1, self.cross_attention_dim) ,		rng=random.Random(seed + 1)).to(__lowerCAmelCase)
         if str(__lowerCAmelCase).startswith("mps"):
               lowercase_     			=   torch.manual_seed(__lowerCAmelCase)
         else:
               lowercase_     			=   torch.Generator(device=__lowerCAmelCase).manual_seed(__lowerCAmelCase)
         lowercase_     			=   {
             "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					:						Any)   ->       Optional[int]:
         lowercase_     			=   "cpu"

         lowercase_     			=   self.get_dummy_components()

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

         pipe.set_progress_bar_config(disable=__lowerCAmelCase)

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

         lowercase_     			=   pipe(
             **self.get_dummy_inputs(__lowerCAmelCase) ,		return_dict=__lowerCAmelCase ,		)[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.32_8663, 1.0, 0.2321_6873, 1.0, 0.9271_7564, 0.463_9046, 0.9689_4777, 0.3171_3378, 0.629_3953])

         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 				lowercase    (    unittest.TestCase			):


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


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

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

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

         lowercase_     			=   "red cat, 4k photo"

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

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

         lowercase_     			=   output.images[0]

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

         assert_mean_pixel_difference(__lowerCAmelCase ,		__lowerCAmelCase)






