

"""simple docstring"""





import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		Optional[int]						       =			{}
	for name in unet.attn_processors.keys():
		lowerCAmelCase__			:		int						       =			None if name.endswith('''attn1.processor'''				) else unet.config.cross_attention_dim
		if name.startswith('''mid_block'''				):
			lowerCAmelCase__			:		List[str]						       =			unet.config.block_out_channels[-1]
		elif name.startswith('''up_blocks'''				):
			lowerCAmelCase__			:		Union[str, Any]						       =			int(name[len('''up_blocks.'''				)]				)
			lowerCAmelCase__			:		List[str]						       =			list(reversed(unet.config.block_out_channels				)				)[block_id]
		elif name.startswith('''down_blocks'''				):
			lowerCAmelCase__			:		Tuple						       =			int(name[len('''down_blocks.'''				)]				)
			lowerCAmelCase__			:		Any						       =			unet.config.block_out_channels[block_id]
		lowerCAmelCase__			:		Optional[int]						       =			(
		    LoRAAttnProcessor2_0 if hasattr(A_		,  '''scaled_dot_product_attention'''				) else LoRAAttnProcessor
		)
		lowerCAmelCase__			:		List[str]						       =			lora_attn_processor_class(
		    hidden_size=A_		,  cross_attention_dim=A_				)
	lowerCAmelCase__			:		Optional[Any]						       =			AttnProcsLayers(A_				)
	return lora_attn_procs, unet_lora_layers

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		Optional[Any]						       =			{}
	lowerCAmelCase__			:		Optional[Any]						       =			(
	    LoRAAttnProcessor2_0 if hasattr(A_		,  '''scaled_dot_product_attention'''				) else LoRAAttnProcessor
	)
	for name, module in text_encoder.named_modules():
		if name.endswith(A_				):
			lowerCAmelCase__			:		Optional[Any]						       =			lora_attn_processor_class(
			    hidden_size=module.out_proj.out_features		,  cross_attention_dim=A_				)
	return text_lora_attn_procs

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		List[Any]						       =			create_text_encoder_lora_attn_procs(A_				)
	lowerCAmelCase__			:		Tuple						       =			AttnProcsLayers(A_				)
	return text_encoder_lora_layers

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_=False				):







	for _, attn_proc in text_lora_attn_procs.items():
		# set up.weights
		for layer_name, layer_module in attn_proc.named_modules():
			if layer_name.endswith('''_lora'''				):
				lowerCAmelCase__			:		Tuple						       =			(
				    torch.randn_like(layer_module.up.weight				)
				    if randn_weight
				    else torch.zeros_like(layer_module.up.weight				)
				)
				lowerCAmelCase__			:		List[Any]						       =			torch.nn.Parameter(A_				)







