code: 
  
  
  
  
  """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 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE = False							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Any								=				10
  
  					if only_cross_attention:
  							snake_case		:						Tuple								=				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 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Tuple								=				2
  
  					snake_case		:						Any								=				torch.rand(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, 3				, 2							)
  					snake_case		:						int								=				torch.rand(SCREAMING_SNAKE_CASE				, 4				, SCREAMING_SNAKE_CASE							)
  					snake_case		:						str								=				None
  
  					return {
  					    "hidden_states": hidden_states,
  					    "encoder_hidden_states": encoder_hidden_states,
  					    "attention_mask": attention_mask,
  					}
  
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					torch.manual_seed(0							)
  
  					snake_case		:						List[Any]								=				self.get_constructor_arguments(only_cross_attention=SCREAMING_SNAKE_CASE							)
  					snake_case		:						int								=				Attention(**SCREAMING_SNAKE_CASE							)
  
  					self.assertTrue(attn.to_k is not None							)
  					self.assertTrue(attn.to_v is not None							)
  
  					snake_case		:						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(**SCREAMING_SNAKE_CASE							)
  
  					# only self attention
  
  					torch.manual_seed(0							)
  
  					snake_case		:						Optional[Any]								=				self.get_constructor_arguments(only_cross_attention=SCREAMING_SNAKE_CASE							)
  					snake_case		:						int								=				Attention(**SCREAMING_SNAKE_CASE							)
  
  					self.assertTrue(attn.to_k is None							)
  					self.assertTrue(attn.to_v is None							)
  
  					snake_case		:						Union[str, Any]								=				self.get_forward_arguments(
  					    query_dim=constructor_args["query_dim"]				, added_kv_proj_dim=constructor_args["added_kv_proj_dim"]							)
  
  					snake_case		:						Any								=				attn(**SCREAMING_SNAKE_CASE							)
  
  					self.assertTrue((only_cross_attn_out != self_and_cross_attn_out).all()							)
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  unittest.TestCase			):
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				DiffusionPipeline.from_pretrained("hf-internal-testing/tiny-stable-diffusion-pipe"				, safety_checker=SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						List[str]								=				pipe(
  					    "foo"				, num_inference_steps=2				, generator=torch.Generator("cpu"							).manual_seed(0							)				, output_type="np"				, ).images
  
  					# the initial conversion succeeds
  					snake_case		:						Optional[Any]								=				DiffusionPipeline.from_pretrained(
  					    "hf-internal-testing/tiny-stable-diffusion-pipe"				, device_map="sequential"				, safety_checker=SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						Dict								=				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(SCREAMING_SNAKE_CASE							)
  
  							# can also load the converted weights
  							snake_case		:						Tuple								=				DiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE				, device_map="sequential"				, safety_checker=SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						List[Any]								=				pipe(
  					    "foo"				, num_inference_steps=2				, generator=torch.Generator("cpu"							).manual_seed(0							)				, output_type="np"				, ).images
  
  					self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, atol=1E-5							)							)
  					self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, atol=1E-5							)							)
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  def   UpperCamelCase__     (		lowercase__  :     int   ):
  		if not isinstance(lowercase__       ,     lowercase__   ):
  				snake_case		:						Optional[Any]								=				F'''Input value of [number={number}] must be an integer'''
  				raise TypeError(lowercase__   )
  		if number < 0 or number % 2 == 1:
  				return False
  		snake_case		:						str								=				int(number**0.5   )
  		return number == number_sqrt * (number_sqrt + 1)
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()
  
  