code: def re_init(
      predData,
      condensed_tree,
      n_clusters=None,
      cluster_selection_epsilon=0.0,
  ):
      """
      Modify PredictionData of HDBSCAN to account for epsilon.
      epsilon is the cluster_selection_epsilon that controls granularity
          of clusters; Large epsilon => More clusters
  
      Parameters
      ----------
      predData: PredictionData
          Contains data to use for predicting novel points.
          Defined in the HDBSCAN module
  
      condensed_tree: CondensedTree
          Tree structure that contains hierarchical clustering.
          Defined in the HDBSCAN module
  
      n_clusters: int, optional, default=None
          If specified, use this to obtain cluster_selection_epsilon
              from CondensedTree; Overrides cluster_selection_epsilon parameter
  
      cluster_selection_epsilon: float, default=0.
          In cluster tree, nodes are not split further beyond (>=) this value.
          epsilon is the inverse of core distance.
  
      Returns
      -------
      None
      """
      # predData must be a pre-trained PredictionData instance from hdbscan
      # If n_clusters is specified, compute cluster_selection_epsilon;
      if n_clusters is not None:
          cluster_selection_epsilon = select_epsilon(
              condensed_tree, n_clusters
          )
  
      # This is the key modification:
      # Select clusters according to selection method and epsilon.
      selected_clusters = _new_select_clusters(
          condensed_tree, cluster_selection_epsilon
      )
      # _new_select_clusters is a modification of get_clusters
      #   from hdbscan._hdbscan_tree
  
      # raw tree, used later to get exemplars and lambda values
      raw_condensed_tree = condensed_tree._raw_tree
  
      # Re-do the cluster map: Map cluster numbers in tree (N, N+1, ..)
      #    to the cluster labels produced as output
      predData.cluster_map = {
          int(c): n
          for n, c in enumerate(sorted(list(selected_clusters)))
      }
      predData.reverse_cluster_map = {
          n: c for c, n in predData.cluster_map.items()
      }
  
      # Re-compute lambdas and exemplars for selected clusters;
      predData.max_lambdas = {}
      predData.exemplars = []
  
      for cluster in selected_clusters:
          # max_lambda <=> smallest distance <=> most persistent point(s)
          predData.max_lambdas[cluster] = raw_condensed_tree[
              "lambda_val"
          ][raw_condensed_tree["parent"] == cluster].max()
  
          # Map all sub-clusters of selected cluster to the selected cluster's
          #       label in output.
          # Map lambdas too...
          for sub_cluster in predData._clusters_below(cluster):
              predData.cluster_map[sub_cluster] = predData.cluster_map[
                  cluster
              ]
              predData.max_lambdas[sub_cluster] = predData.max_lambdas[
                  cluster
              ]
  
          # Create set of exemplar points for later use.
          # Novel points are assigned based on cluster of closest exemplar.
          cluster_exemplars = np.array([], dtype=np.int64)
          # For each selected cluster, get all of its leaves,
          #       and leaves of leaves, and so on...
          for leaf in predData._recurse_leaf_dfs(cluster):
              # Largest lambda => Most persistent points
              leaf_max_lambda = raw_condensed_tree["lambda_val"][
                  raw_condensed_tree["parent"] == leaf
              ].max()
              # Get the most persistent points
              points = raw_condensed_tree["child"][
                  (raw_condensed_tree["parent"] == leaf)
                  & (
                      raw_condensed_tree["lambda_val"]
                      == leaf_max_lambda
                  )
              ]
              # Add most persistent points as exemplars
              cluster_exemplars = np.hstack([cluster_exemplars, points])
  
          # Add exemplars for each leaf of each selected cluster.
          predData.exemplars.append(
              predData.raw_data[cluster_exemplars]
          )
      return
  
imports: import copy
  from warnings import warn
  import numpy
  from ._hdbscan_tree import compute_stability, get_cluster_tree_leaves
  from .hdbscan_ import HDBSCAN, _tree_to_labels
  from .plots import _bfs_from_cluster_tree
  from .prediction import PredictionData, _find_cluster_and_probability, _find_neighbor_and_lambda
  from ._prediction_utils import get_tree_row_with_child, dist_membership_vector, outlier_membership_vector, prob_in_some_cluster, all_points_dist_membership_vector, all_points_outlier_membership_vector, all_points_prob_in_some_cluster
label_desc: Use image node_id 8 for calling a global function with example usage: re_init(predData, condensed_tree, n_clusters, cluster_selection_epsilon) without return types