





"""simple docstring"""





import argparse
import json

import torch

from diffusers import DDPMScheduler, LDMPipeline, UNetaDModel, VQModel



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				Tuple     ,    SCREAMING_SNAKE_CASE							:				Any=1 ):


							'''simple docstring'''







							if n_shave_prefix_segments >= 0:
														return ".".join(path.split('''.''' )[n_shave_prefix_segments:] )
							else:
														return ".".join(path.split('''.''' )[:n_shave_prefix_segments] )



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				Union[str, Any]     ,    SCREAMING_SNAKE_CASE							:				Any=0 ):


							'''simple docstring'''







							__lowerCamelCase   :   Any       =[]
							for old_item in old_list:
														__lowerCamelCase   :   str       =old_item.replace('''in_layers.0'''     ,    '''norm1''' )
														__lowerCamelCase   :   List[str]       =new_item.replace('''in_layers.2'''     ,    '''conv1''' )

														__lowerCamelCase   :   Union[str, Any]       =new_item.replace('''out_layers.0'''     ,    '''norm2''' )
														__lowerCamelCase   :   Optional[int]       =new_item.replace('''out_layers.3'''     ,    '''conv2''' )

														__lowerCamelCase   :   int       =new_item.replace('''emb_layers.1'''     ,    '''time_emb_proj''' )
														__lowerCamelCase   :   int       =new_item.replace('''skip_connection'''     ,    '''conv_shortcut''' )

														__lowerCamelCase   :   Tuple       =shave_segments(SCREAMING_SNAKE_CASE     ,    n_shave_prefix_segments=SCREAMING_SNAKE_CASE )

														mapping.append({'''old''': old_item, '''new''': new_item} )

							return mapping



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				int     ,    SCREAMING_SNAKE_CASE							:				Optional[Any]=0 ):


							'''simple docstring'''







							__lowerCamelCase   :   Union[str, Any]       =[]
							for old_item in old_list:
														__lowerCamelCase   :   int       =old_item

														__lowerCamelCase   :   Dict       =new_item.replace('''norm.weight'''     ,    '''group_norm.weight''' )
														__lowerCamelCase   :   Tuple       =new_item.replace('''norm.bias'''     ,    '''group_norm.bias''' )

														__lowerCamelCase   :   Any       =new_item.replace('''proj_out.weight'''     ,    '''proj_attn.weight''' )
														__lowerCamelCase   :   Optional[Any]       =new_item.replace('''proj_out.bias'''     ,    '''proj_attn.bias''' )

														__lowerCamelCase   :   Optional[int]       =shave_segments(SCREAMING_SNAKE_CASE     ,    n_shave_prefix_segments=SCREAMING_SNAKE_CASE )

														mapping.append({'''old''': old_item, '''new''': new_item} )

							return mapping



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				str     ,    SCREAMING_SNAKE_CASE							:				int     ,    SCREAMING_SNAKE_CASE							:				List[str]     ,    SCREAMING_SNAKE_CASE							:				Optional[int]=None     ,    SCREAMING_SNAKE_CASE							:				List[str]=None     ,    SCREAMING_SNAKE_CASE							:				Optional[Any]=None ):


							'''simple docstring'''







							assert isinstance(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE ), "Paths should be a list of dicts containing 'old' and 'new' keys."

							# Splits the attention layers into three variables.
							if attention_paths_to_split is not None:
														for path, path_map in attention_paths_to_split.items():
																					__lowerCamelCase   :   Optional[int]       =old_checkpoint[path]
																					__lowerCamelCase   :   List[str]       =old_tensor.shape[0] // 3

																					__lowerCamelCase   :   Any       =(-1, channels) if len(old_tensor.shape ) == 3 else (-1)

																					__lowerCamelCase   :   str       =old_tensor.shape[0] // config['''num_head_channels'''] // 3

																					__lowerCamelCase   :   Dict       =old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:] )
																					__lowerCamelCase     ,    __lowerCamelCase     ,    __lowerCamelCase   :   Optional[int]       =old_tensor.split(channels // num_heads     ,    dim=1 )

																					__lowerCamelCase   :   List[str]       =query.reshape(SCREAMING_SNAKE_CASE )
																					__lowerCamelCase   :   Optional[int]       =key.reshape(SCREAMING_SNAKE_CASE )
																					__lowerCamelCase   :   Tuple       =value.reshape(SCREAMING_SNAKE_CASE )

							for path in paths:
														__lowerCamelCase   :   Union[str, Any]       =path['''new''']

														# These have already been assigned
														if attention_paths_to_split is not None and new_path in attention_paths_to_split:
																					continue

														# Global renaming happens here
														__lowerCamelCase   :   Optional[Any]       =new_path.replace('''middle_block.0'''     ,    '''mid_block.resnets.0''' )
														__lowerCamelCase   :   Any       =new_path.replace('''middle_block.1'''     ,    '''mid_block.attentions.0''' )
														__lowerCamelCase   :   List[Any]       =new_path.replace('''middle_block.2'''     ,    '''mid_block.resnets.1''' )

														if additional_replacements is not None:
																					for replacement in additional_replacements:
																												__lowerCamelCase   :   str       =new_path.replace(replacement['''old''']     ,    replacement['''new'''] )

        # proj_attn.weight has to be converted from conv 1D to linear
														if "proj_attn.weight" in new_path:
																					__lowerCamelCase   :   str       =old_checkpoint[path['''old''']][:, :, 0]
														else:
																					__lowerCamelCase   :   Any       =old_checkpoint[path['''old''']]



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				str     ,    SCREAMING_SNAKE_CASE							:				List[str] ):


							'''simple docstring'''







							__lowerCamelCase   :   Union[str, Any]       ={}

							__lowerCamelCase   :   List[str]       =checkpoint['''time_embed.0.weight''']
							__lowerCamelCase   :   Union[str, Any]       =checkpoint['''time_embed.0.bias''']
							__lowerCamelCase   :   Dict       =checkpoint['''time_embed.2.weight''']
							__lowerCamelCase   :   Union[str, Any]       =checkpoint['''time_embed.2.bias''']

							__lowerCamelCase   :   Optional[Any]       =checkpoint['''input_blocks.0.0.weight''']
							__lowerCamelCase   :   Optional[Any]       =checkpoint['''input_blocks.0.0.bias''']

							__lowerCamelCase   :   Union[str, Any]       =checkpoint['''out.0.weight''']
							__lowerCamelCase   :   Union[str, Any]       =checkpoint['''out.0.bias''']
							__lowerCamelCase   :   Tuple       =checkpoint['''out.2.weight''']
							__lowerCamelCase   :   Optional[Any]       =checkpoint['''out.2.bias''']

							# Retrieves the keys for the input blocks only
							__lowerCamelCase   :   Dict       =len({'''.'''.join(layer.split('''.''' )[:2] ) for layer in checkpoint if '''input_blocks''' in layer} )
							__lowerCamelCase   :   Optional[Any]       ={
							    layer_id: [key for key in checkpoint if F'input_blocks.{layer_id}' in key]
							    for layer_id in range(SCREAMING_SNAKE_CASE )
							}

							# Retrieves the keys for the middle blocks only
							__lowerCamelCase   :   Optional[Any]       =len({'''.'''.join(layer.split('''.''' )[:2] ) for layer in checkpoint if '''middle_block''' in layer} )
							__lowerCamelCase   :   int       ={
							    layer_id: [key for key in checkpoint if F'middle_block.{layer_id}' in key]
							    for layer_id in range(SCREAMING_SNAKE_CASE )
							}

							# Retrieves the keys for the output blocks only
							__lowerCamelCase   :   Tuple       =len({'''.'''.join(layer.split('''.''' )[:2] ) for layer in checkpoint if '''output_blocks''' in layer} )
							__lowerCamelCase   :   Any       ={
							    layer_id: [key for key in checkpoint if F'output_blocks.{layer_id}' in key]
							    for layer_id in range(SCREAMING_SNAKE_CASE )
							}

							for i in range(1     ,    SCREAMING_SNAKE_CASE ):
														__lowerCamelCase   :   List[Any]       =(i - 1) // (config['''num_res_blocks'''] + 1)
														__lowerCamelCase   :   List[str]       =(i - 1) % (config['''num_res_blocks'''] + 1)

														__lowerCamelCase   :   Optional[Any]       =[key for key in input_blocks[i] if F'input_blocks.{i}.0' in key]
														__lowerCamelCase   :   List[str]       =[key for key in input_blocks[i] if F'input_blocks.{i}.1' in key]

														if F'input_blocks.{i}.0.op.weight' in checkpoint:
																					__lowerCamelCase   :   Tuple       =checkpoint[
																					    F'input_blocks.{i}.0.op.weight'
																					]
																					__lowerCamelCase   :   int       =checkpoint[
																					    F'input_blocks.{i}.0.op.bias'
																					]
																					continue

														__lowerCamelCase   :   str       =renew_resnet_paths(SCREAMING_SNAKE_CASE )
														__lowerCamelCase   :   str       ={'''old''': F'input_blocks.{i}.0', '''new''': F'down_blocks.{block_id}.resnets.{layer_in_block_id}'}
														__lowerCamelCase   :   List[str]       ={'''old''': '''resnets.2.op''', '''new''': '''downsamplers.0.op'''}
														assign_to_checkpoint(
														    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    additional_replacements=[meta_path, resnet_op]     ,    config=SCREAMING_SNAKE_CASE )

														if len(SCREAMING_SNAKE_CASE ):
																					__lowerCamelCase   :   Any       =renew_attention_paths(SCREAMING_SNAKE_CASE )
																					__lowerCamelCase   :   Union[str, Any]       ={
																					    '''old''': F'input_blocks.{i}.1',
																					    '''new''': F'down_blocks.{block_id}.attentions.{layer_in_block_id}',
																					}
																					__lowerCamelCase   :   List[Any]       ={
																					    F'input_blocks.{i}.1.qkv.bias': {
																					        '''key''': F'down_blocks.{block_id}.attentions.{layer_in_block_id}.key.bias',
																					        '''query''': F'down_blocks.{block_id}.attentions.{layer_in_block_id}.query.bias',
																					        '''value''': F'down_blocks.{block_id}.attentions.{layer_in_block_id}.value.bias',
																					    },
																					    F'input_blocks.{i}.1.qkv.weight': {
																					        '''key''': F'down_blocks.{block_id}.attentions.{layer_in_block_id}.key.weight',
																					        '''query''': F'down_blocks.{block_id}.attentions.{layer_in_block_id}.query.weight',
																					        '''value''': F'down_blocks.{block_id}.attentions.{layer_in_block_id}.value.weight',
																					    },
																					}
																					assign_to_checkpoint(
																					    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    additional_replacements=[meta_path]     ,    attention_paths_to_split=SCREAMING_SNAKE_CASE     ,    config=SCREAMING_SNAKE_CASE     ,    )

							__lowerCamelCase   :   Optional[int]       =middle_blocks[0]
							__lowerCamelCase   :   Optional[Any]       =middle_blocks[1]
							__lowerCamelCase   :   Dict       =middle_blocks[2]

							__lowerCamelCase   :   Union[str, Any]       =renew_resnet_paths(SCREAMING_SNAKE_CASE )
							assign_to_checkpoint(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    config=SCREAMING_SNAKE_CASE )

							__lowerCamelCase   :   str       =renew_resnet_paths(SCREAMING_SNAKE_CASE )
							assign_to_checkpoint(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    config=SCREAMING_SNAKE_CASE )

							__lowerCamelCase   :   Optional[Any]       =renew_attention_paths(SCREAMING_SNAKE_CASE )
							__lowerCamelCase   :   Dict       ={
							    '''middle_block.1.qkv.bias''': {
							        '''key''': '''mid_block.attentions.0.key.bias''',
							        '''query''': '''mid_block.attentions.0.query.bias''',
							        '''value''': '''mid_block.attentions.0.value.bias''',
							    },
							    '''middle_block.1.qkv.weight''': {
							        '''key''': '''mid_block.attentions.0.key.weight''',
							        '''query''': '''mid_block.attentions.0.query.weight''',
							        '''value''': '''mid_block.attentions.0.value.weight''',
							    },
							}
							assign_to_checkpoint(
							    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    attention_paths_to_split=SCREAMING_SNAKE_CASE     ,    config=SCREAMING_SNAKE_CASE )

							for i in range(SCREAMING_SNAKE_CASE ):
														__lowerCamelCase   :   Dict       =i // (config['''num_res_blocks'''] + 1)
														__lowerCamelCase   :   Any       =i % (config['''num_res_blocks'''] + 1)
														__lowerCamelCase   :   List[str]       =[shave_segments(SCREAMING_SNAKE_CASE     ,    2 ) for name in output_blocks[i]]
														__lowerCamelCase   :   Any       ={}

														for layer in output_block_layers:
																					__lowerCamelCase     ,    __lowerCamelCase   :   Optional[int]       =layer.split('''.''' )[0], shave_segments(SCREAMING_SNAKE_CASE     ,    1 )
																					if layer_id in output_block_list:
																												output_block_list[layer_id].append(SCREAMING_SNAKE_CASE )
																					else:
																												__lowerCamelCase   :   Union[str, Any]       =[layer_name]

														if len(SCREAMING_SNAKE_CASE ) > 1:
																					__lowerCamelCase   :   str       =[key for key in output_blocks[i] if F'output_blocks.{i}.0' in key]
																					__lowerCamelCase   :   Union[str, Any]       =[key for key in output_blocks[i] if F'output_blocks.{i}.1' in key]

																					__lowerCamelCase   :   Optional[Any]       =renew_resnet_paths(SCREAMING_SNAKE_CASE )
																					__lowerCamelCase   :   Any       =renew_resnet_paths(SCREAMING_SNAKE_CASE )

																					__lowerCamelCase   :   int       ={'''old''': F'output_blocks.{i}.0', '''new''': F'up_blocks.{block_id}.resnets.{layer_in_block_id}'}
																					assign_to_checkpoint(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    additional_replacements=[meta_path]     ,    config=SCREAMING_SNAKE_CASE )

																					if ["conv.weight", "conv.bias"] in output_block_list.values():
																												__lowerCamelCase   :   Any       =list(output_block_list.values() ).index(['''conv.weight''', '''conv.bias'''] )
																												__lowerCamelCase   :   Optional[Any]       =checkpoint[
																												    F'output_blocks.{i}.{index}.conv.weight'
																												]
																												__lowerCamelCase   :   Union[str, Any]       =checkpoint[
																												    F'output_blocks.{i}.{index}.conv.bias'
																												]

																												# Clear attentions as they have been attributed above.
																												if len(SCREAMING_SNAKE_CASE ) == 2:
																																			__lowerCamelCase   :   int       =[]

																					if len(SCREAMING_SNAKE_CASE ):
																												__lowerCamelCase   :   List[Any]       =renew_attention_paths(SCREAMING_SNAKE_CASE )
																												__lowerCamelCase   :   int       ={
																												    '''old''': F'output_blocks.{i}.1',
																												    '''new''': F'up_blocks.{block_id}.attentions.{layer_in_block_id}',
																												}
																												__lowerCamelCase   :   Dict       ={
																												    F'output_blocks.{i}.1.qkv.bias': {
																												        '''key''': F'up_blocks.{block_id}.attentions.{layer_in_block_id}.key.bias',
																												        '''query''': F'up_blocks.{block_id}.attentions.{layer_in_block_id}.query.bias',
																												        '''value''': F'up_blocks.{block_id}.attentions.{layer_in_block_id}.value.bias',
																												    },
																												    F'output_blocks.{i}.1.qkv.weight': {
																												        '''key''': F'up_blocks.{block_id}.attentions.{layer_in_block_id}.key.weight',
																												        '''query''': F'up_blocks.{block_id}.attentions.{layer_in_block_id}.query.weight',
																												        '''value''': F'up_blocks.{block_id}.attentions.{layer_in_block_id}.value.weight',
																												    },
																												}
																												assign_to_checkpoint(
																												    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    additional_replacements=[meta_path]     ,    attention_paths_to_split=to_split if any('''qkv''' in key for key in attentions ) else None     ,    config=SCREAMING_SNAKE_CASE     ,    )
														else:
																					__lowerCamelCase   :   int       =renew_resnet_paths(SCREAMING_SNAKE_CASE     ,    n_shave_prefix_segments=1 )
																					for path in resnet_0_paths:
																												__lowerCamelCase   :   List[Any]       ='''.'''.join(['''output_blocks''', str(SCREAMING_SNAKE_CASE ), path['''old''']] )
																												__lowerCamelCase   :   Any       ='''.'''.join(['''up_blocks''', str(SCREAMING_SNAKE_CASE ), '''resnets''', str(SCREAMING_SNAKE_CASE ), path['''new''']] )

																												__lowerCamelCase   :   Optional[Any]       =checkpoint[old_path]

							return new_checkpoint


