code: def points(
      umap_object,
      points=None,
      labels=None,
      values=None,
      theme=None,
      cmap="Blues",
      color_key=None,
      color_key_cmap="Spectral",
      background="white",
      width=800,
      height=800,
      show_legend=True,
      subset_points=None,
      ax=None,
      alpha=None,
  ):
      """Plot an embedding as points. 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 make it easy to automatically
      colour points by a categorical labelling or numeric values.
  
      This method is intended to be used within a Jupyter
      notebook with ``%matplotlib inline``.
  
      Parameters
      ----------
      umap_object: trained UMAP object
          A trained UMAP object that has a 2D embedding.
  
      points: array, shape (n_samples, dim) (optional, default None)
          An array of points to be plotted. Usually this is None
          and so the original embedding points of the umap_object
          are used. However points can be passed explicitly instead
          which is useful for points manually transformed.
  
      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
  
      show_legend: bool (optional, default True)
          Whether to display a legend of the labels
  
      subset_points: array, shape (n_samples,) (optional, default None)
          A way to select a subset of points based on an array of boolean
          values.
  
      ax: matplotlib axis (optional, default None)
          The matplotlib axis to draw the plot to, or if None, which is
          the default, a new axis will be created and returned.
  
      alpha: float (optional, default: None)
          The alpha blending value, between 0 (transparent) and 1 (opaque).
  
      Returns
      -------
      result: matplotlib axis
          The result is a matplotlib axis with the relevant plot displayed.
          If you are using a notebooks and have ``%matplotlib inline`` set
          then this will simply display inline.
      """
      # if not hasattr(umap_object, "embedding_"):
      #     raise ValueError(
      #         "UMAP object must perform fit on data before it can be visualized"
      #     )
  
      if theme is not None:
          cmap = _themes[theme]["cmap"]
          color_key_cmap = _themes[theme]["color_key_cmap"]
          background = _themes[theme]["background"]
  
      if labels is not None and values is not None:
          raise ValueError(
              "Conflicting options; only one of labels or values should be set"
          )
  
      if alpha is not None:
          if not 0.0 <= alpha <= 1.0:
              raise ValueError(
                  "Alpha must be between 0 and 1 inclusive"
              )
  
      if points is None:
          points = _get_embedding(umap_object)
  
      if subset_points is not None:
          if len(subset_points) != points.shape[0]:
              raise ValueError(
                  "Size of subset points ({}) does not match number of input points ({})".format(
                      len(subset_points), points.shape[0]
                  )
              )
          points = points[subset_points]
  
          if labels is not None:
              labels = labels[subset_points]
          if values is not None:
              values = values[subset_points]
  
      if points.shape[1] != 2:
          raise ValueError(
              "Plotting is currently only implemented for 2D embeddings"
          )
  
      font_color = _select_font_color(background)
  
      if ax is None:
          dpi = plt.rcParams["figure.dpi"]
          fig = plt.figure(figsize=(width / dpi, height / dpi))
          ax = fig.add_subplot(111)
  
      if points.shape[0] <= width * height // 10:
          ax = _matplotlib_points(
              points,
              ax,
              labels,
              values,
              cmap,
              color_key,
              color_key_cmap,
              background,
              width,
              height,
              show_legend,
              alpha,
          )
      else:
          # Datashader uses 0-255 as the range for alpha, with 255 as the default
          if alpha is not None:
              alpha = alpha * 255
          else:
              alpha = 255
  
          ax = _datashade_points(
              points,
              ax,
              labels,
              values,
              cmap,
              color_key,
              color_key_cmap,
              background,
              width,
              height,
              show_legend,
              alpha,
          )
  
      ax.set(xticks=[], yticks=[])
      if _get_metric(umap_object) != "euclidean":
          ax.text(
              0.99,
              0.01,
              "UMAP: metric={}, n_neighbors={}, min_dist={}".format(
                  _get_metric(umap_object),
                  umap_object.n_neighbors,
                  umap_object.min_dist,
              ),
              transform=ax.transAxes,
              horizontalalignment="right",
              color=font_color,
          )
      else:
          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 16 for calling a global function with example usage: points(umap_object, points, labels, values, theme, cmap, color_key, color_key_cmap, background, width, height, show_legend, subset_points, ax, alpha) and returns: ax