code: def infer_num_nodes(data, bipartite=False):
      """Function for inferring the number of nodes.
  
      Parameters
      ----------
      data : graph data
          Supported types are:
  
          * SparseTuple ``(sparse_fmt, arrays)`` where ``arrays`` can be either ``(src, dst)`` or
            ``(indptr, indices, data)``.
          * SciPy matrix.
          * NetworkX graph.
      bipartite : bool, optional
          Whether infer number of nodes of a bipartite graph --
          num_src and num_dst can be different.
  
      Returns
      -------
      num_src : int
          Number of source nodes.
      num_dst : int
          Number of destination nodes.
  
      or
  
      None
          If the inference failed.
      """
      if isinstance(data, tuple) and len(data) == 2:
          if not isinstance(data[0], str):
              raise TypeError(
                  "Expected sparse format as a str, but got %s"
                  % type(data[0])
              )
  
          if data[0] == "coo":
              # ('coo', (src, dst)) format
              u, v = data[1]
              nsrc = (
                  F.as_scalar(F.max(u, dim=0)) + 1 if len(u) > 0 else 0
              )
              ndst = (
                  F.as_scalar(F.max(v, dim=0)) + 1 if len(v) > 0 else 0
              )
          elif data[0] == "csr":
              # ('csr', (indptr, indices, eids)) format
              indptr, indices, _ = data[1]
              nsrc = F.shape(indptr)[0] - 1
              ndst = (
                  F.as_scalar(F.max(indices, dim=0)) + 1
                  if len(indices) > 0
                  else 0
              )
          elif data[0] == "csc":
              # ('csc', (indptr, indices, eids)) format
              indptr, indices, _ = data[1]
              ndst = F.shape(indptr)[0] - 1
              nsrc = (
                  F.as_scalar(F.max(indices, dim=0)) + 1
                  if len(indices) > 0
                  else 0
              )
          else:
              raise ValueError("unknown format %s" % data[0])
      elif isinstance(data, sp.sparse.spmatrix):
          nsrc, ndst = data.shape[0], data.shape[1]
      elif isinstance(data, nx.Graph):
          if data.number_of_nodes() == 0:
              nsrc = ndst = 0
          elif not bipartite:
              nsrc = ndst = data.number_of_nodes()
          else:
              nsrc = len(
                  {
                      n
                      for n, d in data.nodes(data=True)
                      if d["bipartite"] == 0
                  }
              )
              ndst = data.number_of_nodes() - nsrc
      else:
          return None
      if not bipartite:
          nsrc = ndst = max(nsrc, ndst)
      return nsrc, ndst
  
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 6 for calling a global function with example usage: infer_num_nodes(data, bipartite) and returns: nsrc,  ndst, None