code: def _make_plc_graph(
      sID,
      edata_x,
      graph_props,
      src_col_name,
      dst_col_name,
      store_transposed,
      vertex_type,
      weight_type,
      edge_id_type,
      edge_type_id,
  ):
      weights = None
      edge_ids = None
      edge_types = None
  
      num_arrays = len(edata_x)
      if weight_type is not None:
          weights = [
              edata_x[i][simpleDistributedGraphImpl.edgeWeightCol]
              for i in range(num_arrays)
          ]
          if weight_type == "int32":
              weights = [
                  w_array.astype("float32") for w_array in weights
              ]
          elif weight_type == "int64":
              weights = [
                  w_array.astype("float64") for w_array in weights
              ]
  
      if edge_id_type is not None:
          edge_ids = [
              edata_x[i][simpleDistributedGraphImpl.edgeIdCol]
              for i in range(num_arrays)
          ]
          if vertex_type == "int64" and edge_id_type != "int64":
              edge_ids = [
                  e_id_array.astype("int64") for e_id_array in edge_ids
              ]
              warnings.warn(
                  f"Vertex type is int64 but edge id type is {edge_ids[0].dtype}"
                  ", automatically casting edge id type to int64. "
                  "This may cause extra memory usage.  Consider passing"
                  " a int64 list of edge ids instead."
              )
      if edge_type_id is not None:
          edge_types = [
              edata_x[i][simpleDistributedGraphImpl.edgeTypeCol]
              for i in range(num_arrays)
          ]
  
      src_array = [edata_x[i][src_col_name] for i in range(num_arrays)]
      dst_array = [edata_x[i][dst_col_name] for i in range(num_arrays)]
      plc_graph = MGGraph(
          resource_handle=ResourceHandle(
              Comms.get_handle(sID).getHandle()
          ),
          graph_properties=graph_props,
          src_array=src_array
          if src_array
          else cudf.Series(dtype=vertex_type),
          dst_array=dst_array
          if dst_array
          else cudf.Series(dtype=vertex_type),
          weight_array=weights
          if weights
          else (
              [cudf.Series(dtype=weight_type)] if weight_type else None
          ),
          edge_id_array=edge_ids
          if edge_ids
          else (
              [cudf.Series(dtype=edge_id_type)]
              if edge_id_type
              else None
          ),
          edge_type_array=edge_types
          if edge_types
          else (
              [cudf.Series(dtype=edge_type_id)]
              if edge_type_id
              else None
          ),
          num_arrays=num_arrays,
          store_transposed=store_transposed,
          do_expensive_check=False,
      )
      del edata_x
      gc.collect()
  
      return plc_graph
  
imports: import gc
  from typing import Union
  import warnings
  import cudf
  import cupy
  import dask
  import dask_cudf
  from dask import delayed
  from dask.distributed import wait, default_client
  import numpy
  from pylibcugraph import MGGraph, ResourceHandle, GraphProperties, get_two_hop_neighbors, select_random_vertices
  from cugraph.structure import graph_primtypes_wrapper
  from cugraph.structure.graph_primtypes_wrapper import Direction
  from cugraph.structure.number_map import NumberMap
  from cugraph.structure.symmetrize import symmetrize
  from cugraph.dask.common.part_utils import get_persisted_df_worker_map, persist_dask_df_equal_parts_per_worker
  from cugraph.dask.common.mg_utils import run_gc_on_dask_cluster
  from cugraph.dask import get_n_workers
  import cugraph.dask.comms.comms
label_desc: Use image node_id 2 for calling the simpleDistributedGraphImpl obj's underlying member method code with example usage: obj._make_plc_graph(sID, edata_x, graph_props, src_col_name, dst_col_name, store_transposed, vertex_type, weight_type, edge_id_type, edge_type_id) and returns: plc_graph