code: def networkxbipartite2tensors(
      nx_graph, idtype, top_map, bottom_map, edge_id_attr_name=None
  ):
      """Function to convert a networkx bipartite to edge tensors.
  
      Parameters
      ----------
      nx_graph : nx.Graph
          NetworkX graph. It must follow the bipartite graph convention of networkx.
          Each node has an attribute ``bipartite`` with values 0 and 1 indicating
          which set it belongs to.
      top_map : dict
          The dictionary mapping the original node labels to the node IDs for the source type.
      bottom_map : dict
          The dictionary mapping the original node labels to the node IDs for the destination type.
      idtype : int32, int64, optional
          Integer ID type. Must be int32 or int64.
      edge_id_attr_name : str, optional
          Key name for edge ids in the NetworkX graph. If not found, we
          will consider the graph not to have pre-specified edge ids. (Default: None)
  
      Returns
      -------
      (Tensor, Tensor)
          Edge tensors.
      """
      has_edge_id = edge_id_attr_name is not None
  
      if has_edge_id:
          num_edges = nx_graph.number_of_edges()
          src = [0] * num_edges
          dst = [0] * num_edges
          for u, v, attr in nx_graph.edges(data=True):
              if u not in top_map:
                  raise DGLError(
                      "Expect the node {} to have attribute bipartite=0 "
                      "with edge {}".format(u, (u, v))
                  )
              if v not in bottom_map:
                  raise DGLError(
                      "Expect the node {} to have attribute bipartite=1 "
                      "with edge {}".format(v, (u, v))
                  )
              eid = int(attr[edge_id_attr_name])
              if eid < 0 or eid >= nx_graph.number_of_edges():
                  raise DGLError(
                      "Expect edge IDs to be a non-negative integer smaller than {:d}, "
                      "got {:d}".format(num_edges, eid)
                  )
              src[eid] = top_map[u]
              dst[eid] = bottom_map[v]
      else:
          src = []
          dst = []
          for e in nx_graph.edges:
              u, v = e[0], e[1]
              if u not in top_map:
                  raise DGLError(
                      "Expect the node {} to have attribute bipartite=0 "
                      "with edge {}".format(u, (u, v))
                  )
              if v not in bottom_map:
                  raise DGLError(
                      "Expect the node {} to have attribute bipartite=1 "
                      "with edge {}".format(v, (u, v))
                  )
              src.append(top_map[u])
              dst.append(bottom_map[v])
      src = F.tensor(src, dtype=idtype)
      dst = F.tensor(dst, dtype=idtype)
      return src, dst
  
file_path: dgl/python/dgl/utils/data.py
imports: from collections import namedtuple
  import networkx
  import scipy
  from ..None import backend
  from ..base import DGLError
  from .None import checks
label_desc: Use image node_id 5 for calling a global function with example usage: networkxbipartite2tensors(nx_graph, idtype, top_map, bottom_map, edge_id_attr_name) and returns: src,  dst