if __name__ == "__main__":
							_UpperCamelCase					      =   argparse.ArgumentParser()

							parser.add_argument(
							    '--checkpoint_path', default=None, type=str, required=True, help='Path to the checkpoint to convert.'
							)

							parser.add_argument(
							    '--config_file',
							    default=None,
							    type=str,
							    required=True,
							    help='The config json file corresponding to the architecture.',
							)

							parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')

							_UpperCamelCase					      =   parser.parse_args()

							_UpperCamelCase					      =   torch.load(args.checkpoint_path)

							with open(args.config_file) as f:
														_UpperCamelCase					      =   json.loads(f.read())

							_UpperCamelCase					      =   convert_ldm_checkpoint(checkpoint, config)

							if "ldm" in config:
														del config["ldm"]

							_UpperCamelCase					      =   UNetaDModel(**config)
							model.load_state_dict(converted_checkpoint)

							try:
														_UpperCamelCase					      =   DDPMScheduler.from_config('/'.join(args.checkpoint_path.split('/')[:-1]))
														_UpperCamelCase					      =   VQModel.from_pretrained('/'.join(args.checkpoint_path.split('/')[:-1]))

														_UpperCamelCase					      =   LDMPipeline(unet=model, scheduler=scheduler, vae=vqvae)
														pipe.save_pretrained(args.dump_path)
							except:  # noqa: E722
														model.save_pretrained(args.dump_path)











