code: def verify_graph_feats(
      g, gpb, part, node_feats, edge_feats, orig_nids, orig_eids
  ):
      """Verify the node/edge features of the partitioned graph with
      the original graph
  
      Parameters:
      -----------
      g : DGL Graph Object
          of the original graph
      gpb : global partition book
          created for the partitioned graph object
      node_feats : dictionary
          with key, value pairs as node-types and features as numpy arrays
      edge_feats : dictionary
          with key, value pairs as edge-types and features as numpy arrays
      orig_nids : dictionary
          with key, value pairs as node-types and (global) nids from the
          original graph
      orig_eids : dictionary
          with key, value pairs as edge-types and (global) eids from the
          original graph
      """
      for ntype in g.ntypes:
          ntype_id = g.get_ntype_id(ntype)
          inner_node_mask = _get_inner_node_mask(part, ntype_id)
          inner_nids = part.ndata[dgl.NID][inner_node_mask]
          ntype_ids, inner_type_nids = gpb.map_to_per_ntype(inner_nids)
          partid = gpb.nid2partid(inner_type_nids, ntype)
          assert np.all(ntype_ids.numpy() == ntype_id)
          assert np.all(partid.numpy() == gpb.partid)
  
          orig_id = orig_nids[ntype][inner_type_nids]
          local_nids = gpb.nid2localnid(
              inner_type_nids, gpb.partid, ntype
          )
  
          for name in g.nodes[ntype].data:
              if name in [dgl.NID, "inner_node"]:
                  continue
              true_feats = g.nodes[ntype].data[name][orig_id]
              ndata = node_feats[ntype + "/" + name][local_nids]
              assert np.array_equal(ndata.numpy(), true_feats.numpy())
  
      for etype in g.canonical_etypes:
          etype_id = g.get_etype_id(etype)
          inner_edge_mask = _get_inner_edge_mask(part, etype_id)
          inner_eids = part.edata[dgl.EID][inner_edge_mask]
          etype_ids, inner_type_eids = gpb.map_to_per_etype(inner_eids)
          partid = gpb.eid2partid(inner_type_eids, etype)
          assert np.all(etype_ids.numpy() == etype_id)
          assert np.all(partid.numpy() == gpb.partid)
  
          orig_id = orig_eids[_etype_tuple_to_str(etype)][
              inner_type_eids
          ]
          local_eids = gpb.eid2localeid(
              inner_type_eids, gpb.partid, etype
          )
  
          for name in g.edges[etype].data:
              if name in [dgl.EID, "inner_edge"]:
                  continue
              true_feats = g.edges[etype].data[name][orig_id]
              edata = edge_feats[
                  _etype_tuple_to_str(etype) + "/" + name
              ][local_eids]
              assert np.array_equal(edata.numpy(), true_feats.numpy())
  
file_path: dgl/tools/verification_utils.py
imports: import json
  import os
  import constants
  import dgl
  import numpy
  import pyarrow
  import pyarrow.parquet
  import pytest
  import torch
  from dgl.data.utils import load_tensors
  from dgl.distributed.partition import _etype_str_to_tuple, _etype_tuple_to_str, _get_inner_edge_mask, _get_inner_node_mask, RESERVED_FIELD_DTYPE
  from distpartitioning.utils import get_idranges
label_desc: Use image node_id 4 for calling a global function with example usage: verify_graph_feats(g, gpb, part, node_feats, edge_feats, orig_nids, orig_eids) without return types