docs: def variants(self, case_id, skip=0, count=1000, filters=None):
          """Return all variants in the VCF.
  
          This function will apply the given filter and return the 'count' first
          variants. If skip the first 'skip' variants will not be regarded.
  
              Args:
                  case_id (str): Path to a vcf file (for this adapter)
                  skip (int): Skip first variants
                  count (int): The number of variants to return
                  filters (dict): A dictionary with filters. Currently this will
                  look like: {
                      gene_list: [] (list of hgnc ids),
                      frequency: None (float),
                      cadd: None (float),
                      sv_len: None (float),
                      consequence: [] (list of consequences),
                      is_lof: None (Bool),
                      genetic_models [] (list of genetic models)
                      sv_type: List (list of sv types),
                  }
              Returns:
                  puzzle.constants.Results : Named tuple with variants and
                                             nr_of_variants
  
          """
          filters = filters or {}
          case_obj = self.case(case_id=case_id)
  
          limit = count + skip
  
          genes = set()
          if filters.get('gene_ids'):
              genes = set([gene_id.strip() for gene_id in filters['gene_ids']])
  
          frequency = None
          if filters.get('frequency'):
              frequency = float(filters['frequency'])
  
          cadd = None
          if filters.get('cadd'):
              cadd = float(filters['cadd'])
  
          genetic_models = None
          if filters.get('genetic_models'):
              genetic_models = set(filters['genetic_models'])
  
          sv_len = None
          if filters.get('sv_len'):
              sv_len = float(filters['sv_len'])
  
          impact_severities = None
          if filters.get('impact_severities'):
              impact_severities = set(filters['impact_severities'])
  
          vcf_file_path = case_obj.variant_source
  
          self.head = get_header(vcf_file_path)
  
          self.vep_header = self.head.vep_columns
          self.snpeff_header = self.head.snpeff_columns
  
          variants = self._get_filtered_variants(vcf_file_path, filters)
  
          result = []
          skip_index = 0
          for index, variant in enumerate(variants):
              index += 1
              if skip_index >= skip:
                  variant_obj = self._format_variants(
                       variant=variant,
                       index=index,
                       case_obj=case_obj,
                  )
  
                  if genes and variant_obj:
                      if not set(variant_obj['gene_symbols']).intersection(genes):
                          variant_obj = None
  
                  if impact_severities and variant_obj:
                      if not variant_obj['impact_severity'] in impact_severities:
                          variant_obj = None
  
                  if frequency and variant_obj:
                      if variant_obj.max_freq > frequency:
                          variant_obj = None
  
                  if cadd and variant_obj:
                      if variant_obj['cadd_score'] < cadd:
                          variant_obj = None
  
                  if genetic_models and variant_obj:
                      models = set(variant_obj.genetic_models)
                      if not models.intersection(genetic_models):
                          variant_obj = None
  
                  if sv_len and variant_obj:
                      if variant_obj.sv_len < sv_len:
                          variant_obj = None
  
                  if variant_obj:
                      skip_index += 1
  
                      if skip_index <= limit:
                          result.append(variant_obj)
                      else:
                          break
              else:
                  skip_index += 1
  
          return Results(result, len(result))