"""simple docstring"""





import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
							from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
							from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
							from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


_UpperCamelCase					      =   DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

_UpperCamelCase					      =   'main'
# Default branch name
_UpperCamelCase					      =   'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
_UpperCamelCase					      =   'aaaaaaa'
# This commit does not exist, so we should 404.

_UpperCamelCase					      =   'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
_UpperCamelCase					      =   '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'



@contextlib.contextmanager
def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							print('''Welcome!''' )
							yield
							print('''Bye!''' )



@contextlib.contextmanager
def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							print('''Bonjour!''' )
							yield
							print('''Au revoir!''' )
class 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				def        __lowercase	(  self	:str      ):
											# If the spec is missing, importlib would not be able to import the module dynamically.
											assert transformers.__spec__ is not None
											assert importlib.util.find_spec('''transformers'''      ) is not None

class 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:str    ,     __lowercase	:str      ):
											with ContextManagers([]      ):
																		print('''Transformers are awesome!'''      )
											# The print statement adds a new line at the end of the output
											self.assertEqual(mock_stdout.getvalue()    ,     '''Transformers are awesome!\n'''      )




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:Any    ,     __lowercase	:Tuple      ):
											with ContextManagers([context_en()]      ):
																		print('''Transformers are awesome!'''      )
											# The output should be wrapped with an English welcome and goodbye
											self.assertEqual(mock_stdout.getvalue()    ,     '''Welcome!\nTransformers are awesome!\nBye!\n'''      )




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:List[Any]    ,     __lowercase	:Optional[Any]      ):
											with ContextManagers([context_fr(), context_en()]      ):
																		print('''Transformers are awesome!'''      )
											# The output should be wrapped with an English and French welcome and goodbye
											self.assertEqual(mock_stdout.getvalue()    ,     '''Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n'''      )




				@require_torch
				def        __lowercase	(  self	:Tuple      ):
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''', '''next_sentence_label''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''start_positions''', '''end_positions''']      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )




				@require_tf
				def        __lowercase	(  self	:str      ):
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''', '''next_sentence_label''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''start_positions''', '''end_positions''']      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )




				@require_flax
				def        __lowercase	(  self	:str      ):
											# Flax models don't have labels
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     []      )




