



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()

UpperCAmelCase__			:   Optional[Any]      			=    logging.get_logger(__name__)


def 	_A	(   _UpperCamelCase      ,					_UpperCamelCase = True			):
				_UpperCAmelCase						:  Any     					=	{}
				for name in model.attn_processors.keys():
								_UpperCAmelCase						:  int     					=	name.endswith('''attn2.processor'''			) and not (
								    name.startswith('''transformer_in'''			) or '''temp_attentions''' in name.split('''.'''			)
								)
								_UpperCAmelCase						:  str     					=	model.config.cross_attention_dim if has_cross_attention else None
								if name.startswith('''mid_block'''			):
												_UpperCAmelCase						:  Any     					=	model.config.block_out_channels[-1]
								elif name.startswith('''up_blocks'''			):
												_UpperCAmelCase						:  List[str]     					=	int(name[len('''up_blocks.'''			)]			)
												_UpperCAmelCase						:  int     					=	list(reversed(model.config.block_out_channels			)			)[block_id]
								elif name.startswith('''down_blocks'''			):
												_UpperCAmelCase						:  List[str]     					=	int(name[len('''down_blocks.'''			)]			)
												_UpperCAmelCase						:  Optional[Any]     					=	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
												_UpperCAmelCase						:  Union[str, Any]     					=	8 * model.config.attention_head_dim

								_UpperCAmelCase						:  Optional[int]     					=	LoRAAttnProcessor(hidden_size=a__      ,					cross_attention_dim=a__			)
								_UpperCAmelCase						:  Tuple     					=	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 							lowerCAmelCase_		(		A__							,		A__							,		unittest.TestCase     ):
		SCREAMING_SNAKE_CASE_       :			Optional[int]					       =	UNetaDConditionModel
		SCREAMING_SNAKE_CASE_       :			int					       =	'''sample'''







		@property
		def 					a_  (    self  :   Any					)       ->		Dict:


						'''simple docstring'''







						_UpperCAmelCase						:  Tuple     					=	4
						_UpperCAmelCase						:  int     					=	4
						_UpperCAmelCase						:  Union[str, Any]     					=	4
						_UpperCAmelCase						:  Any     					=	(32, 32)

						_UpperCAmelCase						:  List[Any]     					=	floats_tensor((batch_size, num_channels, num_frames) + sizes					).to(UpperCAmelCase_					)
						_UpperCAmelCase						:  str     					=	torch.tensor([10]					).to(UpperCAmelCase_					)
						_UpperCAmelCase						:  List[Any]     					=	floats_tensor((batch_size, 4, 32)					).to(UpperCAmelCase_					)

						return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}







		@property
		def 					a_  (    self  :   int					)       ->		str:


						'''simple docstring'''







						return (4, 4, 32, 32)







		@property
		def 					a_  (    self  :   Optional[Any]					)       ->		int:


						'''simple docstring'''







						return (4, 4, 32, 32)







		def 					a_  (    self  :   List[str]					)       ->		Dict:


						'''simple docstring'''







						_UpperCAmelCase						:  List[Any]     					=	{
						    '''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,
						}
						_UpperCAmelCase						:  Tuple     					=	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  :   Optional[int]					)       ->		List[str]:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Dict     					=	self.prepare_init_args_and_inputs_for_common()
						_UpperCAmelCase						:  Optional[int]     					=	self.model_class(**UpperCAmelCase_					)

						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  :   Optional[int]					)       ->		Any:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Union[str, Any]     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  int     					=	32

						_UpperCAmelCase						:  Any     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)
						model.eval()

						with torch.no_grad():
										_UpperCAmelCase						:  Union[str, Any]     					=	model(**UpperCAmelCase_					)

										if isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					):
														_UpperCAmelCase						:  List[Any]     					=	output.sample

						self.assertIsNotNone(UpperCAmelCase_					)
						_UpperCAmelCase						:  Optional[int]     					=	inputs_dict['''sample'''].shape
						self.assertEqual(output.shape       ,		UpperCAmelCase_       ,		'''Input and output shapes do not match'''					)







		def 					a_  (    self  :   List[str]					)       ->		Union[str, Any]:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Optional[int]     					=	self.prepare_init_args_and_inputs_for_common()
						_UpperCAmelCase						:  Tuple     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)
						model.eval()

						with torch.no_grad():
										# Warmup pass when using mps (see #372)
										if torch_device == "mps" and isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					):
														model(**self.dummy_input					)

										_UpperCAmelCase						:  int     					=	model(**UpperCAmelCase_					)
										if isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					):
														_UpperCAmelCase						:  Optional[Any]     					=	first.sample

										_UpperCAmelCase						:  Tuple     					=	model(**UpperCAmelCase_					)
										if isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					):
														_UpperCAmelCase						:  str     					=	second.sample

						_UpperCAmelCase						:  Optional[Any]     					=	first.cpu().numpy()
						_UpperCAmelCase						:  Any     					=	second.cpu().numpy()
						_UpperCAmelCase						:  Any     					=	out_a[~np.isnan(UpperCAmelCase_					)]
						_UpperCAmelCase						:  Any     					=	out_a[~np.isnan(UpperCAmelCase_					)]
						_UpperCAmelCase						:  Any     					=	np.amax(np.abs(out_a - out_a					)					)
						self.assertLessEqual(UpperCAmelCase_       ,		1E-5					)







		def 					a_  (    self  :   List[Any]					)       ->		Any:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  str     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  int     					=	8

						_UpperCAmelCase						:  Optional[Any]     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)
						model.eval()

						model.set_attention_slice('''auto'''					)
						with torch.no_grad():
										_UpperCAmelCase						:  List[str]     					=	model(**UpperCAmelCase_					)
						assert output is not None

						model.set_attention_slice('''max'''					)
						with torch.no_grad():
										_UpperCAmelCase						:  str     					=	model(**UpperCAmelCase_					)
						assert output is not None

						model.set_attention_slice(2					)
						with torch.no_grad():
										_UpperCAmelCase						:  str     					=	model(**UpperCAmelCase_					)
						assert output is not None







		def 					a_  (    self  :   Dict					)       ->		str:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  str     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  Union[str, Any]     					=	8

						_UpperCAmelCase						:  Optional[Any]     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  Union[str, Any]     					=	model(**UpperCAmelCase_					).sample

						_UpperCAmelCase						:  str     					=	create_lora_layers(UpperCAmelCase_					)

						# make sure we can set a list of attention processors
						model.set_attn_processor(UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)

						# test that attn processors can be set to itself
						model.set_attn_processor(model.attn_processors					)

						with torch.no_grad():
										_UpperCAmelCase						:  List[str]     					=	model(**UpperCAmelCase_       ,		cross_attention_kwargs={'''scale''': 0.0}					).sample
										_UpperCAmelCase						:  str     					=	model(**UpperCAmelCase_       ,		cross_attention_kwargs={'''scale''': 0.5}					).sample
										_UpperCAmelCase						:  List[Any]     					=	model(**UpperCAmelCase_       ,		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  :   Any					)       ->		Dict:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Union[str, Any]     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  Optional[int]     					=	8

						torch.manual_seed(0					)
						_UpperCAmelCase						:  Tuple     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  Optional[Any]     					=	model(**UpperCAmelCase_					).sample

						_UpperCAmelCase						:  Tuple     					=	create_lora_layers(UpperCAmelCase_					)
						model.set_attn_processor(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  int     					=	model(**UpperCAmelCase_       ,		cross_attention_kwargs={'''scale''': 0.5}					).sample

						with tempfile.TemporaryDirectory() as tmpdirname:
										model.save_attn_procs(UpperCAmelCase_					)
										self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase_       ,		'''pytorch_lora_weights.bin'''					)					)					)
										torch.manual_seed(0					)
										_UpperCAmelCase						:  List[Any]     					=	self.model_class(**UpperCAmelCase_					)
										new_model.to(UpperCAmelCase_					)
										new_model.load_attn_procs(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  int     					=	new_model(**UpperCAmelCase_       ,		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  :   str					)       ->		int:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  str     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  Optional[int]     					=	8

						torch.manual_seed(0					)
						_UpperCAmelCase						:  List[Any]     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  List[Any]     					=	model(**UpperCAmelCase_					).sample

						_UpperCAmelCase						:  List[str]     					=	create_lora_layers(UpperCAmelCase_					)
						model.set_attn_processor(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  List[str]     					=	model(**UpperCAmelCase_       ,		cross_attention_kwargs={'''scale''': 0.5}					).sample

						with tempfile.TemporaryDirectory() as tmpdirname:
										model.save_attn_procs(UpperCAmelCase_       ,		safe_serialization=UpperCAmelCase_					)
										self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase_       ,		'''pytorch_lora_weights.safetensors'''					)					)					)
										torch.manual_seed(0					)
										_UpperCAmelCase						:  Tuple     					=	self.model_class(**UpperCAmelCase_					)
										new_model.to(UpperCAmelCase_					)
										new_model.load_attn_procs(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  List[Any]     					=	new_model(**UpperCAmelCase_       ,		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  :   Union[str, Any]					)       ->		Union[str, Any]:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Any     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  Optional[Any]     					=	8

						torch.manual_seed(0					)
						_UpperCAmelCase						:  Optional[Any]     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)

						_UpperCAmelCase						:  Dict     					=	create_lora_layers(UpperCAmelCase_       ,		mock_weights=UpperCAmelCase_					)
						model.set_attn_processor(UpperCAmelCase_					)
						# Saving as torch, properly reloads with directly filename
						with tempfile.TemporaryDirectory() as tmpdirname:
										model.save_attn_procs(UpperCAmelCase_					)
										self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase_       ,		'''pytorch_lora_weights.bin'''					)					)					)
										torch.manual_seed(0					)
										_UpperCAmelCase						:  str     					=	self.model_class(**UpperCAmelCase_					)
										new_model.to(UpperCAmelCase_					)
										new_model.load_attn_procs(UpperCAmelCase_       ,		weight_name='''pytorch_lora_weights.bin'''					)







		def 					a_  (    self  :   str					)       ->		Optional[int]:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Dict     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  str     					=	8

						torch.manual_seed(0					)
						_UpperCAmelCase						:  Tuple     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)

						_UpperCAmelCase						:  Tuple     					=	create_lora_layers(UpperCAmelCase_       ,		mock_weights=UpperCAmelCase_					)
						model.set_attn_processor(UpperCAmelCase_					)
						# Saving as torch, properly reloads with directly filename
						with tempfile.TemporaryDirectory() as tmpdirname:
										model.save_attn_procs(UpperCAmelCase_					)
										self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase_       ,		'''pytorch_lora_weights.bin'''					)					)					)
										torch.manual_seed(0					)
										_UpperCAmelCase						:  int     					=	self.model_class(**UpperCAmelCase_					)
										new_model.to(UpperCAmelCase_					)
										with self.assertRaises(UpperCAmelCase_					) as e:
														new_model.load_attn_procs(UpperCAmelCase_       ,		use_safetensors=UpperCAmelCase_					)
										self.assertIn('''Error no file named pytorch_lora_weights.safetensors'''       ,		str(e.exception					)					)







		def 					a_  (    self  :   List[Any]					)       ->		List[str]:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Optional[Any]     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  int     					=	8

						torch.manual_seed(0					)
						_UpperCAmelCase						:  str     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  int     					=	model(**UpperCAmelCase_					).sample

						_UpperCAmelCase						:  Dict     					=	create_lora_layers(UpperCAmelCase_					)
						model.set_attn_processor(UpperCAmelCase_					)

						with torch.no_grad():
										_UpperCAmelCase						:  Optional[Any]     					=	model(**UpperCAmelCase_       ,		cross_attention_kwargs={'''scale''': 0.0}					).sample

						model.set_attn_processor(AttnProcessor()					)

						with torch.no_grad():
										_UpperCAmelCase						:  Union[str, Any]     					=	model(**UpperCAmelCase_					).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  :   List[str]					)       ->		str:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  Union[str, Any]     					=	self.prepare_init_args_and_inputs_for_common()

						_UpperCAmelCase						:  Optional[int]     					=	4

						torch.manual_seed(0					)
						_UpperCAmelCase						:  List[Any]     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)
						_UpperCAmelCase						:  List[str]     					=	create_lora_layers(UpperCAmelCase_					)
						model.set_attn_processor(UpperCAmelCase_					)

						# default
						with torch.no_grad():
										_UpperCAmelCase						:  List[str]     					=	model(**UpperCAmelCase_					).sample

										model.enable_xformers_memory_efficient_attention()
										_UpperCAmelCase						:  List[Any]     					=	model(**UpperCAmelCase_					).sample

										model.disable_xformers_memory_efficient_attention()
										_UpperCAmelCase						:  List[Any]     					=	model(**UpperCAmelCase_					).sample

						assert (sample - on_sample).abs().max() < 1E-4
						assert (sample - off_sample).abs().max() < 1E-4







		def 					a_  (    self  :   Optional[Any]					)       ->		Dict:


						'''simple docstring'''







						_UpperCAmelCase					, _UpperCAmelCase						:  str     					=	self.prepare_init_args_and_inputs_for_common()
						_UpperCAmelCase						:  List[Any]     					=	32

						_UpperCAmelCase						:  List[str]     					=	self.model_class(**UpperCAmelCase_					)
						model.to(UpperCAmelCase_					)
						model.eval()

						with torch.no_grad():
										_UpperCAmelCase						:  Union[str, Any]     					=	model(**UpperCAmelCase_					)[0]

						model.enable_forward_chunking()
						with torch.no_grad():
										_UpperCAmelCase						:  Optional[int]     					=	model(**UpperCAmelCase_					)[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.


'''simple docstring'''







from collections import defaultdict







def   lowerCAmelCase(  a__    :  int = 5      ):







       '''simple docstring'''






       lowerCamelCase__				   =      defaultdict(a__      )
       lowerCamelCase__				   =      0

       while True:
              lowerCamelCase__				   =      get_digits(a__      )
              freqs[digits].append(a__      )

              if len(freqs[digits]      ) == max_base:
                     lowerCamelCase__				   =      freqs[digits][0] ** 3
                     return base

              num += 1







def   lowerCAmelCase(  a__    :  int      ):







       '''simple docstring'''






       return "".join(sorted(str(num**3      )      )      )


if __name__ == "__main__":
    print(f'{solution() = }')

