code: def gen_edge_files(rank, schema_map, params):
      """Function to create edges files to be consumed by ParMETIS
      for partitioning purposes.
  
      This function creates the edge files and each of these will have the
      following format (meaning each line of these file is of the following format)
      <global_src_id> <global_dst_id>
  
      Here ``global`` prefix means that globally unique identifier assigned each node
      in the input graph. In this context globally unique means unique across all the
      nodes in the input graph.
  
      Parameters:
      -----------
      rank : int
          rank of the current process
      schema_map : json dictionary
          Dictionary created by reading the metadata.json file for the input dataset.
      output : string
          Location of storing the node-weights and edge files for ParMETIS.
      """
      _, ntype_gnid_offset = get_idranges(
          schema_map[constants.STR_NODE_TYPE],
          dict(
              zip(
                  schema_map[constants.STR_NODE_TYPE],
                  schema_map[constants.STR_NUM_NODES_PER_TYPE],
              )
          ),
      )
  
      # Regenerate edge files here.
      edge_data = schema_map[constants.STR_EDGES]
  
      outdir = Path(params.output_dir)
      os.makedirs(outdir, exist_ok=True)
  
      def process_and_write_back(data_df, idx):
          data_f0 = data_df[:, 0]
          data_f1 = data_df[:, 1]
  
          global_src_id = (
              data_f0 + ntype_gnid_offset[src_ntype_name][0, 0]
          )
          global_dst_id = (
              data_f1 + ntype_gnid_offset[dst_ntype_name][0, 0]
          )
          cols = [global_src_id, global_dst_id]
          col_names = ["global_src_id", "global_dst_id"]
  
          out_file_name = Path(edge_data_files[idx]).stem.split(".")[0]
          out_file = os.path.join(
              outdir, etype_name, f"edges_{out_file_name}.csv"
          )
          os.makedirs(os.path.dirname(out_file), exist_ok=True)
  
          options = csv.WriteOptions(
              include_header=False, delimiter=" "
          )
          csv.write_csv(
              pyarrow.Table.from_arrays(cols, names=col_names),
              out_file,
              options,
          )
          return out_file
  
      edge_files = []
      for etype_name, etype_info in edge_data.items():
          edge_data_files = etype_info[constants.STR_DATA]
  
          # ``edgetype`` strings are in canonical format, src_node_type:edge_type:dst_node_type
          tokens = etype_name.split(":")
          assert len(tokens) == 3
  
          src_ntype_name = tokens[0]
  
          dst_ntype_name = tokens[2]
  
          rank_assignments = generate_roundrobin_read_list(
              len(edge_data_files), params.num_parts
          )
          for file_idx in rank_assignments[rank]:
              reader_fmt_meta = {
                  "name": etype_info[constants.STR_FORMAT][
                      constants.STR_NAME
                  ],
              }
              if reader_fmt_meta["name"] == constants.STR_CSV:
                  reader_fmt_meta["delimiter"] = etype_info[
                      constants.STR_FORMAT
                  ][constants.STR_FORMAT_DELIMITER]
              data_df = array_readwriter.get_array_parser(
                  **reader_fmt_meta
              ).read(
                  os.path.join(
                      params.input_dir, edge_data_files[file_idx]
                  )
              )
              out_file = process_and_write_back(data_df, file_idx)
              edge_files.append(out_file)
  
      return edge_files
  
file_path: dgl/tools/distpartitioning/parmetis_preprocess.py
imports: import argparse
  import logging
  import os
  import platform
  from pathlib import Path
  import array_readwriter
  import constants
  import numpy
  import pyarrow
  import pyarrow.csv
  from utils import generate_read_list, generate_roundrobin_read_list, get_idranges, get_node_types, read_json
label_desc: Use image node_id 3 for calling a global function with example usage: gen_edge_files(rank, schema_map, params) and returns: edge_files, out_file