docs: def cover(self, minAcc, maxAcc, groupBy=None, new_reg_fields=None, cover_type="normal"):
          """
          *Wrapper of* ``COVER``
  
          COVER is a GMQL operator that takes as input a dataset (of usually, 
          but not necessarily, multiple samples) and returns another dataset 
          (with a single sample, if no groupby option is specified) by “collapsing”
          the input samples and their regions according to certain rules 
          specified by the COVER parameters. The attributes of the output regions 
          are only the region coordinates, plus in case, when aggregate functions 
          are specified, new attributes with aggregate values over attribute values 
          of the contributing input regions; output metadata are the union of the 
          input ones, plus the metadata attributes JaccardIntersect and 
          JaccardResult, representing global Jaccard Indexes for the considered 
          dataset, computed as the correspondent region Jaccard Indexes but on 
          the whole sample regions.
  
          :param cover_type: the kind of cover variant you want ['normal', 'flat', 'summit', 'histogram']
          :param minAcc: minimum accumulation value, i.e. the minimum number
           of overlapping regions to be considered during COVER execution. It can be any positive
           number or the strings {'ALL', 'ANY'}.
          :param maxAcc: maximum accumulation value, i.e. the maximum number
           of overlapping regions to be considered during COVER execution. It can be any positive
           number or the strings {'ALL', 'ANY'}.
          :param groupBy: optional list of metadata attributes 
          :param new_reg_fields: dictionary of the type
              {'new_region_attribute' : AGGREGATE_FUNCTION('field'), ...}
          :return: a new GMQLDataset
          
          An example of usage::
          
              cell_tf = narrow_peak.cover("normal", minAcc=1, maxAcc="Any", 
                                              groupBy=['cell', 'antibody_target'])    
          """
          if isinstance(cover_type, str):
              coverFlag = self.opmng.getCoverTypes(cover_type)
          else:
              raise TypeError("type must be a string. "
                              "{} was provided".format(type(cover_type)))
          if isinstance(minAcc, str):
              minAccParam = self.opmng.getCoverParam(minAcc.lower())
          elif isinstance(minAcc, int):
              minAccParam = self.opmng.getCoverParam(str(minAcc).lower())
          else:
              raise TypeError("minAcc must be a string or an integer. "
                              "{} was provided".format(type(minAcc)))
          if isinstance(maxAcc, str):
              maxAccParam = self.opmng.getCoverParam(maxAcc.lower())
          elif isinstance(maxAcc, int):
              maxAccParam = self.opmng.getCoverParam(str(maxAcc).lower())
          else:
              raise TypeError("maxAcc must be a string or an integer. "
                              "{} was provided".format(type(minAcc)))
  
          if isinstance(groupBy, list) and \
              all([isinstance(x, str) for x in groupBy]):
              groupBy_result = Some(groupBy)
          elif groupBy is None:
              groupBy_result = none()
          else:
              raise TypeError("groupBy must be a list of string. "
                              "{} was provided".format(type(groupBy)))
  
          aggregates = []
          if isinstance(new_reg_fields, dict):
              expBuild = self.pmg.getNewExpressionBuilder(self.__index)
              for k in new_reg_fields.keys():
                  if isinstance(k, str):
                      item = new_reg_fields[k]
                      if isinstance(item, (SUM, MIN, MAX, AVG, BAG, BAGD,
                                           MEDIAN, COUNT)):
                          op_name = item.get_aggregate_name()
                          op_argument = item.get_argument()
                          if op_argument is None:
                              op_argument = none()
                          else:
                              op_argument = Some(op_argument)
                          regsToReg = expBuild.getRegionsToRegion(op_name, k, op_argument)
                          aggregates.append(regsToReg)
                      else:
                          raise TypeError("The items in new_reg_fields must be Aggregates (SUM, MIN, MAX, AVG, BAG, "
                                          "BAGD, MEDIAN, COUNT)"
                                          " {} was provided".format(type(item)))
                  else:
                      raise TypeError("The key of new_reg_fields must be a string. "
                                      "{} was provided".format(type(k)))
          elif new_reg_fields is None:
              pass
          else:
              raise TypeError("new_reg_fields must be a list of dictionary. "
                              "{} was provided".format(type(new_reg_fields)))
  
          new_index = self.opmng.cover(self.__index, coverFlag, minAccParam, maxAccParam,
                                       groupBy_result, aggregates)
          return GMQLDataset(index=new_index, location=self.location,
                             local_sources=self._local_sources,
                             remote_sources=self._remote_sources, meta_profile=self.meta_profile)