code: def write_metadata_json(
      input_list, output_dir, graph_name, world_size, num_parts
  ):
      """
      Merge json schema's from each of the rank's on rank-0.
      This utility function, to be used on rank-0, to create aggregated json file.
  
      Parameters:
      -----------
      metadata_list : list of json (dictionaries)
          a list of json dictionaries to merge on rank-0
      output_dir : string
          output directory path in which results are stored (as a json file)
      graph-name : string
          a string specifying the graph name
      """
      # Preprocess the input_list, a list of dictionaries
      # each dictionary will contain num_parts/world_size metadata json
      # which correspond to local partitions on the respective ranks.
      metadata_list = []
      for local_part_id in range(num_parts // world_size):
          for idx in range(world_size):
              metadata_list.append(
                  input_list[idx][
                      "local-part-id-"
                      + str(local_part_id * world_size + idx)
                  ]
              )
  
      # Initialize global metadata
      graph_metadata = {}
  
      # Merge global_edge_ids from each json object in the input list
      edge_map = {}
      x = metadata_list[0]["edge_map"]
      for k in x:
          edge_map[k] = []
          for idx in range(len(metadata_list)):
              edge_map[k].append(
                  [
                      int(metadata_list[idx]["edge_map"][k][0][0]),
                      int(metadata_list[idx]["edge_map"][k][0][1]),
                  ]
              )
      graph_metadata["edge_map"] = edge_map
  
      graph_metadata["etypes"] = metadata_list[0]["etypes"]
      graph_metadata["graph_name"] = metadata_list[0]["graph_name"]
      graph_metadata["halo_hops"] = metadata_list[0]["halo_hops"]
  
      # Merge global_nodeids from each of json object in the input list
      node_map = {}
      x = metadata_list[0]["node_map"]
      for k in x:
          node_map[k] = []
          for idx in range(len(metadata_list)):
              node_map[k].append(
                  [
                      int(metadata_list[idx]["node_map"][k][0][0]),
                      int(metadata_list[idx]["node_map"][k][0][1]),
                  ]
              )
      graph_metadata["node_map"] = node_map
  
      graph_metadata["ntypes"] = metadata_list[0]["ntypes"]
      graph_metadata["num_edges"] = int(
          sum(
              [
                  metadata_list[i]["num_edges"]
                  for i in range(len(metadata_list))
              ]
          )
      )
      graph_metadata["num_nodes"] = int(
          sum(
              [
                  metadata_list[i]["num_nodes"]
                  for i in range(len(metadata_list))
              ]
          )
      )
      graph_metadata["num_parts"] = metadata_list[0]["num_parts"]
      graph_metadata["part_method"] = metadata_list[0]["part_method"]
  
      for i in range(len(metadata_list)):
          graph_metadata["part-{}".format(i)] = metadata_list[i][
              "part-{}".format(i)
          ]
  
      _dump_part_config(f"{output_dir}/metadata.json", graph_metadata)
  
imports: import json
  import logging
  import os
  from itertools import cycle
  import constants
  import dgl
  import numpy
  import psutil
  import pyarrow
  import torch
  from dgl.distributed.partition import _dump_part_config
  from pyarrow import csv
label_desc: Use image node_id 9 for calling a global function with example usage: write_metadata_json(input_list, output_dir, graph_name, world_size, num_parts) without return types