code: def get_data(self, element, ranges, style):
      # Force static source to False
      static = self.static_source
      self.handles["static_source"] = static
      self.static_source = False
  
      # Get node data
      nodes = element.nodes.dimension_values(2)
      node_positions = element.nodes.array([0, 1])
      # Map node indices to integers
      if nodes.dtype.kind not in "uif":
          node_indices = {v: i for i, v in enumerate(nodes)}
          index = np.array(
              [node_indices[n] for n in nodes], dtype=np.int32
          )
          layout = {
              node_indices[k]: (y, x) if self.invert_axes else (x, y)
              for k, (x, y) in zip(nodes, node_positions)
          }
      else:
          index = nodes.astype(np.int32)
          layout = {
              k: (y, x) if self.invert_axes else (x, y)
              for k, (x, y) in zip(index, node_positions)
          }
  
      point_data = {"index": index}
  
      # Handle node colors
      fixed_color = style.pop("node_color", None)
      cycle = self.lookup_options(element, "style").kwargs.get(
          "node_color"
      )
      if isinstance(cycle, Cycle) and "cmap" not in style:
          colors = cycle
      else:
          colors = None
      cdata, cmapping = self._get_color_data(
          element.nodes,
          ranges,
          style,
          name="node_fill_color",
          colors=colors,
          int_categories=True,
      )
      if fixed_color is not None and not cdata:
          style["node_color"] = fixed_color
      point_data.update(cdata)
      point_mapping = cmapping
      if "node_fill_color" in point_mapping:
          style = {
              k: v
              for k, v in style.items()
              if k
              not in ["node_fill_color", "node_nonselection_fill_color"]
          }
          point_mapping["node_nonselection_fill_color"] = point_mapping[
              "node_fill_color"
          ]
  
      # Handle edge colors
      edge_mapping = {}
      nan_node = index.max() + 1 if len(index) else 0
      start, end = (element.dimension_values(i) for i in range(2))
      if nodes.dtype.kind == "f":
          start, end = start.astype(np.int32), end.astype(np.int32)
      elif nodes.dtype.kind not in "ui":
          start = np.array(
              [node_indices.get(x, nan_node) for x in start],
              dtype=np.int32,
          )
          end = np.array(
              [node_indices.get(y, nan_node) for y in end],
              dtype=np.int32,
          )
      path_data = dict(start=start, end=end)
      self._get_edge_colors(
          element, ranges, path_data, edge_mapping, style
      )
      if not static:
          pdata, pmapping = self._get_edge_paths(element, ranges)
          path_data.update(pdata)
          edge_mapping.update(pmapping)
  
      # Get hover data
      if "hover" in self.handles:
          if self.inspection_policy == "nodes":
              index_dim = element.nodes.get_dimension(2)
              point_data["index_hover"] = [
                  index_dim.pprint_value(v)
                  for v in element.nodes.dimension_values(2)
              ]
              for d in element.nodes.dimensions()[3:]:
                  point_data[
                      dimension_sanitizer(d.name)
                  ] = element.nodes.dimension_values(d)
          elif self.inspection_policy == "edges":
              for d in element.dimensions():
                  dim_name = dimension_sanitizer(d.name)
                  if dim_name in ("start", "end"):
                      dim_name += "_values"
                  path_data[dim_name] = element.dimension_values(d)
      data = {
          "scatter_1": point_data,
          self.edge_glyph: path_data,
          "layout": layout,
      }
      mapping = {
          "scatter_1": point_mapping,
          self.edge_glyph: edge_mapping,
      }
      return data, mapping, style
  
imports: from collections import defaultdict
  import numpy
  import param
  from bokeh.models import Bezier, ColumnDataSource, EdgesAndLinkedNodes, NodesAndLinkedEdges, NodesOnly, Patches, StaticLayoutProvider
  from ...core.data import Dataset
  from ...core.options import Cycle, abbreviated_exception
  from ...core.util import dimension_sanitizer, unique_array
  from ...util.transform import dim
  from ..mixins import ChordMixin, GraphMixin
  from ..util import get_directed_graph_paths, process_cmap
  from .chart import ColorbarPlot, PointPlot
  from .element import CompositeElementPlot, LegendPlot
  from .styles import base_properties, fill_properties, line_properties, rgba_tuple, text_properties
label_desc: Use image node_id 5 for calling the GraphPlot obj's underlying member method code with example usage: obj.get_data(element, ranges, style) and returns: data,  mapping,  style