code: def connectivity(
      umap_object,
      edge_bundling=None,
      edge_cmap="gray_r",
      show_points=False,
      labels=None,
      values=None,
      theme=None,
      cmap="Blues",
      color_key=None,
      color_key_cmap="Spectral",
      background="white",
      width=800,
      height=800,
  ):
      """Plot connectivity relationships of the underlying UMAP
      simplicial set data structure. Internally UMAP will make
      use of what can be viewed as a weighted graph. This graph
      can be plotted using the layout provided by UMAP as a
      potential diagnostic view of the embedding. Currently this only works
      for 2D embeddings. While there are many optional parameters
      to further control and tailor the plotting, you need only
      pass in the trained/fit umap model to get results. This plot
      utility will attempt to do the hard work of avoiding
      over-plotting issues and provide options for plotting the
      points as well as using edge bundling for graph visualization.
  
      Parameters
      ----------
      umap_object: trained UMAP object
          A trained UMAP object that has a 2D embedding.
  
      edge_bundling: string or None (optional, default None)
          The edge bundling method to use. Currently supported
          are None or 'hammer'. See the datashader docs
          on graph visualization for more details.
  
      edge_cmap: string (default 'gray_r')
          The name of a matplotlib colormap to use for shading/
          coloring the edges of the connectivity graph. Note that
          the ``theme``, if specified, will override this.
  
      show_points: bool (optional False)
          Whether to display the points over top of the edge
          connectivity. Further options allow for coloring/
          shading the points accordingly.
  
      labels: array, shape (n_samples,) (optional, default None)
          An array of labels (assumed integer or categorical),
          one for each data sample.
          This will be used for coloring the points in
          the plot according to their label. Note that
          this option is mutually exclusive to the ``values``
          option.
  
      values: array, shape (n_samples,) (optional, default None)
          An array of values (assumed float or continuous),
          one for each sample.
          This will be used for coloring the points in
          the plot according to a colorscale associated
          to the total range of values. Note that this
          option is mutually exclusive to the ``labels``
          option.
  
      theme: string (optional, default None)
          A color theme to use for plotting. A small set of
          predefined themes are provided which have relatively
          good aesthetics. Available themes are:
             * 'blue'
             * 'red'
             * 'green'
             * 'inferno'
             * 'fire'
             * 'viridis'
             * 'darkblue'
             * 'darkred'
             * 'darkgreen'
  
      cmap: string (optional, default 'Blues')
          The name of a matplotlib colormap to use for coloring
          or shading points. If no labels or values are passed
          this will be used for shading points according to
          density (largely only of relevance for very large
          datasets). If values are passed this will be used for
          shading according the value. Note that if theme
          is passed then this value will be overridden by the
          corresponding option of the theme.
  
      color_key: dict or array, shape (n_categories) (optional, default None)
          A way to assign colors to categoricals. This can either be
          an explicit dict mapping labels to colors (as strings of form
          '#RRGGBB'), or an array like object providing one color for
          each distinct category being provided in ``labels``. Either
          way this mapping will be used to color points according to
          the label. Note that if theme
          is passed then this value will be overridden by the
          corresponding option of the theme.
  
      color_key_cmap: string (optional, default 'Spectral')
          The name of a matplotlib colormap to use for categorical coloring.
          If an explicit ``color_key`` is not given a color mapping for
          categories can be generated from the label list and selecting
          a matching list of colors from the given colormap. Note
          that if theme
          is passed then this value will be overridden by the
          corresponding option of the theme.
  
      background: string (optional, default 'white)
          The color of the background. Usually this will be either
          'white' or 'black', but any color name will work. Ideally
          one wants to match this appropriately to the colors being
          used for points etc. This is one of the things that themes
          handle for you. Note that if theme
          is passed then this value will be overridden by the
          corresponding option of the theme.
  
      width: int (optional, default 800)
          The desired width of the plot in pixels.
  
      height: int (optional, default 800)
          The desired height of the plot in pixels
  
      Returns
      -------
      result: matplotlib axis
          The result is a matplotlib axis with the relevant plot displayed.
          If you are using a notebook and have ``%matplotlib inline`` set
          then this will simply display inline.
      """
      if theme is not None:
          cmap = _themes[theme]["cmap"]
          color_key_cmap = _themes[theme]["color_key_cmap"]
          edge_cmap = _themes[theme]["edge_cmap"]
          background = _themes[theme]["background"]
  
      points = _get_embedding(umap_object)
      point_df = pd.DataFrame(points, columns=("x", "y"))
  
      point_size = 100.0 / np.sqrt(points.shape[0])
      if point_size > 1:
          px_size = int(np.round(point_size))
      else:
          px_size = 1
  
      if show_points:
          edge_how = "log"
      else:
          edge_how = "eq_hist"
  
      coo_graph = umap_object.graph_.tocoo()
      edge_df = pd.DataFrame(
          np.vstack([coo_graph.row, coo_graph.col, coo_graph.data]).T,
          columns=("source", "target", "weight"),
      )
      edge_df["source"] = edge_df.source.astype(np.int32)
      edge_df["target"] = edge_df.target.astype(np.int32)
  
      extent = _get_extent(points)
      canvas = ds.Canvas(
          plot_width=width,
          plot_height=height,
          x_range=(extent[0], extent[1]),
          y_range=(extent[2], extent[3]),
      )
  
      if edge_bundling is None:
          edges = bd.directly_connect_edges(
              point_df, edge_df, weight="weight"
          )
      elif edge_bundling == "hammer":
          warn(
              "Hammer edge bundling is expensive for large graphs!\n"
              "This may take a long time to compute!"
          )
          edges = bd.hammer_bundle(point_df, edge_df, weight="weight")
      else:
          raise ValueError(
              "{} is not a recognised bundling method".format(
                  edge_bundling
              )
          )
  
      edge_img = tf.shade(
          canvas.line(edges, "x", "y", agg=ds.sum("weight")),
          cmap=plt.get_cmap(edge_cmap),
          how=edge_how,
      )
      edge_img = tf.set_background(edge_img, background)
  
      if show_points:
          point_img = _datashade_points(
              points,
              None,
              labels,
              values,
              cmap,
              color_key,
              color_key_cmap,
              None,
              width,
              height,
              False,
          )
          if px_size > 1:
              point_img = tf.dynspread(
                  point_img, threshold=0.5, max_px=px_size
              )
          result = tf.stack(edge_img, point_img, how="over")
      else:
          result = edge_img
  
      font_color = _select_font_color(background)
  
      dpi = plt.rcParams["figure.dpi"]
      fig = plt.figure(figsize=(width / dpi, height / dpi))
      ax = fig.add_subplot(111)
  
      _embed_datashader_in_an_axis(result, ax)
  
      ax.set(xticks=[], yticks=[])
      ax.text(
          0.99,
          0.01,
          "UMAP: n_neighbors={}, min_dist={}".format(
              umap_object.n_neighbors, umap_object.min_dist
          ),
          transform=ax.transAxes,
          horizontalalignment="right",
          color=font_color,
      )
  
      return ax
  
imports: import numpy
  import numba
  from warnings import warn
  import sklearn.decomposition
  import sklearn.cluster
  import sklearn.neighbors
  from matplotlib.patches import Patch
  from umap.utils import submatrix, average_nn_distance
  from bokeh.plotting import show
  from bokeh.plotting import output_file, output_notebook
  from bokeh.layouts import column
  from bokeh.models import CustomJS, TextInput
  from matplotlib.pyplot import show
  from warnings import warn
label_desc: Use image node_id 17 for calling a global function with example usage: connectivity(umap_object, edge_bundling, edge_cmap, show_points, labels, values, theme, cmap, color_key, color_key_cmap, background, width, height) and returns: ax