code: 
  '''simple docstring'''
  
  
  
  from __future__ import annotations
  
  import unittest
  from collections.abc import Iterator
  
  
  
  
  
  class 			A							:
  
  
  
  			def __init__(					self       ,     lowerCamelCase__       ,     lowerCamelCase__       )			->		int:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       label
  									lowercase__							 =       parent
  									lowercase__							 =       None
  									lowercase__							 =       None
  
  
  
  
  
  class 			A							:
  
  
  
  			def __init__(					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       None
  
  
  
  			def A__ (					self       )			->		Tuple:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       None
  
  
  
  			def A__ (					self       )			->		Tuple:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									return self.root is None
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       )			->		Tuple:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._put(self.root       ,     _lowerCamelCase       )
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       ,     lowerCamelCase__       ,     lowerCamelCase__ = None       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if node is None:
  															lowercase__							 =       Node(_lowerCamelCase       ,     _lowerCamelCase       )
  									else:
  															if label < node.label:
  																					lowercase__							 =       self._put(node.left       ,     _lowerCamelCase       ,     _lowerCamelCase       )
  															elif label > node.label:
  																					lowercase__							 =       self._put(node.right       ,     _lowerCamelCase       ,     _lowerCamelCase       )
  															else:
  																					lowercase__							 =       F'''Node with label {label} already exists'''
  																					raise Exception(_lowerCamelCase       )
  
  									return node
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       )			->		Optional[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									return self._search(self.root       ,     _lowerCamelCase       )
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       ,     lowerCamelCase__       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if node is None:
  															lowercase__							 =       F'''Node with label {label} does not exist'''
  															raise Exception(_lowerCamelCase       )
  									else:
  															if label < node.label:
  																					lowercase__							 =       self._search(node.left       ,     _lowerCamelCase       )
  															elif label > node.label:
  																					lowercase__							 =       self._search(node.right       ,     _lowerCamelCase       )
  
  									return node
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self.search(_lowerCamelCase       )
  									if node.right and node.left:
  															lowercase__							 =       self._get_lowest_node(node.right       )
  															lowercase__							 =       node.left
  															lowercase__							 =       node.right
  															lowercase__							 =       lowest_node
  															if node.right:
  																					lowercase__							 =       lowest_node
  															self._reassign_nodes(_lowerCamelCase       ,     _lowerCamelCase       )
  									elif not node.right and node.left:
  															self._reassign_nodes(_lowerCamelCase       ,     node.left       )
  									elif node.right and not node.left:
  															self._reassign_nodes(_lowerCamelCase       ,     node.right       )
  									else:
  															self._reassign_nodes(_lowerCamelCase       ,     _lowerCamelCase       )
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       ,     lowerCamelCase__       )			->		Optional[int]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if new_children:
  															lowercase__							 =       node.parent
  
  									if node.parent:
  															if node.parent.right == node:
  																					lowercase__							 =       new_children
  															else:
  																					lowercase__							 =       new_children
  									else:
  															lowercase__							 =       new_children
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       )			->		Optional[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if node.left:
  															lowercase__							 =       self._get_lowest_node(node.left       )
  									else:
  															lowercase__							 =       node
  															self._reassign_nodes(_lowerCamelCase       ,     node.right       )
  
  									return lowest_node
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       )			->		int:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									try:
  															self.search(_lowerCamelCase       )
  															return True
  									except Exception:
  															return False
  
  
  
  			def A__ (					self       )			->		Dict:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if self.root is None:
  															raise Exception("""Binary search tree is empty"""       )
  
  									lowercase__							 =       self.root
  									while node.right is not None:
  															lowercase__							 =       node.right
  
  									return node.label
  
  
  
  			def A__ (					self       )			->		List[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if self.root is None:
  															raise Exception("""Binary search tree is empty"""       )
  
  									lowercase__							 =       self.root
  									while node.left is not None:
  															lowercase__							 =       node.left
  
  									return node.label
  
  
  
  			def A__ (					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									return self._inorder_traversal(self.root       )
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       )			->		int:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if node is not None:
  															yield from self._inorder_traversal(node.left       )
  															yield node
  															yield from self._inorder_traversal(node.right       )
  
  
  
  			def A__ (					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									return self._preorder_traversal(self.root       )
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if node is not None:
  															yield node
  															yield from self._preorder_traversal(node.left       )
  															yield from self._preorder_traversal(node.right       )
  
  
  
  
  
  class 			A							(       unittest.TestCase				):
  
  
  
  			@staticmethod
  			def A__ (					)			->		Dict:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       BinarySearchTree()
  									t.put(8       )
  									t.put(3       )
  									t.put(6       )
  									t.put(1       )
  									t.put(10       )
  									t.put(14       )
  									t.put(13       )
  									t.put(4       )
  									t.put(7       )
  									t.put(5       )
  
  									return t
  
  
  
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       BinarySearchTree()
  									assert t.is_empty()
  
  									t.put(8       )
  									assert t.root is not None
  									assert t.root.parent is None
  									assert t.root.label == 8
  
  									t.put(10       )
  									assert t.root.right is not None
  									assert t.root.right.parent == t.root
  									assert t.root.right.label == 10
  
  									t.put(3       )
  									assert t.root.left is not None
  									assert t.root.left.parent == t.root
  									assert t.root.left.label == 3
  
  									t.put(6       )
  									assert t.root.left.right is not None
  									assert t.root.left.right.parent == t.root.left
  									assert t.root.left.right.label == 6
  
  									t.put(1       )
  									assert t.root.left.left is not None
  									assert t.root.left.left.parent == t.root.left
  									assert t.root.left.left.label == 1
  
  									with self.assertRaises(_lowerCamelCase       ):  # noqa: B017
  															t.put(1       )
  
  
  
  			def A__ (					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									lowercase__							 =       t.search(6       )
  									assert node.label == 6
  
  									lowercase__							 =       t.search(13       )
  									assert node.label == 13
  
  									with self.assertRaises(_lowerCamelCase       ):  # noqa: B017
  															t.search(2       )
  
  
  
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									t.remove(13       )
  									assert t.root is not None
  									assert t.root.right is not None
  									assert t.root.right.right is not None
  									assert t.root.right.right.right is None
  									assert t.root.right.right.left is None
  
  									t.remove(7       )
  									assert t.root.left is not None
  									assert t.root.left.right is not None
  									assert t.root.left.right.left is not None
  									assert t.root.left.right.right is None
  									assert t.root.left.right.left.label == 4
  
  									t.remove(6       )
  									assert t.root.left.left is not None
  									assert t.root.left.right.right is not None
  									assert t.root.left.left.label == 1
  									assert t.root.left.right.label == 4
  									assert t.root.left.right.right.label == 5
  									assert t.root.left.right.left is None
  									assert t.root.left.left.parent == t.root.left
  									assert t.root.left.right.parent == t.root.left
  
  									t.remove(3       )
  									assert t.root is not None
  									assert t.root.left.label == 4
  									assert t.root.left.right.label == 5
  									assert t.root.left.left.label == 1
  									assert t.root.left.parent == t.root
  									assert t.root.left.left.parent == t.root.left
  									assert t.root.left.right.parent == t.root.left
  
  									t.remove(4       )
  									assert t.root.left is not None
  									assert t.root.left.left is not None
  									assert t.root.left.label == 5
  									assert t.root.left.right is None
  									assert t.root.left.left.label == 1
  									assert t.root.left.parent == t.root
  									assert t.root.left.left.parent == t.root.left
  
  
  
  			def A__ (					self       )			->		str:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									t.remove(3       )
  									assert t.root is not None
  									assert t.root.left is not None
  									assert t.root.left.left is not None
  									assert t.root.left.right is not None
  									assert t.root.left.right.left is not None
  									assert t.root.left.right.right is not None
  									assert t.root.left.label == 4
  									assert t.root.left.right.label == 6
  									assert t.root.left.left.label == 1
  									assert t.root.left.right.right.label == 7
  									assert t.root.left.right.left.label == 5
  									assert t.root.left.parent == t.root
  									assert t.root.left.right.parent == t.root.left
  									assert t.root.left.left.parent == t.root.left
  									assert t.root.left.right.left.parent == t.root.left.right
  
  
  
  			def A__ (					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  									t.empty()
  									assert t.root is None
  
  
  
  			def A__ (					self       )			->		int:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  									assert not t.is_empty()
  
  									t.empty()
  									assert t.is_empty()
  
  
  
  			def A__ (					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									assert t.exists(6       )
  									assert not t.exists(-1       )
  
  
  
  			def A__ (					self       )			->		Optional[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									assert t.get_max_label() == 14
  
  									t.empty()
  									with self.assertRaises(_lowerCamelCase       ):  # noqa: B017
  															t.get_max_label()
  
  
  
  			def A__ (					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									assert t.get_min_label() == 1
  
  									t.empty()
  									with self.assertRaises(_lowerCamelCase       ):  # noqa: B017
  															t.get_min_label()
  
  
  
  			def A__ (					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									lowercase__							 =       [i.label for i in t.inorder_traversal()]
  									assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]
  
  
  
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       self._get_binary_search_tree()
  
  									lowercase__							 =       [i.label for i in t.preorder_traversal()]
  									assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]
  
  
  
  
  
  def  _A		(							):
  						lowercase__							 =       BinarySearchTree()
  						t.put(8	)
  						t.put(3	)
  						t.put(6	)
  						t.put(1	)
  						t.put(10	)
  						t.put(14	)
  						t.put(13	)
  						t.put(4	)
  						t.put(7	)
  						t.put(5	)
  
  						print(
  						    """
              8
             / \\
            3   10
           / \\    \\
          1   6    14
             / \\   /
            4   7 13
             \\
              5
          """	)
  
  						print("""Label 6 exists:"""		,		t.exists(6	)	)
  						print("""Label 13 exists:"""		,		t.exists(13	)	)
  						print("""Label -1 exists:"""		,		t.exists(-1	)	)
  						print("""Label 12 exists:"""		,		t.exists(12	)	)
  
  						# Prints all the elements of the list in inorder traversal
  						lowercase__							 =       [i.label for i in t.inorder_traversal()]
  						print("""Inorder traversal:"""		,		lowercase__	)
  
  						# Prints all the elements of the list in preorder traversal
  						lowercase__							 =       [i.label for i in t.preorder_traversal()]
  						print("""Preorder traversal:"""		,		lowercase__	)
  
  						print("""Max. label:"""		,		t.get_max_label()	)
  						print("""Min. label:"""		,		t.get_min_label()	)
  
  						# Delete elements
  						print("""\nDeleting elements 13, 10, 8, 3, 6, 14"""	)
  						print(
  						    """
            4
           / \\
          1   7
               \\
                5
          """	)
  						t.remove(13	)
  						t.remove(10	)
  						t.remove(8	)
  						t.remove(3	)
  						t.remove(6	)
  						t.remove(14	)
  
  						# Prints all the elements of the list in inorder traversal after delete
  						lowercase__							 =       [i.label for i in t.inorder_traversal()]
  						print("""Inorder traversal after delete:"""		,		lowercase__	)
  
  						# Prints all the elements of the list in preorder traversal after delete
  						lowercase__							 =       [i.label for i in t.preorder_traversal()]
  						print("""Preorder traversal after delete:"""		,		lowercase__	)
  
  						print("""Max. label:"""		,		t.get_max_label()	)
  						print("""Min. label:"""		,		t.get_min_label()	)
  
  
  if __name__ == "__main__":
  				binary_search_tree_example()
  
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  
  
  import os
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  
  from diffusers.models import ModelMixin, UNetaDConditionModel
  from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
  from diffusers.utils import (
      floats_tensor,
      logging,
      skip_mps,
      torch_device,
  )
  from diffusers.utils.import_utils import is_xformers_available
  from diffusers.utils.testing_utils import enable_full_determinism
  
  from .test_modeling_common import ModelTesterMixin, UNetTesterMixin
  
  
  enable_full_determinism()
  
  __A          =    logging.get_logger(__name__)
  
  
  
  
  
  def  _A		(							lowercase__		,		lowercase__ = True	):
  						lowercase__							 =       {}
  						for name in model.attn_processors.keys():
  												lowercase__							 =       name.endswith("""attn2.processor"""	) and not (
  												    name.startswith("""transformer_in"""	) or """temp_attentions""" in name.split("""."""	)
  												)
  												lowercase__							 =       model.config.cross_attention_dim if has_cross_attention else None
  												if name.startswith("""mid_block"""	):
  																		lowercase__							 =       model.config.block_out_channels[-1]
  												elif name.startswith("""up_blocks"""	):
  																		lowercase__							 =       int(name[len("""up_blocks."""	)]	)
  																		lowercase__							 =       list(reversed(model.config.block_out_channels	)	)[block_id]
  												elif name.startswith("""down_blocks"""	):
  																		lowercase__							 =       int(name[len("""down_blocks."""	)]	)
  																		lowercase__							 =       model.config.block_out_channels[block_id]
  												elif name.startswith("""transformer_in"""	):
  																		# Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
  																		lowercase__							 =       8 * model.config.attention_head_dim
  
  												lowercase__							 =       LoRAAttnProcessor(hidden_size=lowercase__		,		cross_attention_dim=lowercase__	)
  												lowercase__							 =       lora_attn_procs[name].to(model.device	)
  
  												if mock_weights:
  																		# add 1 to weights to mock trained weights
  																		with torch.no_grad():
  																								lora_attn_procs[name].to_q_lora.up.weight += 1
  																								lora_attn_procs[name].to_k_lora.up.weight += 1
  																								lora_attn_procs[name].to_v_lora.up.weight += 1
  																								lora_attn_procs[name].to_out_lora.up.weight += 1
  
  						return lora_attn_procs
  
  
  
  
  
  
  
  @skip_mps
  class 			A							(       __UpperCAmelCase		,						__UpperCAmelCase		,						unittest.TestCase				):
  			lowerCamelCase							:							List[Any]       		=  UNetaDConditionModel
  			lowerCamelCase							:							int       		=  """sample"""
  
  
  
  			@property
  			def A__ (					self       )			->		Optional[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       4
  									lowercase__							 =       4
  									lowercase__							 =       4
  									lowercase__							 =       (32, 32)
  
  									lowercase__							 =       floats_tensor((batch_size, num_channels, num_frames) + sizes       ).to(lowerCamelCase__       )
  									lowercase__							 =       torch.tensor([10]       ).to(lowerCamelCase__       )
  									lowercase__							 =       floats_tensor((batch_size, 4, 32)       ).to(lowerCamelCase__       )
  
  									return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}
  
  
  
  			@property
  			def A__ (					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									return (4, 4, 32, 32)
  
  
  
  			@property
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									return (4, 4, 32, 32)
  
  
  
  			def A__ (					self       )			->		Optional[int]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       {
  									    """block_out_channels""": (32, 64),
  									    """down_block_types""": (
  									        """CrossAttnDownBlock3D""",
  									        """DownBlock3D""",
  									    ),
  									    """up_block_types""": ("""UpBlock3D""", """CrossAttnUpBlock3D"""),
  									    """cross_attention_dim""": 32,
  									    """attention_head_dim""": 8,
  									    """out_channels""": 4,
  									    """in_channels""": 4,
  									    """layers_per_block""": 1,
  									    """sample_size""": 32,
  									}
  									lowercase__							 =       self.dummy_input
  									return init_dict, inputs_dict
  
  
  
  			@unittest.skipIf(
  			    torch_device != """cuda""" or not is_xformers_available()       ,     reason="""XFormers attention is only available with CUDA and `xformers` installed"""       ,     )
  			def A__ (					self       )			->		str:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  
  									model.enable_xformers_memory_efficient_attention()
  
  									assert (
  									    model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
  									    == "XFormersAttnProcessor"
  									), "xformers is not enabled"
  
  
  
  			def A__ (					self       )			->		Dict:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       32
  
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  									model.eval()
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       )
  
  															if isinstance(lowerCamelCase__       ,     lowerCamelCase__       ):
  																					lowercase__							 =       output.sample
  
  									self.assertIsNotNone(lowerCamelCase__       )
  									lowercase__							 =       inputs_dict["""sample"""].shape
  									self.assertEqual(output.shape       ,     lowerCamelCase__       ,     """Input and output shapes do not match"""       )
  
  
  
  			def A__ (					self       )			->		List[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  									model.eval()
  
  									with torch.no_grad():
  															# Warmup pass when using mps (see #372)
  															if torch_device == "mps" and isinstance(lowerCamelCase__       ,     lowerCamelCase__       ):
  																					model(**self.dummy_input       )
  
  															lowercase__							 =       model(**lowerCamelCase__       )
  															if isinstance(lowerCamelCase__       ,     lowerCamelCase__       ):
  																					lowercase__							 =       first.sample
  
  															lowercase__							 =       model(**lowerCamelCase__       )
  															if isinstance(lowerCamelCase__       ,     lowerCamelCase__       ):
  																					lowercase__							 =       second.sample
  
  									lowercase__							 =       first.cpu().numpy()
  									lowercase__							 =       second.cpu().numpy()
  									lowercase__							 =       out_a[~np.isnan(lowerCamelCase__       )]
  									lowercase__							 =       out_a[~np.isnan(lowerCamelCase__       )]
  									lowercase__							 =       np.amax(np.abs(out_a - out_a       )       )
  									self.assertLessEqual(lowerCamelCase__       ,     1e-5       )
  
  
  
  			def A__ (					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       8
  
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  									model.eval()
  
  									model.set_attention_slice("""auto"""       )
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       )
  									assert output is not None
  
  									model.set_attention_slice("""max"""       )
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       )
  									assert output is not None
  
  									model.set_attention_slice(2       )
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       )
  									assert output is not None
  
  
  
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       8
  
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  									lowercase__							 =       create_lora_layers(lowerCamelCase__       )
  
  									# make sure we can set a list of attention processors
  									model.set_attn_processor(lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  
  									# test that attn processors can be set to itself
  									model.set_attn_processor(model.attn_processors       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.0}       ).sample
  															lowercase__							 =       model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.5}       ).sample
  															lowercase__							 =       model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.5}       ).sample
  
  									assert (samplea - samplea).abs().max() < 3e-3
  									assert (samplea - samplea).abs().max() < 3e-3
  
  									# sample 2 and sample 3 should be different
  									assert (samplea - samplea).abs().max() > 3e-3
  
  
  
  			def A__ (					self       )			->		Optional[int]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       8
  
  									torch.manual_seed(0       )
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  									lowercase__							 =       create_lora_layers(lowerCamelCase__       )
  									model.set_attn_processor(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.5}       ).sample
  
  									with tempfile.TemporaryDirectory() as tmpdirname:
  															model.save_attn_procs(lowerCamelCase__       )
  															self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__       ,     """pytorch_lora_weights.bin"""       )       )       )
  															torch.manual_seed(0       )
  															lowercase__							 =       self.model_class(**lowerCamelCase__       )
  															new_model.to(lowerCamelCase__       )
  															new_model.load_attn_procs(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       new_model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.5}       ).sample
  
  									assert (sample - new_sample).abs().max() < 1e-3
  
  									# LoRA and no LoRA should NOT be the same
  									assert (sample - old_sample).abs().max() > 1e-4
  
  
  
  			def A__ (					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       8
  
  									torch.manual_seed(0       )
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  									lowercase__							 =       create_lora_layers(lowerCamelCase__       )
  									model.set_attn_processor(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.5}       ).sample
  
  									with tempfile.TemporaryDirectory() as tmpdirname:
  															model.save_attn_procs(lowerCamelCase__       ,     safe_serialization=lowerCamelCase__       )
  															self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__       ,     """pytorch_lora_weights.safetensors"""       )       )       )
  															torch.manual_seed(0       )
  															lowercase__							 =       self.model_class(**lowerCamelCase__       )
  															new_model.to(lowerCamelCase__       )
  															new_model.load_attn_procs(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       new_model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.5}       ).sample
  
  									assert (sample - new_sample).abs().max() < 3e-3
  
  									# LoRA and no LoRA should NOT be the same
  									assert (sample - old_sample).abs().max() > 1e-4
  
  
  
  			def A__ (					self       )			->		Dict:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       8
  
  									torch.manual_seed(0       )
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  
  									lowercase__							 =       create_lora_layers(lowerCamelCase__       ,     mock_weights=lowerCamelCase__       )
  									model.set_attn_processor(lowerCamelCase__       )
  									# Saving as torch, properly reloads with directly filename
  									with tempfile.TemporaryDirectory() as tmpdirname:
  															model.save_attn_procs(lowerCamelCase__       )
  															self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__       ,     """pytorch_lora_weights.bin"""       )       )       )
  															torch.manual_seed(0       )
  															lowercase__							 =       self.model_class(**lowerCamelCase__       )
  															new_model.to(lowerCamelCase__       )
  															new_model.load_attn_procs(lowerCamelCase__       ,     weight_name="""pytorch_lora_weights.bin"""       )
  
  
  
  			def A__ (					self       )			->		List[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       8
  
  									torch.manual_seed(0       )
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  
  									lowercase__							 =       create_lora_layers(lowerCamelCase__       ,     mock_weights=lowerCamelCase__       )
  									model.set_attn_processor(lowerCamelCase__       )
  									# Saving as torch, properly reloads with directly filename
  									with tempfile.TemporaryDirectory() as tmpdirname:
  															model.save_attn_procs(lowerCamelCase__       )
  															self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__       ,     """pytorch_lora_weights.bin"""       )       )       )
  															torch.manual_seed(0       )
  															lowercase__							 =       self.model_class(**lowerCamelCase__       )
  															new_model.to(lowerCamelCase__       )
  															with self.assertRaises(lowerCamelCase__       ) as e:
  																					new_model.load_attn_procs(lowerCamelCase__       ,     use_safetensors=lowerCamelCase__       )
  															self.assertIn("""Error no file named pytorch_lora_weights.safetensors"""       ,     str(e.exception       )       )
  
  
  
  			def A__ (					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       8
  
  									torch.manual_seed(0       )
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  									lowercase__							 =       create_lora_layers(lowerCamelCase__       )
  									model.set_attn_processor(lowerCamelCase__       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ,     cross_attention_kwargs={"""scale""": 0.0}       ).sample
  
  									model.set_attn_processor(AttnProcessor()       )
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  									assert (sample - new_sample).abs().max() < 1e-4
  									assert (sample - old_sample).abs().max() < 3e-3
  
  
  
  			@unittest.skipIf(
  			    torch_device != """cuda""" or not is_xformers_available()       ,     reason="""XFormers attention is only available with CUDA and `xformers` installed"""       ,     )
  			def A__ (					self       )			->		Optional[int]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  
  									lowercase__							 =       4
  
  									torch.manual_seed(0       )
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  									lowercase__							 =       create_lora_layers(lowerCamelCase__       )
  									model.set_attn_processor(lowerCamelCase__       )
  
  									# default
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  															model.enable_xformers_memory_efficient_attention()
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  															model.disable_xformers_memory_efficient_attention()
  															lowercase__							 =       model(**lowerCamelCase__       ).sample
  
  									assert (sample - on_sample).abs().max() < 1e-4
  									assert (sample - off_sample).abs().max() < 1e-4
  
  
  
  			def A__ (					self       )			->		List[Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__ ,						lowercase__							 =       self.prepare_init_args_and_inputs_for_common()
  									lowercase__							 =       32
  
  									lowercase__							 =       self.model_class(**lowerCamelCase__       )
  									model.to(lowerCamelCase__       )
  									model.eval()
  
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       )[0]
  
  									model.enable_forward_chunking()
  									with torch.no_grad():
  															lowercase__							 =       model(**lowerCamelCase__       )[0]
  
  									self.assertEqual(output.shape       ,     output_a.shape       ,     """Shape doesn't match"""       )
  									assert np.abs(output.cpu() - output_a.cpu()       ).max() < 1e-2
  
  
  # (todo: sayakpaul) implement SLOW tests.
  
  
  
  
  
  
  