



import argparse

import torch

from diffusers import UNetaDConditionModel







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case=None       ,	__snake_case=None       ,	__snake_case=None     )  ->  List[Any]:






      '''simple docstring'''







      assert isinstance(__snake_case       ,	__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():
                  UpperCAmelCase_	:						str					   =		old_checkpoint[path]
                  UpperCAmelCase_	:						str					   =		old_tensor.shape[0] // 3

                  UpperCAmelCase_	:						List[str]					   =		(-1, channels) if len(old_tensor.shape     ) == 3 else (-1)

                  UpperCAmelCase_	:						Optional[int]					   =		old_tensor.shape[0] // config["num_head_channels"] // 3

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

                  UpperCAmelCase_	:						Union[str, Any]					   =		query.reshape(__snake_case     )
                  UpperCAmelCase_	:						Tuple					   =		key.reshape(__snake_case     )
                  UpperCAmelCase_	:						Union[str, Any]					   =		value.reshape(__snake_case     )

      for path in paths:
            UpperCAmelCase_	:						int					   =		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:
                        UpperCAmelCase_	:						Optional[Any]					   =		new_path.replace(replacement["old"]       ,	replacement["new"]     )

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







def  _snake_case			(							__snake_case       ,	__snake_case=0     )  ->  Union[str, Any]:






      '''simple docstring'''







      UpperCAmelCase_	:						Tuple					   =		[]
      for old_item in old_list:
            UpperCAmelCase_	:						Dict					   =		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  _snake_case			(							__snake_case       ,	__snake_case=1     )  ->  Dict:






      '''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  _snake_case			(							__snake_case       ,	__snake_case=0     )  ->  Tuple:






      '''simple docstring'''







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

      return mapping







def  _snake_case			(							__snake_case       ,	__snake_case=0     )  ->  Any:






      '''simple docstring'''







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

            UpperCAmelCase_	:						Optional[int]					   =		new_item.replace("out_layers.0"       ,	"norm2"     )
            UpperCAmelCase_	:						List[str]					   =		new_item.replace("out_layers.3"       ,	"conv2"     )

            UpperCAmelCase_	:						str					   =		new_item.replace("emb_layers.1"       ,	"time_emb_proj"     )
            UpperCAmelCase_	:						Tuple					   =		new_item.replace("skip_connection"       ,	"conv_shortcut"     )

            UpperCAmelCase_	:						List[Any]					   =		shave_segments(__snake_case       ,	n_shave_prefix_segments=__snake_case     )

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

      return mapping







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case=None       ,	__snake_case=False     )  ->  Optional[Any]:






      '''simple docstring'''







      UpperCAmelCase_	:						List[Any]					   =		{}
      UpperCAmelCase_	:						List[Any]					   =		list(checkpoint.keys()     )

      UpperCAmelCase_	:						Optional[int]					   =		"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     ) > 1_0_0 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"     ):
                        UpperCAmelCase_	:						Any					   =		"model_ema." + "".join(key.split("."     )[1:]     )
                        UpperCAmelCase_	:						Tuple					   =		checkpoint.pop(__snake_case     )
      else:
            if sum(k.startswith("model_ema"     ) for k in keys     ) > 1_0_0:
                  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:
                  UpperCAmelCase_	:						int					   =		checkpoint.pop(__snake_case     )

      UpperCAmelCase_	:						Union[str, Any]					   =		{}

      UpperCAmelCase_	:						int					   =		unet_state_dict["time_embed.0.weight"]
      UpperCAmelCase_	:						Dict					   =		unet_state_dict["time_embed.0.bias"]
      UpperCAmelCase_	:						Optional[Any]					   =		unet_state_dict["time_embed.2.weight"]
      UpperCAmelCase_	:						Union[str, Any]					   =		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":
            UpperCAmelCase_	:						Union[str, Any]					   =		unet_state_dict["label_emb.0.0.weight"]
            UpperCAmelCase_	:						int					   =		unet_state_dict["label_emb.0.0.bias"]
            UpperCAmelCase_	:						Optional[int]					   =		unet_state_dict["label_emb.0.2.weight"]
            UpperCAmelCase_	:						Dict					   =		unet_state_dict["label_emb.0.2.bias"]
      else:
            raise NotImplementedError(F"""Not implemented `class_embed_type`: {config['class_embed_type']}"""     )

      UpperCAmelCase_	:						int					   =		unet_state_dict["input_blocks.0.0.weight"]
      UpperCAmelCase_	:						Any					   =		unet_state_dict["input_blocks.0.0.bias"]

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

      UpperCAmelCase_	:						Optional[int]					   =		unet_state_dict["out.0.weight"]
      UpperCAmelCase_	:						str					   =		unet_state_dict["out.0.bias"]
      UpperCAmelCase_	:						Any					   =		unet_state_dict["out.2.weight"]
      UpperCAmelCase_	:						List[Any]					   =		unet_state_dict["out.2.bias"]

      # Retrieves the keys for the input blocks only
      UpperCAmelCase_	:						Any					   =		len({".".join(layer.split("."     )[:2]     ) for layer in unet_state_dict if "input_blocks" in layer}     )
      UpperCAmelCase_	:						int					   =		{
          layer_id: [key for key in unet_state_dict if F"""input_blocks.{layer_id}""" in key]
          for layer_id in range(__snake_case     )
      }

      # Retrieves the keys for the middle blocks only
      UpperCAmelCase_	:						Optional[int]					   =		len({".".join(layer.split("."     )[:2]     ) for layer in unet_state_dict if "middle_block" in layer}     )
      UpperCAmelCase_	:						str					   =		{
          layer_id: [key for key in unet_state_dict if F"""middle_block.{layer_id}""" in key]
          for layer_id in range(__snake_case     )
      }

      # Retrieves the keys for the output blocks only
      UpperCAmelCase_	:						Tuple					   =		len({".".join(layer.split("."     )[:2]     ) for layer in unet_state_dict if "output_blocks" in layer}     )
      UpperCAmelCase_	:						Union[str, Any]					   =		{
          layer_id: [key for key in unet_state_dict if F"""output_blocks.{layer_id}""" in key]
          for layer_id in range(__snake_case     )
      }

      for i in range(1       ,	__snake_case     ):
            UpperCAmelCase_	:						List[Any]					   =		(i - 1) // (config["layers_per_block"] + 1)
            UpperCAmelCase_	:						List[str]					   =		(i - 1) % (config["layers_per_block"] + 1)

            UpperCAmelCase_	:						List[str]					   =		[
                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
            ]
            UpperCAmelCase_	:						Tuple					   =		[key for key in input_blocks[i] if F"""input_blocks.{i}.1""" in key]
            UpperCAmelCase_	:						List[Any]					   =		[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:
                  UpperCAmelCase_	:						Dict					   =		unet_state_dict.pop(
                      F"""input_blocks.{i}.op.weight"""     )
                  UpperCAmelCase_	:						Optional[int]					   =		unet_state_dict.pop(
                      F"""input_blocks.{i}.op.bias"""     )

            UpperCAmelCase_	:						Optional[int]					   =		renew_resnet_paths(__snake_case     )
            UpperCAmelCase_	:						Optional[Any]					   =		{"old": F"""input_blocks.{i}.0""", "new": F"""down_blocks.{block_id}.resnets.{layer_in_block_id}"""}
            assign_to_checkpoint(
                __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

            UpperCAmelCase_	:						List[str]					   =		[key for key in resnets if "temopral_conv" in key]
            UpperCAmelCase_	:						Any					   =		renew_temp_conv_paths(__snake_case     )
            UpperCAmelCase_	:						Any					   =		{
                "old": F"""input_blocks.{i}.0.temopral_conv""",
                "new": F"""down_blocks.{block_id}.temp_convs.{layer_in_block_id}""",
            }
            assign_to_checkpoint(
                __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

            if len(__snake_case     ):
                  UpperCAmelCase_	:						Any					   =		renew_attention_paths(__snake_case     )
                  UpperCAmelCase_	:						List[Any]					   =		{"old": F"""input_blocks.{i}.1""", "new": F"""down_blocks.{block_id}.attentions.{layer_in_block_id}"""}
                  assign_to_checkpoint(
                      __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

            if len(__snake_case     ):
                  UpperCAmelCase_	:						Tuple					   =		renew_attention_paths(__snake_case     )
                  UpperCAmelCase_	:						int					   =		{
                      "old": F"""input_blocks.{i}.2""",
                      "new": F"""down_blocks.{block_id}.temp_attentions.{layer_in_block_id}""",
                  }
                  assign_to_checkpoint(
                      __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

      UpperCAmelCase_	:						Dict					   =		middle_blocks[0]
      UpperCAmelCase_	:						Optional[int]					   =		[key for key in resnet_a if "temopral_conv" in key]
      UpperCAmelCase_	:						List[str]					   =		middle_blocks[1]
      UpperCAmelCase_	:						Dict					   =		middle_blocks[2]
      UpperCAmelCase_	:						Dict					   =		middle_blocks[3]
      UpperCAmelCase_	:						Optional[Any]					   =		[key for key in resnet_a if "temopral_conv" in key]

      UpperCAmelCase_	:						Any					   =		renew_resnet_paths(__snake_case     )
      UpperCAmelCase_	:						Union[str, Any]					   =		{"old": "middle_block.0", "new": "mid_block.resnets.0"}
      assign_to_checkpoint(
          __snake_case       ,	__snake_case       ,	__snake_case       ,	config=__snake_case       ,	additional_replacements=[meta_path]     )

      UpperCAmelCase_	:						Optional[Any]					   =		renew_temp_conv_paths(__snake_case     )
      UpperCAmelCase_	:						Any					   =		{"old": "middle_block.0.temopral_conv", "new": "mid_block.temp_convs.0"}
      assign_to_checkpoint(
          __snake_case       ,	__snake_case       ,	__snake_case       ,	config=__snake_case       ,	additional_replacements=[meta_path]     )

      UpperCAmelCase_	:						Union[str, Any]					   =		renew_resnet_paths(__snake_case     )
      UpperCAmelCase_	:						Union[str, Any]					   =		{"old": "middle_block.3", "new": "mid_block.resnets.1"}
      assign_to_checkpoint(
          __snake_case       ,	__snake_case       ,	__snake_case       ,	config=__snake_case       ,	additional_replacements=[meta_path]     )

      UpperCAmelCase_	:						Optional[Any]					   =		renew_temp_conv_paths(__snake_case     )
      UpperCAmelCase_	:						List[Any]					   =		{"old": "middle_block.3.temopral_conv", "new": "mid_block.temp_convs.1"}
      assign_to_checkpoint(
          __snake_case       ,	__snake_case       ,	__snake_case       ,	config=__snake_case       ,	additional_replacements=[meta_path]     )

      UpperCAmelCase_	:						str					   =		renew_attention_paths(__snake_case     )
      UpperCAmelCase_	:						Any					   =		{"old": "middle_block.1", "new": "mid_block.attentions.0"}
      assign_to_checkpoint(
          __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

      UpperCAmelCase_	:						Union[str, Any]					   =		renew_attention_paths(__snake_case     )
      UpperCAmelCase_	:						int					   =		{"old": "middle_block.2", "new": "mid_block.temp_attentions.0"}
      assign_to_checkpoint(
          __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

      for i in range(__snake_case     ):
            UpperCAmelCase_	:						Any					   =		i // (config["layers_per_block"] + 1)
            UpperCAmelCase_	:						Optional[Any]					   =		i % (config["layers_per_block"] + 1)
            UpperCAmelCase_	:						List[str]					   =		[shave_segments(__snake_case       ,	2     ) for name in output_blocks[i]]
            UpperCAmelCase_	:						List[str]					   =		{}

            for layer in output_block_layers:
                  UpperCAmelCase_   ,   UpperCAmelCase_	:						Optional[Any]					   =		layer.split("."     )[0], shave_segments(__snake_case       ,	1     )
                  if layer_id in output_block_list:
                        output_block_list[layer_id].append(__snake_case     )
                  else:
                        UpperCAmelCase_	:						Dict					   =		[layer_name]

            if len(__snake_case     ) > 1:
                  UpperCAmelCase_	:						int					   =		[key for key in output_blocks[i] if F"""output_blocks.{i}.0""" in key]
                  UpperCAmelCase_	:						str					   =		[key for key in output_blocks[i] if F"""output_blocks.{i}.1""" in key]
                  UpperCAmelCase_	:						Union[str, Any]					   =		[key for key in output_blocks[i] if F"""output_blocks.{i}.2""" in key]

                  UpperCAmelCase_	:						Union[str, Any]					   =		renew_resnet_paths(__snake_case     )
                  UpperCAmelCase_	:						Any					   =		renew_resnet_paths(__snake_case     )

                  UpperCAmelCase_	:						Optional[Any]					   =		{"old": F"""output_blocks.{i}.0""", "new": F"""up_blocks.{block_id}.resnets.{layer_in_block_id}"""}
                  assign_to_checkpoint(
                      __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

                  UpperCAmelCase_	:						List[str]					   =		[key for key in resnets if "temopral_conv" in key]
                  UpperCAmelCase_	:						Union[str, Any]					   =		renew_temp_conv_paths(__snake_case     )
                  UpperCAmelCase_	:						Optional[Any]					   =		{
                      "old": F"""output_blocks.{i}.0.temopral_conv""",
                      "new": F"""up_blocks.{block_id}.temp_convs.{layer_in_block_id}""",
                  }
                  assign_to_checkpoint(
                      __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

                  UpperCAmelCase_	:						Dict					   =		{k: sorted(__snake_case     ) for k, v in output_block_list.items()}
                  if ["conv.bias", "conv.weight"] in output_block_list.values():
                        UpperCAmelCase_	:						Union[str, Any]					   =		list(output_block_list.values()     ).index(["conv.bias", "conv.weight"]     )
                        UpperCAmelCase_	:						Dict					   =		unet_state_dict[
                            F"""output_blocks.{i}.{index}.conv.weight"""
                        ]
                        UpperCAmelCase_	:						List[Any]					   =		unet_state_dict[
                            F"""output_blocks.{i}.{index}.conv.bias"""
                        ]

                        # Clear attentions as they have been attributed above.
                        if len(__snake_case     ) == 2:
                              UpperCAmelCase_	:						Union[str, Any]					   =		[]

                  if len(__snake_case     ):
                        UpperCAmelCase_	:						str					   =		renew_attention_paths(__snake_case     )
                        UpperCAmelCase_	:						Optional[int]					   =		{
                            "old": F"""output_blocks.{i}.1""",
                            "new": F"""up_blocks.{block_id}.attentions.{layer_in_block_id}""",
                        }
                        assign_to_checkpoint(
                            __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )

                  if len(__snake_case     ):
                        UpperCAmelCase_	:						str					   =		renew_attention_paths(__snake_case     )
                        UpperCAmelCase_	:						Dict					   =		{
                            "old": F"""output_blocks.{i}.2""",
                            "new": F"""up_blocks.{block_id}.temp_attentions.{layer_in_block_id}""",
                        }
                        assign_to_checkpoint(
                            __snake_case       ,	__snake_case       ,	__snake_case       ,	additional_replacements=[meta_path]       ,	config=__snake_case     )
            else:
                  UpperCAmelCase_	:						Union[str, Any]					   =		renew_resnet_paths(__snake_case       ,	n_shave_prefix_segments=1     )
                  for path in resnet_0_paths:
                        UpperCAmelCase_	:						Tuple					   =		".".join(["output_blocks", str(__snake_case     ), path["old"]]     )
                        UpperCAmelCase_	:						Any					   =		".".join(["up_blocks", str(__snake_case     ), "resnets", str(__snake_case     ), path["new"]]     )
                        UpperCAmelCase_	:						str					   =		unet_state_dict[old_path]

                  UpperCAmelCase_	:						Union[str, Any]					   =		[l for l in output_block_layers if "temopral_conv" in l]
                  for path in temopral_conv_paths:
                        UpperCAmelCase_	:						Optional[int]					   =		path.split("temopral_conv."     )[-1]
                        UpperCAmelCase_	:						Tuple					   =		".".join(["output_blocks", str(__snake_case     ), str(__snake_case     ), "temopral_conv", pruned_path]     )
                        UpperCAmelCase_	:						Optional[Any]					   =		".".join(["up_blocks", str(__snake_case     ), "temp_convs", str(__snake_case     ), pruned_path]     )
                        UpperCAmelCase_	:						Tuple					   =		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 --





import heapq







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case     )  ->  str:






      '''simple docstring'''







      UpperCAmelCase_	:						List[str]					   =		[(0, start)]  # cost from start node,end node
      UpperCAmelCase_	:						List[Any]					   =		set()
      while heap:
            ((UpperCAmelCase_)   ,   (UpperCAmelCase_))	:						str					   =		heapq.heappop(__snake_case     )
            if u in visited:
                  continue
            visited.add(__snake_case     )
            if u == end:
                  return cost
            for v, c in graph[u]:
                  if v in visited:
                        continue
                  UpperCAmelCase_	:						Tuple					   =		cost + c
                  heapq.heappush(__snake_case       ,	(next_item, v)     )
      return -1


__lowerCamelCase								=      {
    '''A''': [['''B''', 2], ['''C''', 5]],
    '''B''': [['''A''', 2], ['''D''', 3], ['''E''', 1], ['''F''', 1]],
    '''C''': [['''A''', 5], ['''F''', 3]],
    '''D''': [['''B''', 3]],
    '''E''': [['''B''', 4], ['''F''', 3]],
    '''F''': [['''C''', 3], ['''E''', 3]],
}
__lowerCamelCase								=      {
    '''B''': [['''C''', 1]],
    '''C''': [['''D''', 1]],
    '''D''': [['''F''', 1]],
    '''E''': [['''B''', 1], ['''F''', 3]],
    '''F''': [],
}
__lowerCamelCase								=      {
    '''B''': [['''C''', 1]],
    '''C''': [['''D''', 1]],
    '''D''': [['''F''', 1]],
    '''E''': [['''B''', 1], ['''G''', 2]],
    '''F''': [],
    '''G''': [['''F''', 1]],
}

__lowerCamelCase								=      dijkstra(G, '''E''', '''C''')
print(short_distance)  # E -- 3 --> F -- 3 --> C == 6

__lowerCamelCase								=      dijkstra(Ga, '''E''', '''F''')
print(short_distance)  # E -- 3 --> F == 3

__lowerCamelCase								=      dijkstra(Ga, '''E''', '''F''')
print(short_distance)  # E -- 2 --> G -- 1 --> F == 3

if __name__ == "__main__":
   import doctest

   doctest.testmod()
