code: def symmetrize(
      input_df,
      source_col_name,
      dest_col_name,
      value_col_name=None,
      multi=False,
      symmetrize=True,
  ):
      """
      Take a dataframe of source destination pairs along with associated
      values stored in a single GPU or distributed
      create a COO set of source destination pairs along with values where
      all edges exist in both directions.
  
      Return from this call will be a COO stored as two/three cudf/dask_cudf
      Series/Dataframe -the symmetrized source column and the symmetrized dest
      column, along with an optional cudf/dask_cudf Series/DataFrame containing
      the associated values (only if the values are passed in).
  
      Parameters
      ----------
      input_df : cudf.DataFrame or dask_cudf.DataFrame
          The edgelist as a cudf.DataFrame or dask_cudf.DataFrame
  
      source_col_name : str or list
          source column name.
  
      dest_col_name : str or list
          destination column name.
  
      value_col_name : str or None
          weights column name.
  
      multi : bool, optional (default=False)
          Set to True if graph is a Multi(Di)Graph. This allows multiple
          edges instead of dropping them.
  
      symmetrize : bool, optional
          Default is True to perform symmetrization. If False only duplicate
          edges are dropped.
  
  
      Examples
      --------
      >>> from cugraph.structure.symmetrize import symmetrize
      >>> # Download dataset from https://github.com/rapidsai/cugraph/datasets/..
      >>> M = cudf.read_csv(datasets_path / 'karate.csv', delimiter=' ',
      ...                   dtype=['int32', 'int32', 'float32'], header=None)
      >>> df = cudf.DataFrame()
      >>> df['sources'] = cudf.Series(M['0'])
      >>> df['destinations'] = cudf.Series(M['1'])
      >>> df['values'] = cudf.Series(M['2'])
      >>> src, dst, val = symmetrize(df, 'sources', 'destinations', 'values')
  
      """
  
      # FIXME: Redundant check that should be done at the graph creation
      if "edge_id" in input_df.columns and symmetrize:
          raise ValueError(
              "Edge IDs are not supported on undirected graphs"
          )
  
      csg.null_check(input_df[source_col_name])
      csg.null_check(input_df[dest_col_name])
  
      if isinstance(input_df, dask_cudf.DataFrame):
          output_df = symmetrize_ddf(
              input_df,
              source_col_name,
              dest_col_name,
              value_col_name,
              multi,
              symmetrize,
          )
      else:
          output_df = symmetrize_df(
              input_df,
              source_col_name,
              dest_col_name,
              value_col_name,
              multi,
              symmetrize,
          )
      if value_col_name is not None:
          value_col = output_df[value_col_name]
          if isinstance(value_col, (cudf.Series, dask_cudf.Series)):
              return (
                  output_df[source_col_name],
                  output_df[dest_col_name],
                  output_df[value_col_name],
              )
          elif isinstance(
              value_col, (cudf.DataFrame, dask_cudf.DataFrame)
          ):
              return (
                  output_df[source_col_name],
                  output_df[dest_col_name],
                  output_df[value_col.columns],
              )
  
      return output_df[source_col_name], output_df[dest_col_name]
  
file_path: cugraph/python/cugraph/cugraph/structure/symmetrize.py
imports: from cugraph.structure import graph_classes
  import cudf
  import dask_cudf
  from dask.distributed import default_client
label_desc: Use image node_id 3 for calling a global function with example usage: symmetrize(input_df, source_col_name, dest_col_name, value_col_name, multi, symmetrize) and returns: output_df,  output_df, output_df,  output_df,  output_df, output_df,  output_df,  output_df