docs: def DBSCAN(data, minPts, eps = None, quantile = 50, subsamples_matrix = None, samples_weights = None, 
  metric = 'minkowski', p = 2, verbose = True):
      """Performs Density-Based Spatial Clustering of Applications with Noise,
          possibly on various subsamples or combinations of data-points extracted from the whole dataset, 'data'.
          
          If the radius 'eps' is not provided by the user, it will be determined in an adaptive, data-dependent way 
          by a call to 'load' from this module (see the corresponding documentation for more explanations).
          
          Unlike Scikit-learn's and many other versions of DBSCAN, this implementation does not experience failure 
          due to 'MemoryError' exceptions for large data-sets.
          Indeed, any array too large to fit into memory is stored on disk in an HDF5 data structure.
      
      Parameters
      ----------
      data : array of shape (n_samples, n_features)
          The data-set to be analysed. Subsamples of this curated data-set can also be analysed 
          by a call to DBSCAN by providing lits of selected data-points, stored in 'subsamples_matrix' (see below).
  
      subsamples_matrix : array of shape (n_runs, n_subsamples), optional (default = None)
          Each row of this matrix contains a set of indices identifying the samples selected from the whole data-set 
          for each of 'n_runs' independent rounds of DBSCAN clusterings.
  
      minPts : int
          The number of points within an epsilon-radius hypershpere for the said region to qualify as dense.
  
      eps : float, optional (default = None)
          Sets the maximum distance separating two data-points for those data-points to be considered 
          as part of the same neighborhood.
  
      quantile : int, optional (default = 50)
          If 'eps' is not provided by the user, it will be determined as the 'quantile' of the distribution
          of the k-nearest distances to each sample, with k set to 'minPts'.
  
      samples_weights : array of shape (n_runs, n_samples), optional (default = None)
          Holds the weights of each sample. A sample with weight greater than 'minPts' is guaranteed 
          to be a core sample; a sample with negative weight tends to prevent its 'eps'-neighbors from being core. 
          Weights are absolute and default to 1.
  
      metric : string or callable, optional (default = 'euclidean')
          The metric to use for computing the pairwise distances between samples
          (each sample corresponds to a row in 'data'). 
          If metric is a string or callable, it must be compatible with metrics.pairwise.pairwise_distances.
  
      p : float, optional (default = 2)
          If a Minkowski metric is used, 'p' denotes its power.
  
      verbose : Boolean, optional (default = True)
          Whether to display messages reporting the status of the computations and the time it took to complete
          each major stage of the algorithm. 
      
      Returns
      -------
      eps : float
          The parameter of DBSCAN clustering specifying if points are density-reachable. 
          This is relevant if the user chose to let our procedures search for a value of this radius as a quantile
          of the distribution of 'minPts'-nearest distances for each data-point.
      
      labels_matrix : array of shape (N_samples, ) 
          For each sample, specifies the identity of the cluster to which it has been
          assigned by DBSCAN. The points classified as noise have entries -1. The points that have not been
          considered for clustering are labelled -2.
          
      References
      ----------
      Ester, M., H. P. Kriegel, J. Sander and X. Xu, "A Density-Based
      Algorithm for Discovering Clusters in Large Spatial Databases with Noise".
      In: Proceedings of the 2nd International Conference on Knowledge Discovery
      and Data Mining, Portland, OR, AAAI Press, pp. 226-231. 1996
      """
          
      assert isinstance(minPts, int) or type(minPts) is np.int_
      assert minPts > 1
  
      if subsamples_matrix is None:
          subsamples_matrix = np.arange(data.shape[0], dtype = int)
          subsamples_matrix = subsamples_matrix.reshape(1, -1)
      else:
          subsamples_matrix = np.array(subsamples_matrix, copy = False)
  
      N_runs = subsamples_matrix.shape[0]
      N_samples = data.shape[0]
  
      labels_matrix = np.zeros((N_runs, N_samples), dtype = int)
  
      with NamedTemporaryFile('w', suffix = '.h5', delete = True, dir = './') as f:
          eps = load(f.name, data, minPts, eps, quantile, subsamples_matrix, samples_weights, metric, p, verbose)
  
          for run in range(N_runs):
              _, labels = shoot(f.name, minPts, sample_ID = run, verbose = verbose)
              labels_matrix[run] = labels
  
      return eps, labels_matrix