code: def remove_edges(g, eids, etype=None, store_ids=False):
      r"""Remove the specified edges and return a new graph.
  
      Also delete the features of the edges. The edges must exist in the graph.
      The resulting graph has the same number of the nodes as the input one,
      even if some nodes become isolated after the the edge removal.
  
      Parameters
      ----------
      eids : int, Tensor, iterable[int]
          The IDs of the edges to remove.
      etype : str or (str, str, str), optional
          The type names of the edges. The allowed type name formats are:
  
          * ``(str, str, str)`` for source node type, edge type and destination node type.
          * or one ``str`` edge type name if the name can uniquely identify a
            triplet format in the graph.
  
          Can be omitted if the graph has only one type of edges.
      store_ids : bool, optional
          If True, it will store the raw IDs of the extracted nodes and edges in the ``ndata``
          and ``edata`` of the resulting graph under name ``dgl.NID`` and ``dgl.EID``,
          respectively.
  
      Return
      ------
      DGLGraph
          The graph with edges deleted.
  
      Notes
      -----
      This function preserves the batch information.
  
      Examples
      --------
      >>> import dgl
      >>> import torch
  
      **Homogeneous Graphs**
  
      >>> g = dgl.graph((torch.tensor([0, 0, 2]), torch.tensor([0, 1, 2])))
      >>> g.edata['he'] = torch.arange(3).float().reshape(-1, 1)
      >>> g = dgl.remove_edges(g, torch.tensor([0, 1]))
      >>> g
      Graph(num_nodes=3, num_edges=1,
          ndata_schemes={}
          edata_schemes={'he': Scheme(shape=(1,), dtype=torch.float32)})
      >>> g.edges('all')
      (tensor([2]), tensor([2]), tensor([0]))
      >>> g.edata['he']
      tensor([[2.]])
  
      **Heterogeneous Graphs**
  
      >>> g = dgl.heterograph({
      ...     ('user', 'plays', 'game'): (torch.tensor([0, 1, 1, 2]),
      ...                                 torch.tensor([0, 0, 1, 1])),
      ...     ('developer', 'develops', 'game'): (torch.tensor([0, 1]),
      ...                                         torch.tensor([0, 1]))
      ...     })
      >>> g = dgl.remove_edges(g, torch.tensor([0, 1]), 'plays')
      >>> g.edges('all', etype='plays')
      (tensor([1, 2]), tensor([1, 1]), tensor([0, 1]))
  
      See Also
      --------
      add_nodes
      add_edges
      remove_nodes
      """
      g = g.clone()
      g.remove_edges(eids, etype=etype, store_ids=store_ids)
      return g
  
imports: import copy
  from collections.abc import Iterable, Mapping
  import numpy
  import scipy.sparse
  import scipy.sparse.linalg
  from ..utils import version
  from ..None import backend, batch, convert, function, ndarray, subgraph, utils
  from .._ffi.function import _init_api
  from ..base import dgl_warning, DGLError, EID, NID
  from ..frame import Frame
  from ..heterograph import DGLGraph
  from ..heterograph_index import create_heterograph_from_relations, create_metagraph_index
  from ..partition import metis_partition, metis_partition_assignment, partition_graph_with_halo
  from ..sampling.neighbor import sample_neighbors
label_desc: Use image node_id 19 for calling a global function with example usage: remove_edges(g, eids, etype, store_ids) and returns: g