class        SCREAMING_SNAKE_CASE      (	unittest.TestCase ):






					"""simple docstring"""



					def  __lowerCAmelCase				( self    :       Optional[int]	):
						torch.manual_seed(0	)
						lowerCAmelCase__			:		Any						       =			UNetaDConditionModel(
						    block_out_channels=(3_2, 6_4)     ,layers_per_block=2     ,sample_size=3_2     ,in_channels=4     ,out_channels=4     ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,cross_attention_dim=3_2     ,)
						lowerCAmelCase__			:		List[str]						       =			DDIMScheduler(
						    beta_start=0.0_0085     ,beta_end=0.012     ,beta_schedule='''scaled_linear'''     ,clip_sample=UpperCamelCase__     ,set_alpha_to_one=UpperCamelCase__     ,steps_offset=1     ,)
						torch.manual_seed(0	)
						lowerCAmelCase__			:		int						       =			AutoencoderKL(
						    block_out_channels=[3_2, 6_4]     ,in_channels=3     ,out_channels=3     ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,latent_channels=4     ,)
						lowerCAmelCase__			:		str						       =			CLIPTextConfig(
						    bos_token_id=0     ,eos_token_id=2     ,hidden_size=3_2     ,intermediate_size=3_7     ,layer_norm_eps=1E-05     ,num_attention_heads=4     ,num_hidden_layers=5     ,pad_token_id=1     ,vocab_size=1_0_0_0     ,)
						lowerCAmelCase__			:		Any						       =			CLIPTextModel(UpperCamelCase__	)
						lowerCAmelCase__			:		Union[str, Any]						       =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

						lowerCAmelCase__       ,lowerCAmelCase__			:		Any						       =			create_unet_lora_layers(UpperCamelCase__	)
						lowerCAmelCase__			:		Union[str, Any]						       =			create_text_encoder_lora_layers(UpperCamelCase__	)

						lowerCAmelCase__			:		int						       =			{
						    '''unet''': unet,
						    '''scheduler''': scheduler,
						    '''vae''': vae,
						    '''text_encoder''': text_encoder,
						    '''tokenizer''': tokenizer,
						    '''safety_checker''': None,
						    '''feature_extractor''': None,
						}
						lowerCAmelCase__			:		List[Any]						       =			{
						    '''unet_lora_layers''': unet_lora_layers,
						    '''text_encoder_lora_layers''': text_encoder_lora_layers,
						    '''unet_lora_attn_procs''': unet_lora_attn_procs,
						}
						return pipeline_components, lora_components







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__			:		List[Any]						       =			1
						lowerCAmelCase__			:		str						       =			1_0
						lowerCAmelCase__			:		Any						       =			4
						lowerCAmelCase__			:		List[Any]						       =			(3_2, 3_2)

						lowerCAmelCase__			:		int						       =			torch.manual_seed(0	)
						lowerCAmelCase__			:		List[Any]						       =			floats_tensor((batch_size, num_channels) + sizes	)
						lowerCAmelCase__			:		int						       =			torch.randint(1     ,UpperCamelCase__     ,size=(batch_size, sequence_length)     ,generator=UpperCamelCase__	)

						lowerCAmelCase__			:		List[str]						       =			{
						    '''prompt''': '''A painting of a squirrel eating a burger''',
						    '''generator''': generator,
						    '''num_inference_steps''': 2,
						    '''guidance_scale''': 6.0,
						    '''output_type''': '''numpy''',
						}

						return noise, input_ids, pipeline_inputs

						# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__			:		List[Any]						       =			7_7

						lowerCAmelCase__			:		int						       =			torch.randint(2     ,5_6     ,size=(1, max_seq_length)     ,generator=torch.manual_seed(0	)	)

						lowerCAmelCase__			:		Any						       =			{}
						lowerCAmelCase__			:		Optional[Any]						       =			inputs
						return prepared_inputs







					def  __lowerCAmelCase				( self    :       Any     ,lowercase_    :       List[Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		str						       =			self.get_dummy_components()
						LoraLoaderMixin.save_lora_weights(
						    save_directory=UpperCamelCase__     ,unet_lora_layers=lora_components['''unet_lora_layers''']     ,text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']     ,)
						self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__     ,'''pytorch_lora_weights.bin'''	)	)	)







					def  __lowerCAmelCase				( self    :       str	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Any						       =			self.get_dummy_components()
						lowerCAmelCase__			:		Any						       =			StableDiffusionPipeline(**UpperCamelCase__	)
						lowerCAmelCase__			:		Optional[Any]						       =			sd_pipe.to(UpperCamelCase__	)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase__	)

						lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			self.get_dummy_inputs()

						lowerCAmelCase__			:		Dict						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		Any						       =			original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
							LoraLoaderMixin.save_lora_weights(
							    save_directory=UpperCamelCase__     ,unet_lora_layers=lora_components['''unet_lora_layers''']     ,text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']     ,)
							self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__     ,'''pytorch_lora_weights.bin'''	)	)	)
							sd_pipe.load_lora_weights(UpperCamelCase__	)

						lowerCAmelCase__			:		int						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		Optional[Any]						       =			lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__	)     ,torch.from_numpy(UpperCamelCase__	)	)	)







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[str]						       =			self.get_dummy_components()
						lowerCAmelCase__			:		int						       =			StableDiffusionPipeline(**UpperCamelCase__	)
						lowerCAmelCase__			:		Union[str, Any]						       =			sd_pipe.to(UpperCamelCase__	)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase__	)

						lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			self.get_dummy_inputs()

						lowerCAmelCase__			:		Any						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		List[str]						       =			original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
							LoraLoaderMixin.save_lora_weights(
							    save_directory=UpperCamelCase__     ,unet_lora_layers=lora_components['''unet_lora_layers''']     ,text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']     ,safe_serialization=UpperCamelCase__     ,)
							self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__     ,'''pytorch_lora_weights.safetensors'''	)	)	)
							sd_pipe.load_lora_weights(UpperCamelCase__	)

						lowerCAmelCase__			:		Dict						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		Optional[int]						       =			lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__	)     ,torch.from_numpy(UpperCamelCase__	)	)	)







					def  __lowerCAmelCase				( self    :       int	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			self.get_dummy_components()
						lowerCAmelCase__			:		List[str]						       =			lora_components['''unet_lora_attn_procs''']
						lowerCAmelCase__			:		str						       =			StableDiffusionPipeline(**UpperCamelCase__	)
						lowerCAmelCase__			:		List[Any]						       =			sd_pipe.to(UpperCamelCase__	)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase__	)

						lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__			:		Any						       =			self.get_dummy_inputs()

						lowerCAmelCase__			:		Tuple						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		List[str]						       =			original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
							lowerCAmelCase__			:		List[Any]						       =			sd_pipe.unet
							unet.set_attn_processor(UpperCamelCase__	)
							unet.save_attn_procs(UpperCamelCase__	)
							self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__     ,'''pytorch_lora_weights.bin'''	)	)	)
							sd_pipe.load_lora_weights(UpperCamelCase__	)

						lowerCAmelCase__			:		Tuple						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		List[str]						       =			lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__	)     ,torch.from_numpy(UpperCamelCase__	)	)	)







					def  __lowerCAmelCase				( self    :       int	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[str]						       =			self.get_dummy_components()
						lowerCAmelCase__			:		List[Any]						       =			StableDiffusionPipeline(**UpperCamelCase__	)

						lowerCAmelCase__			:		Tuple						       =			self.get_dummy_tokens()

						# inference without lora
						lowerCAmelCase__			:		List[Any]						       =			pipe.text_encoder(**UpperCamelCase__	)[0]
						assert outputs_without_lora.shape == (1, 7_7, 3_2)

						# create lora_attn_procs with zeroed out up.weights
						lowerCAmelCase__			:		Tuple						       =			create_text_encoder_lora_attn_procs(pipe.text_encoder	)
						set_lora_up_weights(UpperCamelCase__     ,randn_weight=UpperCamelCase__	)

						# monkey patch
						pipe._modify_text_encoder(UpperCamelCase__	)

						# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
						del text_attn_procs
						gc.collect()

						# inference with lora
						lowerCAmelCase__			:		List[str]						       =			pipe.text_encoder(**UpperCamelCase__	)[0]
						assert outputs_with_lora.shape == (1, 7_7, 3_2)

						assert torch.allclose(
						    UpperCamelCase__     ,UpperCamelCase__	), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

						# create lora_attn_procs with randn up.weights
						lowerCAmelCase__			:		Optional[Any]						       =			create_text_encoder_lora_attn_procs(pipe.text_encoder	)
						set_lora_up_weights(UpperCamelCase__     ,randn_weight=UpperCamelCase__	)

						# monkey patch
						pipe._modify_text_encoder(UpperCamelCase__	)

						# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
						del text_attn_procs
						gc.collect()

						# inference with lora
						lowerCAmelCase__			:		Dict						       =			pipe.text_encoder(**UpperCamelCase__	)[0]
						assert outputs_with_lora.shape == (1, 7_7, 3_2)

						assert not torch.allclose(
						    UpperCamelCase__     ,UpperCamelCase__	), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"







					def  __lowerCAmelCase				( self    :       Any	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[str]						       =			self.get_dummy_components()
						lowerCAmelCase__			:		List[Any]						       =			StableDiffusionPipeline(**UpperCamelCase__	)

						lowerCAmelCase__			:		Optional[Any]						       =			self.get_dummy_tokens()

						# inference without lora
						lowerCAmelCase__			:		Union[str, Any]						       =			pipe.text_encoder(**UpperCamelCase__	)[0]
						assert outputs_without_lora.shape == (1, 7_7, 3_2)

						# create lora_attn_procs with randn up.weights
						lowerCAmelCase__			:		Optional[Any]						       =			create_text_encoder_lora_attn_procs(pipe.text_encoder	)
						set_lora_up_weights(UpperCamelCase__     ,randn_weight=UpperCamelCase__	)

						# monkey patch
						pipe._modify_text_encoder(UpperCamelCase__	)

						# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
						del text_attn_procs
						gc.collect()

						# inference with lora
						lowerCAmelCase__			:		Tuple						       =			pipe.text_encoder(**UpperCamelCase__	)[0]
						assert outputs_with_lora.shape == (1, 7_7, 3_2)

						assert not torch.allclose(
						    UpperCamelCase__     ,UpperCamelCase__	), "lora outputs should be different to without lora outputs"

						# remove monkey patch
						pipe._remove_text_encoder_monkey_patch()

						# inference with removed lora
						lowerCAmelCase__			:		int						       =			pipe.text_encoder(**UpperCamelCase__	)[0]
						assert outputs_without_lora_removed.shape == (1, 7_7, 3_2)

						assert torch.allclose(
						    UpperCamelCase__     ,UpperCamelCase__	), "remove lora monkey patch should restore the original outputs"







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Optional[Any]						       =			self.get_dummy_components()
						lowerCAmelCase__			:		int						       =			StableDiffusionPipeline(**UpperCamelCase__	)
						lowerCAmelCase__			:		List[Any]						       =			sd_pipe.to(UpperCamelCase__	)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase__	)

						lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__			:		Optional[int]						       =			self.get_dummy_inputs()

						with tempfile.TemporaryDirectory() as tmpdirname:
							LoraLoaderMixin.save_lora_weights(
							    save_directory=UpperCamelCase__     ,unet_lora_layers=lora_components['''unet_lora_layers''']     ,text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']     ,)
							self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__     ,'''pytorch_lora_weights.bin'''	)	)	)
							sd_pipe.load_lora_weights(UpperCamelCase__	)

						lowerCAmelCase__			:		Optional[Any]						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		Union[str, Any]						       =			lora_images[0, -3:, -3:, -1]

						lowerCAmelCase__			:		List[str]						       =			sd_pipe(**UpperCamelCase__     ,cross_attention_kwargs={'''scale''': 0.5}	).images
						lowerCAmelCase__			:		Dict						       =			lora_images_with_scale[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(
						    torch.allclose(torch.from_numpy(UpperCamelCase__	)     ,torch.from_numpy(UpperCamelCase__	)	)	)







					def  __lowerCAmelCase				( self    :       List[Any]	):
						with tempfile.TemporaryDirectory() as tmpdirname:
							self.create_lora_weight_file(UpperCamelCase__	)

							lowerCAmelCase__       ,lowerCAmelCase__			:		str						       =			self.get_dummy_components()
							lowerCAmelCase__			:		str						       =			StableDiffusionPipeline(**UpperCamelCase__	)
							lowerCAmelCase__			:		Optional[int]						       =			sd_pipe.to(UpperCamelCase__	)
							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__	)

							# check if vanilla attention processors are used
							for _, module in sd_pipe.unet.named_modules():
								if isinstance(UpperCamelCase__     ,UpperCamelCase__	):
									self.assertIsInstance(module.processor     ,(AttnProcessor, AttnProcessor2_0)	)

            # load LoRA weight file
							sd_pipe.load_lora_weights(UpperCamelCase__	)

							# check if lora attention processors are used
							for _, module in sd_pipe.unet.named_modules():
								if isinstance(UpperCamelCase__     ,UpperCamelCase__	):
									lowerCAmelCase__			:		Tuple						       =			(
									    LoRAAttnProcessor2_0 if hasattr(UpperCamelCase__     ,'''scaled_dot_product_attention'''	) else LoRAAttnProcessor
									)
									self.assertIsInstance(module.processor     ,UpperCamelCase__	)







					@unittest.skipIf(torch_device != '''cuda'''     ,'''This test is supposed to run on GPU'''	)
					def  __lowerCAmelCase				( self    :       int	):
						with tempfile.TemporaryDirectory() as tmpdirname:
							self.create_lora_weight_file(UpperCamelCase__	)

							lowerCAmelCase__       ,lowerCAmelCase__			:		Union[str, Any]						       =			self.get_dummy_components()
							lowerCAmelCase__			:		Optional[Any]						       =			StableDiffusionPipeline(**UpperCamelCase__	)
							lowerCAmelCase__			:		str						       =			sd_pipe.to(UpperCamelCase__	)
							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__	)

							# enable XFormers
							sd_pipe.enable_xformers_memory_efficient_attention()

							# check if xFormers attention processors are used
							for _, module in sd_pipe.unet.named_modules():
								if isinstance(UpperCamelCase__     ,UpperCamelCase__	):
									self.assertIsInstance(module.processor     ,UpperCamelCase__	)

            # load LoRA weight file
							sd_pipe.load_lora_weights(UpperCamelCase__	)

							# check if lora attention processors are used
							for _, module in sd_pipe.unet.named_modules():
								if isinstance(UpperCamelCase__     ,UpperCamelCase__	):
									self.assertIsInstance(module.processor     ,UpperCamelCase__	)







					@unittest.skipIf(torch_device != '''cuda'''     ,'''This test is supposed to run on GPU'''	)
					def  __lowerCAmelCase				( self    :       Union[str, Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		str						       =			self.get_dummy_components()
						lowerCAmelCase__			:		Tuple						       =			StableDiffusionPipeline(**UpperCamelCase__	)
						lowerCAmelCase__			:		int						       =			sd_pipe.to(UpperCamelCase__	)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase__	)

						lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__			:		List[str]						       =			self.get_dummy_inputs()

						# enable XFormers
						sd_pipe.enable_xformers_memory_efficient_attention()

						lowerCAmelCase__			:		List[str]						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		Tuple						       =			original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
							LoraLoaderMixin.save_lora_weights(
							    save_directory=UpperCamelCase__     ,unet_lora_layers=lora_components['''unet_lora_layers''']     ,text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']     ,)
							self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__     ,'''pytorch_lora_weights.bin'''	)	)	)
							sd_pipe.load_lora_weights(UpperCamelCase__	)

						lowerCAmelCase__			:		str						       =			sd_pipe(**UpperCamelCase__	).images
						lowerCAmelCase__			:		str						       =			lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__	)     ,torch.from_numpy(UpperCamelCase__	)	)	)







"""simple docstring"""





def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		List[Any]						       =			53_81
	for x in s:
		lowerCAmelCase__			:		Tuple						       =			((hash_value << 5) + hash_value) + ord(A_				)
	return hash_value & 0Xf_f_f_f_f_f_f_f




