code: def from_edgelist(
      df,
      source="source",
      destination="destination",
      edge_attr=None,
      create_using=Graph,
      renumber=True,
  ):
      """
      Return a new graph created from the edge list representaion.
  
      Parameters
      ----------
      df : cudf.DataFrame, pandas.DataFrame, dask_cudf.core.DataFrame
          This DataFrame contains columns storing edge source vertices,
          destination (or target following NetworkX's terminology) vertices, and
          (optional) weights.
  
      source : string or integer, optional (default='source')
          This is used to index the source column.
  
      destination : string or integer, optional (default='destination')
          This is used to index the destination (or target following NetworkX's
          terminology) column.
  
      edge_attr : string or integer, optional (default=None)
          This pointer can be ``None``. If not, this is used to index the weight
          column.
  
      create_using: cugraph.Graph (instance or class), optional (default=Graph)
          Specify the type of Graph to create. Can pass in an instance to create
          a Graph instance with specified 'directed' attribute.
  
      renumber : bool, optional (default=True)
          If source and destination indices are not in range 0 to V where V
          is number of vertices, renumber argument should be True.
  
      Examples
      --------
      >>> M = cudf.read_csv(datasets_path / 'karate.csv', delimiter=' ',
      ...                   dtype=['int32', 'int32', 'float32'], header=None)
      >>> G = cugraph.Graph()
      >>> G = cugraph.from_edgelist(M, source='0', destination='1',
      ...                           edge_attr='2')
  
      """
      df_type = type(df)
  
      if df_type is cudf.DataFrame:
          return from_cudf_edgelist(
              df,
              source,
              destination,
              edge_attr=edge_attr,
              create_using=create_using,
              renumber=renumber,
          )
  
      elif (pd is not None) and (df_type is pd.DataFrame):
          return from_pandas_edgelist(
              df,
              source,
              destination,
              edge_attr=edge_attr,
              create_using=create_using,
              renumber=renumber,
          )
  
      elif df_type is dask_cudf.core.DataFrame:
          if create_using is None:
              G = Graph()
          elif isinstance(create_using, Graph):
              attrs = {"directed": create_using.is_directed()}
              G = type(create_using)(**attrs)
          elif type(create_using) is type(Graph):
              G = create_using()
          else:
              raise TypeError(
                  "create_using must be a cugraph.Graph "
                  "(or subclass) type or instance, got: "
                  f"{type(create_using)}"
              )
          G.from_dask_cudf_edgelist(
              df,
              source,
              destination,
              edge_attr=edge_attr,
              renumber=renumber,
          )
          return G
  
      else:
          raise TypeError(f"obj of type {df_type} is not supported.")
  
file_path: cugraph/python/cugraph/cugraph/structure/convert_matrix.py
imports: import cudf
  import dask_cudf
  from cugraph.structure.graph_classes import Graph
label_desc: Use image node_id 1 for calling a global function with example usage: from_edgelist(df, source, destination, edge_attr, create_using, renumber) and returns: from_cudf_edgelist, from_pandas_edgelist, G