



import argparse

import torch

from diffusers import UNetaDConditionModel

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     int			,       _SCREAMING_SNAKE_CASE    :     str			,       _SCREAMING_SNAKE_CASE    :     Dict			,       _SCREAMING_SNAKE_CASE    :     Tuple=None			,       _SCREAMING_SNAKE_CASE    :     int=None			,       _SCREAMING_SNAKE_CASE    :     Tuple=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():
												__a					       =						old_checkpoint[path]
												__a					       =						old_tensor.shape[0] // 3

												__a					       =						(-1, channels) if len(old_tensor.shape      ) == 3 else (-1)

												__a					       =						old_tensor.shape[0] // config["""num_head_channels"""] // 3

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

												__a					       =						query.reshape(_SCREAMING_SNAKE_CASE      )
												__a					       =						key.reshape(_SCREAMING_SNAKE_CASE      )
												__a					       =						value.reshape(_SCREAMING_SNAKE_CASE      )

				for path in paths:
								__a					       =						path["""new"""]

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

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

        # proj_attn.weight has to be converted from conv 1D to linear
								__a					       =						old_checkpoint[path["""old"""]]
								__a					       =						["""proj_attn.weight"""]
								__a					       =						["""proj_out.weight""", """proj_in.weight"""]
								if any(k in new_path for k in names      ):
												__a					       =						weight[:, :, 0]
								elif any(k in new_path for k in names_a      ) and len(weight.shape      ) > 2 and ".attentions." not in new_path:
												__a					       =						weight[:, :, 0]
								else:
												__a					       =						weight

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Tuple			,       _SCREAMING_SNAKE_CASE    :     Any=0      ):
				"""simple docstring"""







				__a					       =						[]
				for old_item in old_list:
								__a					       =						old_item

								#         new_item = new_item.replace('norm.weight', 'group_norm.weight')
								#         new_item = new_item.replace('norm.bias', 'group_norm.bias')

								#         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
								#         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')

								#         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)

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

				return mapping

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Tuple			,       _SCREAMING_SNAKE_CASE    :     Optional[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    :     Optional[int]			,       _SCREAMING_SNAKE_CASE    :     Union[str, Any]=0      ):
				"""simple docstring"""







				__a					       =						[]
				for old_item in old_list:
								mapping.append({"""old""": old_item, """new""": old_item}      )

				return mapping

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     List[str]			,       _SCREAMING_SNAKE_CASE    :     Tuple=0      ):
				"""simple docstring"""







				__a					       =						[]
				for old_item in old_list:
								__a					       =						old_item.replace("""in_layers.0"""			,       """norm1"""      )
								__a					       =						new_item.replace("""in_layers.2"""			,       """conv1"""      )

								__a					       =						new_item.replace("""out_layers.0"""			,       """norm2"""      )
								__a					       =						new_item.replace("""out_layers.3"""			,       """conv2"""      )

								__a					       =						new_item.replace("""emb_layers.1"""			,       """time_emb_proj"""      )
								__a					       =						new_item.replace("""skip_connection"""			,       """conv_shortcut"""      )

								__a					       =						shave_segments(_SCREAMING_SNAKE_CASE			,       n_shave_prefix_segments=_SCREAMING_SNAKE_CASE      )

								if "temopral_conv" not in old_item:
												mapping.append({"""old""": old_item, """new""": new_item}      )

				return mapping

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Union[str, Any]			,       _SCREAMING_SNAKE_CASE    :     Dict			,       _SCREAMING_SNAKE_CASE    :     List[Any]=None			,       _SCREAMING_SNAKE_CASE    :     int=False      ):
				"""simple docstring"""







				__a					       =						{}
				__a					       =						list(checkpoint.keys()      )

				__a					       =						"""model.diffusion_model."""

				# at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
				if sum(k.startswith("""model_ema"""      ) for k in keys      ) > 100 and extract_ema:
								print(f"Checkpoint {path} has both EMA and non-EMA weights."      )
								print(
								    """In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"""
								    """ weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag."""      )
								for key in keys:
												if key.startswith("""model.diffusion_model"""      ):
																__a					       =						"""model_ema.""" + """""".join(key.split("""."""      )[1:]      )
																__a					       =						checkpoint.pop(_SCREAMING_SNAKE_CASE      )
				else:
								if sum(k.startswith("""model_ema"""      ) for k in keys      ) > 100:
												print(
												    """In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"""
												    """ weights (usually better for inference), please make sure to add the `--extract_ema` flag."""      )

								for key in keys:
												__a					       =						checkpoint.pop(_SCREAMING_SNAKE_CASE      )

				__a					       =						{}

				__a					       =						unet_state_dict["""time_embed.0.weight"""]
				__a					       =						unet_state_dict["""time_embed.0.bias"""]
				__a					       =						unet_state_dict["""time_embed.2.weight"""]
				__a					       =						unet_state_dict["""time_embed.2.bias"""]

				if config["class_embed_type"] is None:
								# No parameters to port
								...
				elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
								__a					       =						unet_state_dict["""label_emb.0.0.weight"""]
								__a					       =						unet_state_dict["""label_emb.0.0.bias"""]
								__a					       =						unet_state_dict["""label_emb.0.2.weight"""]
								__a					       =						unet_state_dict["""label_emb.0.2.bias"""]
				else:
								raise NotImplementedError(f"Not implemented `class_embed_type`: {config['class_embed_type']}"      )

				__a					       =						unet_state_dict["""input_blocks.0.0.weight"""]
				__a					       =						unet_state_dict["""input_blocks.0.0.bias"""]

				__a					       =						[v for v in unet_state_dict if v.startswith("""input_blocks.0.1"""      )]
				__a					       =						renew_attention_paths(_SCREAMING_SNAKE_CASE      )
				__a					       =						{"""old""": """input_blocks.0.1""", """new""": """transformer_in"""}
				assign_to_checkpoint(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]			,       config=_SCREAMING_SNAKE_CASE      )

				__a					       =						unet_state_dict["""out.0.weight"""]
				__a					       =						unet_state_dict["""out.0.bias"""]
				__a					       =						unet_state_dict["""out.2.weight"""]
				__a					       =						unet_state_dict["""out.2.bias"""]

				# Retrieves the keys for the input blocks only
				__a					       =						len({""".""".join(layer.split("""."""      )[:2]      ) for layer in unet_state_dict if """input_blocks""" in layer}      )
				__a					       =						{
				    layer_id: [key for key in unet_state_dict if f"input_blocks.{layer_id}" in key]
				    for layer_id in range(_SCREAMING_SNAKE_CASE      )
				}

				# Retrieves the keys for the middle blocks only
				__a					       =						len({""".""".join(layer.split("""."""      )[:2]      ) for layer in unet_state_dict if """middle_block""" in layer}      )
				__a					       =						{
				    layer_id: [key for key in unet_state_dict if f"middle_block.{layer_id}" in key]
				    for layer_id in range(_SCREAMING_SNAKE_CASE      )
				}

				# Retrieves the keys for the output blocks only
				__a					       =						len({""".""".join(layer.split("""."""      )[:2]      ) for layer in unet_state_dict if """output_blocks""" in layer}      )
				__a					       =						{
				    layer_id: [key for key in unet_state_dict if f"output_blocks.{layer_id}" in key]
				    for layer_id in range(_SCREAMING_SNAKE_CASE      )
				}

				for i in range(1			,       _SCREAMING_SNAKE_CASE      ):
								__a					       =						(i - 1) // (config["""layers_per_block"""] + 1)
								__a					       =						(i - 1) % (config["""layers_per_block"""] + 1)

								__a					       =						[
								    key for key in input_blocks[i] if f"input_blocks.{i}.0" in key and f"input_blocks.{i}.0.op" not in key
								]
								__a					       =						[key for key in input_blocks[i] if f"input_blocks.{i}.1" in key]
								__a					       =						[key for key in input_blocks[i] if f"input_blocks.{i}.2" in key]

								if f"input_blocks.{i}.op.weight" in unet_state_dict:
												__a					       =						unet_state_dict.pop(
												    f"input_blocks.{i}.op.weight"      )
												__a					       =						unet_state_dict.pop(
												    f"input_blocks.{i}.op.bias"      )

								__a					       =						renew_resnet_paths(_SCREAMING_SNAKE_CASE      )
								__a					       =						{"""old""": f"input_blocks.{i}.0", """new""": f"down_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      )

								__a					       =						[key for key in resnets if """temopral_conv""" in key]
								__a					       =						renew_temp_conv_paths(_SCREAMING_SNAKE_CASE      )
								__a					       =						{
								    """old""": f"input_blocks.{i}.0.temopral_conv",
								    """new""": f"down_blocks.{block_id}.temp_convs.{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 len(_SCREAMING_SNAKE_CASE      ):
												__a					       =						renew_attention_paths(_SCREAMING_SNAKE_CASE      )
												__a					       =						{"""old""": f"input_blocks.{i}.1", """new""": f"down_blocks.{block_id}.attentions.{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 len(_SCREAMING_SNAKE_CASE      ):
												__a					       =						renew_attention_paths(_SCREAMING_SNAKE_CASE      )
												__a					       =						{
												    """old""": f"input_blocks.{i}.2",
												    """new""": f"down_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
												}
												assign_to_checkpoint(
												    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]			,       config=_SCREAMING_SNAKE_CASE      )

				__a					       =						middle_blocks[0]
				__a					       =						[key for key in resnet_a if """temopral_conv""" in key]
				__a					       =						middle_blocks[1]
				__a					       =						middle_blocks[2]
				__a					       =						middle_blocks[3]
				__a					       =						[key for key in resnet_a if """temopral_conv""" in key]

				__a					       =						renew_resnet_paths(_SCREAMING_SNAKE_CASE      )
				__a					       =						{"""old""": """middle_block.0""", """new""": """mid_block.resnets.0"""}
				assign_to_checkpoint(
				    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       config=_SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]      )

				__a					       =						renew_temp_conv_paths(_SCREAMING_SNAKE_CASE      )
				__a					       =						{"""old""": """middle_block.0.temopral_conv""", """new""": """mid_block.temp_convs.0"""}
				assign_to_checkpoint(
				    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       config=_SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]      )

				__a					       =						renew_resnet_paths(_SCREAMING_SNAKE_CASE      )
				__a					       =						{"""old""": """middle_block.3""", """new""": """mid_block.resnets.1"""}
				assign_to_checkpoint(
				    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       config=_SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]      )

				__a					       =						renew_temp_conv_paths(_SCREAMING_SNAKE_CASE      )
				__a					       =						{"""old""": """middle_block.3.temopral_conv""", """new""": """mid_block.temp_convs.1"""}
				assign_to_checkpoint(
				    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       config=_SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]      )

				__a					       =						renew_attention_paths(_SCREAMING_SNAKE_CASE      )
				__a					       =						{"""old""": """middle_block.1""", """new""": """mid_block.attentions.0"""}
				assign_to_checkpoint(
				    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]			,       config=_SCREAMING_SNAKE_CASE      )

				__a					       =						renew_attention_paths(_SCREAMING_SNAKE_CASE      )
				__a					       =						{"""old""": """middle_block.2""", """new""": """mid_block.temp_attentions.0"""}
				assign_to_checkpoint(
				    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]			,       config=_SCREAMING_SNAKE_CASE      )

				for i in range(_SCREAMING_SNAKE_CASE      ):
								__a					       =						i // (config["""layers_per_block"""] + 1)
								__a					       =						i % (config["""layers_per_block"""] + 1)
								__a					       =						[shave_segments(_SCREAMING_SNAKE_CASE			,       2      ) for name in output_blocks[i]]
								__a					       =						{}

								for layer in output_block_layers:
												__a       ,   __a					       =						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:
																__a					       =						[layer_name]

								if len(_SCREAMING_SNAKE_CASE      ) > 1:
												__a					       =						[key for key in output_blocks[i] if f"output_blocks.{i}.0" in key]
												__a					       =						[key for key in output_blocks[i] if f"output_blocks.{i}.1" in key]
												__a					       =						[key for key in output_blocks[i] if f"output_blocks.{i}.2" in key]

												__a					       =						renew_resnet_paths(_SCREAMING_SNAKE_CASE      )
												__a					       =						renew_resnet_paths(_SCREAMING_SNAKE_CASE      )

												__a					       =						{"""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      )

												__a					       =						[key for key in resnets if """temopral_conv""" in key]
												__a					       =						renew_temp_conv_paths(_SCREAMING_SNAKE_CASE      )
												__a					       =						{
												    """old""": f"output_blocks.{i}.0.temopral_conv",
												    """new""": f"up_blocks.{block_id}.temp_convs.{layer_in_block_id}",
												}
												assign_to_checkpoint(
												    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]			,       config=_SCREAMING_SNAKE_CASE      )

												__a					       =						{k: sorted(_SCREAMING_SNAKE_CASE      ) for k, v in output_block_list.items()}
												if ["conv.bias", "conv.weight"] in output_block_list.values():
																__a					       =						list(output_block_list.values()      ).index(["""conv.bias""", """conv.weight"""]      )
																__a					       =						unet_state_dict[
																    f"output_blocks.{i}.{index}.conv.weight"
																]
																__a					       =						unet_state_dict[
																    f"output_blocks.{i}.{index}.conv.bias"
																]

																# Clear attentions as they have been attributed above.
																if len(_SCREAMING_SNAKE_CASE      ) == 2:
																				__a					       =						[]

												if len(_SCREAMING_SNAKE_CASE      ):
																__a					       =						renew_attention_paths(_SCREAMING_SNAKE_CASE      )
																__a					       =						{
																    """old""": f"output_blocks.{i}.1",
																    """new""": f"up_blocks.{block_id}.attentions.{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 len(_SCREAMING_SNAKE_CASE      ):
																__a					       =						renew_attention_paths(_SCREAMING_SNAKE_CASE      )
																__a					       =						{
																    """old""": f"output_blocks.{i}.2",
																    """new""": f"up_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
																}
																assign_to_checkpoint(
																    _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       additional_replacements=[meta_path]			,       config=_SCREAMING_SNAKE_CASE      )
								else:
												__a					       =						renew_resnet_paths(_SCREAMING_SNAKE_CASE			,       n_shave_prefix_segments=1      )
												for path in resnet_0_paths:
																__a					       =						""".""".join(["""output_blocks""", str(_SCREAMING_SNAKE_CASE      ), path["""old"""]]      )
																__a					       =						""".""".join(["""up_blocks""", str(_SCREAMING_SNAKE_CASE      ), """resnets""", str(_SCREAMING_SNAKE_CASE      ), path["""new"""]]      )
																__a					       =						unet_state_dict[old_path]

												__a					       =						[l for l in output_block_layers if """temopral_conv""" in l]
												for path in temopral_conv_paths:
																__a					       =						path.split("""temopral_conv."""      )[-1]
																__a					       =						""".""".join(["""output_blocks""", str(_SCREAMING_SNAKE_CASE      ), str(_SCREAMING_SNAKE_CASE      ), """temopral_conv""", pruned_path]      )
																__a					       =						""".""".join(["""up_blocks""", str(_SCREAMING_SNAKE_CASE      ), """temp_convs""", str(_SCREAMING_SNAKE_CASE      ), pruned_path]      )
																__a					       =						unet_state_dict[old_path]

				return new_checkpoint


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

						parser.add_argument(
						    """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
						)
						parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
						lowerCamelCase__     =	parser.parse_args()

						lowerCamelCase__     =	torch.load(args.checkpoint_path, map_location="""cpu""")
						lowerCamelCase__     =	UNetaDConditionModel()

						lowerCamelCase__     =	convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

						lowerCamelCase__     =	set(unet.state_dict().keys()) - set(converted_ckpt.keys())
						lowerCamelCase__     =	set(converted_ckpt.keys()) - set(unet.state_dict().keys())

						assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"

						# load state_dict
						unet.load_state_dict(converted_ckpt)

						unet.save_pretrained(args.dump_path)

						# -- finish converting the unet --





# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from pathlib import Path

from .config_args import default_config_file, load_config_from_file
from .config_utils import SubcommandHelpFormatter


lowerCamelCase__     =	"""Update an existing config file with the latest defaults while maintaining the old configuration."""

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Tuple      ):
				"""simple docstring"""







				__a					       =						args.config_file
				if config_file is None and Path(_SCREAMING_SNAKE_CASE      ).exists():
								__a					       =						default_config_file
				elif not Path(_SCREAMING_SNAKE_CASE      ).exists():
								raise ValueError(f"The passed config file located at {config_file} doesn't exist."      )
				__a					       =						load_config_from_file(_SCREAMING_SNAKE_CASE      )

				if config_file.endswith(""".json"""      ):
								config.to_json_file(_SCREAMING_SNAKE_CASE      )
				else:
								config.to_yaml_file(_SCREAMING_SNAKE_CASE      )
				return config_file

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Optional[Any]			,       _SCREAMING_SNAKE_CASE    :     int      ):
				"""simple docstring"""







				__a					       =						parser.add_parser("""update"""			,       parents=_SCREAMING_SNAKE_CASE			,       help=_SCREAMING_SNAKE_CASE			,       formatter_class=_SCREAMING_SNAKE_CASE      )
				parser.add_argument(
				    """--config_file"""			,       default=_SCREAMING_SNAKE_CASE			,       help=(
				        """The path to the config file to update. Will default to a file named default_config.yaml in the cache """
				        """location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have """
				        """such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed """
				        """with 'huggingface'."""
				    )			,       )

				parser.set_defaults(func=_SCREAMING_SNAKE_CASE      )
				return parser

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Optional[Any]      ):
				"""simple docstring"""







				__a					       =						update_config(_SCREAMING_SNAKE_CASE      )
				print(f"Sucessfully updated the configuration file at {config_file}."      )
