docs: def array(self, features, processes=None, chunksize=1, ragged=False,
                **kwargs):
          """
          Creates an MxN NumPy array of genomic signal for the region defined by
          each feature in `features`, where M=len(features) and N=(bins or
          feature length)
  
          Parameters
          ----------
          features : iterable of interval-like objects
              An iterable of interval-like objects; see docstring for
              `local_coverage` method for more details.
  
          processes : int or None
              If not None, then create the array in parallel, giving each process
              chunks of length `chunksize` to work on.
  
          chunksize : int
              `features` will be split into `chunksize` pieces, and each piece
              will be given to a different process. The optimum value is
              dependent on the size of the features and the underlying data set,
              but `chunksize=100` is a good place to start.
  
          ragged : bool
              If False (default), then return a 2-D NumPy array.  This requires
              all rows to have the same number of columns, which you get when
              supplying `bins` or if all features are of uniform length.  If
              True, then return a list of 1-D NumPy arrays
  
          Notes
          -----
          Additional keyword args are passed to local_coverage() which performs
          the work for each feature; see that method for more details.
          """
          if processes is not None:
              arrays = _array_parallel(
                  self.fn, self.__class__, features, processes=processes,
                  chunksize=chunksize, **kwargs)
          else:
              arrays = _array(self.fn, self.__class__, features, **kwargs)
          if not ragged:
              stacked_arrays = np.row_stack(arrays)
              del arrays
              return stacked_arrays
          else:
              return arrays