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

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