docs: def nearest_neighbors(
      X, n_neighbors, metric, metric_kwds, angular, random_state, verbose=False
  ):
      """Compute the ``n_neighbors`` nearest points for each data point in ``X``
      under ``metric``. This may be exact, but more likely is approximated via
      nearest neighbor descent.
  
      Parameters
      ----------
      X: array of shape (n_samples, n_features)
          The input data to compute the k-neighbor graph of.
  
      n_neighbors: int
          The number of nearest neighbors to compute for each sample in ``X``.
  
      metric: string or callable
          The metric to use for the computation.
  
      metric_kwds: dict
          Any arguments to pass to the metric computation function.
  
      angular: bool
          Whether to use angular rp trees in NN approximation.
  
      random_state: np.random state
          The random state to use for approximate NN computations.
  
      verbose: bool
          Whether to print status data during the computation.
  
      Returns
      -------
      knn_indices: array of shape (n_samples, n_neighbors)
          The indices on the ``n_neighbors`` closest points in the dataset.
  
      knn_dists: array of shape (n_samples, n_neighbors)
          The distances to the ``n_neighbors`` closest points in the dataset.
      """
      if verbose:
          print(ts(), "Finding Nearest Neighbors")
  
      if metric == "precomputed":
          # Note that this does not support sparse distance matrices yet ...
          # Compute indices of n nearest neighbors
          knn_indices = np.argsort(X)[:, :n_neighbors]
          # Compute the nearest neighbor distances
          #   (equivalent to np.sort(X)[:,:n_neighbors])
          knn_dists = X[np.arange(X.shape[0])[:, None], knn_indices].copy()
  
          rp_forest = []
      else:
          if callable(metric):
              distance_func = metric
          elif metric in dist.named_distances:
              distance_func = dist.named_distances[metric]
          else:
              raise ValueError("Metric is neither callable, " + "nor a recognised string")
  
          if metric in ("cosine", "correlation", "dice", "jaccard"):
              angular = True
  
          rng_state = random_state.randint(INT32_MIN, INT32_MAX, 3).astype(np.int64)
  
          if scipy.sparse.isspmatrix_csr(X):
              if metric in sparse.sparse_named_distances:
                  distance_func = sparse.sparse_named_distances[metric]
                  if metric in sparse.sparse_need_n_features:
                      metric_kwds["n_features"] = X.shape[1]
              else:
                  raise ValueError(
                      "Metric {} not supported for sparse " + "data".format(metric)
                  )
              metric_nn_descent = sparse.make_sparse_nn_descent(
                  distance_func, tuple(metric_kwds.values())
              )
  
              # TODO: Hacked values for now
              n_trees = 5 + int(round((X.shape[0]) ** 0.5 / 20.0))
              n_iters = max(5, int(round(np.log2(X.shape[0]))))
              if verbose:
                  print(ts(), "Building RP forest with",  str(n_trees), "trees")
  
              rp_forest = make_forest(X, n_neighbors, n_trees, rng_state, angular)
              leaf_array = rptree_leaf_array(rp_forest)
  
              if verbose:
                  print(ts(), "NN descent for", str(n_iters), "iterations")
              knn_indices, knn_dists = metric_nn_descent(
                  X.indices,
                  X.indptr,
                  X.data,
                  X.shape[0],
                  n_neighbors,
                  rng_state,
                  max_candidates=60,
                  rp_tree_init=True,
                  leaf_array=leaf_array,
                  n_iters=n_iters,
                  verbose=verbose,
              )
          else:
              metric_nn_descent = make_nn_descent(
                  distance_func, tuple(metric_kwds.values())
              )
              # TODO: Hacked values for now
              n_trees = 5 + int(round((X.shape[0]) ** 0.5 / 20.0))
              n_iters = max(5, int(round(np.log2(X.shape[0]))))
  
              if verbose:
                  print(ts(), "Building RP forest with", str(n_trees), "trees")
              rp_forest = make_forest(X, n_neighbors, n_trees, rng_state, angular)
              leaf_array = rptree_leaf_array(rp_forest)
              if verbose:
                  print(ts(), "NN descent for", str(n_iters), "iterations")
              knn_indices, knn_dists = metric_nn_descent(
                  X,
                  n_neighbors,
                  rng_state,
                  max_candidates=60,
                  rp_tree_init=True,
                  leaf_array=leaf_array,
                  n_iters=n_iters,
                  verbose=verbose,
              )
  
          if np.any(knn_indices < 0):
              warn(
                  "Failed to correctly find n_neighbors for some samples."
                  "Results may be less than ideal. Try re-running with"
                  "different parameters."
              )
      if verbose:
          print(ts(), "Finished Nearest Neighbor Search")
      return knn_indices, knn_dists, rp_forest