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))
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