code: def save_graphs(filename, g_list, labels=None, formats=None):
      r"""Save graphs and optionally their labels to file.
  
      Besides saving to local files, DGL supports writing the graphs directly
      to S3 (by providing a ``"s3://..."`` path) or to HDFS (by providing
      ``"hdfs://..."`` a path).
  
      The function saves both the graph structure and node/edge features to file
      in DGL's own binary format. For graph-level features, pass them via
      the :attr:`labels` argument.
  
      Parameters
      ----------
      filename : str
          The file name to store the graphs and labels.
      g_list: list
          The graphs to be saved.
      labels: dict[str, Tensor]
          labels should be dict of tensors, with str as keys
      formats: str or list[str]
          Save graph in specified formats. It could be any combination of
          ``coo``, ``csc`` and ``csr``. If not specified, save one format
          only according to what format is available. If multiple formats
          are available, selection priority from high to low is ``coo``,
          ``csc``, ``csr``.
  
      Examples
      ----------
      >>> import dgl
      >>> import torch as th
  
      Create :class:`DGLGraph` objects and initialize node
      and edge features.
  
      >>> g1 = dgl.graph(([0, 1, 2], [1, 2, 3]))
      >>> g2 = dgl.graph(([0, 2], [2, 3]))
      >>> g2.edata["e"] = th.ones(2, 4)
  
      Save Graphs into file
  
      >>> from dgl.data.utils import save_graphs
      >>> graph_labels = {"glabel": th.tensor([0, 1])}
      >>> save_graphs("./data.bin", [g1, g2], graph_labels)
  
      See Also
      --------
      load_graphs
      """
      # if it is local file, do some sanity check
      if is_local_path(filename):
          if os.path.isdir(filename):
              raise DGLError(
                  "Filename {} is an existing directory.".format(
                      filename
                  )
              )
          f_path = os.path.dirname(filename)
          if f_path and not os.path.exists(f_path):
              os.makedirs(f_path)
      g_sample = g_list[0] if isinstance(g_list, list) else g_list
      if (
          type(g_sample) == DGLGraph
      ):  # Doesn't support DGLGraph's derived class
          save_heterographs(filename, g_list, labels, formats)
      else:
          raise DGLError(
              "Invalid argument g_list. Must be a DGLGraph or a list of DGLGraphs."
          )
  
imports: from __future__ import absolute_import
  import os
  from ..None import backend
  from .._ffi.function import _init_api
  from .._ffi.object import ObjectBase, register_object
  from ..base import dgl_warning, DGLError
  from ..heterograph import DGLGraph
  from .heterograph_serialize import save_heterographs
label_desc: Use image node_id 3 for calling a global function with example usage: save_graphs(filename, g_list, labels, formats) without return types