


"""simple docstring"""





def   _snake_case    (    _snake_case					:      Optional[Any]			, _snake_case					:      str			, _snake_case					:      str			, _snake_case					:      Any      ):
      return len_board * len_board_column * row + column


def   _snake_case    (    _snake_case					:      Union[str, Any]			, _snake_case					:      Optional[Any]			, _snake_case					:      List[str]			, _snake_case					:      int			, _snake_case					:      int			, _snake_case					:      List[str]			, ):

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

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

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

            lowerCAmelCase       :						Any							= get_point_key(lowercase__			, lowercase__			, lowercase__			, lowercase__      )
            if key in visited_points_set:
                  continue

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

            visited_points_set.remove(lowercase__      )

      return False


def   _snake_case    (    _snake_case					:      Union[str, Any]			, _snake_case					:      Optional[Any]      ):
      lowerCAmelCase       :						int							= (
          'The board should be a non empty matrix of single chars strings.'
      )

      lowerCAmelCase       :						Any							= len(lowercase__      )
      if not isinstance(lowercase__			, lowercase__      ) or len(lowercase__      ) == 0:
            raise ValueError(lowercase__      )

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

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

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

      lowerCAmelCase       :						Dict							= len(board[0]      )
      for i in range(lowercase__      ):
            for j in range(lowercase__      ):
                  if exits_word(
                      lowercase__			, lowercase__			, lowercase__			, lowercase__			, 0			, {get_point_key(lowercase__			, lowercase__			, lowercase__			, lowercase__      )}      ):
                        return True

      return False


if __name__ == "__main__":
 import doctest

 doctest.testmod()









'''simple docstring'''






import tempfile
import unittest

import numpy as np
import torch

from diffusers import DiffusionPipeline
from diffusers.models.attention_processor import Attention, AttnAddedKVProcessor







class       lowerCamelCase       (    unittest.TestCase	):


					def  SCREAMING_SNAKE_CASE_		(       self						:	List[Any]							,  __snake_case						:	bool = False							):





											'''simple docstring'''





											_snake_case: Any	       =		10

											if only_cross_attention:
																	_snake_case: Optional[int]	       =		12
											else:
																	# when only cross attention is not set, the cross attention dim must be the same as the query dim
																	_snake_case: Optional[int]	       =		query_dim

											return {
											    "query_dim": query_dim,
											    "cross_attention_dim": cross_attention_dim,
											    "heads": 2,
											    "dim_head": 4,
											    "added_kv_proj_dim": 6,
											    "norm_num_groups": 1,
											    "only_cross_attention": only_cross_attention,
											    "processor": AttnAddedKVProcessor(),
											}


					def  SCREAMING_SNAKE_CASE_		(       self						:	List[Any]							,  __snake_case						:	List[Any]							,  __snake_case						:	Tuple							):





											'''simple docstring'''





											_snake_case: Optional[int]	       =		2

											_snake_case: Union[str, Any]	       =		torch.rand(__snake_case							,  __snake_case							,  3							,  2							)
											_snake_case: Optional[int]	       =		torch.rand(__snake_case							,  4							,  __snake_case							)
											_snake_case: int	       =		None

											return {
											    "hidden_states": hidden_states,
											    "encoder_hidden_states": encoder_hidden_states,
											    "attention_mask": attention_mask,
											}




					def  SCREAMING_SNAKE_CASE_		(       self						:	List[Any]							):





											'''simple docstring'''





											torch.manual_seed(0							)

											_snake_case: int	       =		self.get_constructor_arguments(only_cross_attention=__snake_case							)
											_snake_case: Union[str, Any]	       =		Attention(**__snake_case							)

											self.assertTrue(attn.to_k is not None							)
											self.assertTrue(attn.to_v is not None							)

											_snake_case: Optional[int]	       =		self.get_forward_arguments(
											    query_dim=constructor_args['query_dim']							,  added_kv_proj_dim=constructor_args['added_kv_proj_dim']							)

											_snake_case: str	       =		attn(**__snake_case							)

											# only self attention

											torch.manual_seed(0							)

											_snake_case: str	       =		self.get_constructor_arguments(only_cross_attention=__snake_case							)
											_snake_case: Optional[Any]	       =		Attention(**__snake_case							)

											self.assertTrue(attn.to_k is None							)
											self.assertTrue(attn.to_v is None							)

											_snake_case: Dict	       =		self.get_forward_arguments(
											    query_dim=constructor_args['query_dim']							,  added_kv_proj_dim=constructor_args['added_kv_proj_dim']							)

											_snake_case: str	       =		attn(**__snake_case							)

											self.assertTrue((only_cross_attn_out != self_and_cross_attn_out).all()							)







class       lowerCamelCase       (    unittest.TestCase	):


					def  SCREAMING_SNAKE_CASE_		(       self						:	Tuple							):





											'''simple docstring'''





											_snake_case: str	       =		DiffusionPipeline.from_pretrained('hf-internal-testing/tiny-stable-diffusion-pipe'							,  safety_checker=__snake_case							)

											_snake_case: int	       =		pipe(
											    'foo'							,  num_inference_steps=2							,  generator=torch.Generator('cpu'							).manual_seed(0							)							,  output_type='np'							,  ).images

											# the initial conversion succeeds
											_snake_case: Dict	       =		DiffusionPipeline.from_pretrained(
											    'hf-internal-testing/tiny-stable-diffusion-pipe'							,  device_map='sequential'							,  safety_checker=__snake_case							)

											_snake_case: Any	       =		pipe(
											    'foo'							,  num_inference_steps=2							,  generator=torch.Generator('cpu'							).manual_seed(0							)							,  output_type='np'							,  ).images

											with tempfile.TemporaryDirectory() as tmpdir:
																	# save the converted model
																	pipe.save_pretrained(__snake_case							)

																	# can also load the converted weights
																	_snake_case: Union[str, Any]	       =		DiffusionPipeline.from_pretrained(__snake_case							,  device_map='sequential'							,  safety_checker=__snake_case							)

											_snake_case: Union[str, Any]	       =		pipe(
											    'foo'							,  num_inference_steps=2							,  generator=torch.Generator('cpu'							).manual_seed(0							)							,  output_type='np'							,  ).images

											self.assertTrue(np.allclose(__snake_case							,  __snake_case							,  atol=1e-5							)							)
											self.assertTrue(np.allclose(__snake_case							,  __snake_case							,  atol=1e-5							)							)





