class Filter(object): """ filters trios for candidate variants that might contribute to a probands disorder. """ def __init__(self, population_tags=None, count=0, known_genes=None, date=None, regions=None, lof_sites=None, pp_filter=0.0, sum_x_lr2_file=None, output_path=None, export_vcf=None, debug_chrom=None, debug_pos=None): """ initialise the class object Args: population_tags: list of population ID tags, that could exist within the INFO field, or None. count: number of probands to analyse, helpful for tracking progress in output logs. known_genes: path to table of genes genes known to be associated with genetic disorders, or None. date: date of the known_genes file, or None if not using/unknown. regions: path to a table of regions for DECIPHER CNV syndromes. lof_sites: path to json file of [chrom, position] coordinates in genome, for modifying to a loss-of-function consequence if required. Can be None if unneeded. pp_filter: threshold from 0 to 1 for pp_dnm value to filter out candidiate DNMs which fall below this value sum_x_lr2_file: File containing sum of l2r values on x chromosome for each person output_path: path to write output tab-separated file to export_vcf: path to file or folder to write VCFs to. debug_chrom: chromosome for debugging purposes. debug_pos: position for debugging variant filtering at. """ self.pp_filter = pp_filter self.total = count self.count = 0 self.populations = population_tags self.debug_chrom = debug_chrom self.debug_pos = debug_pos # open reference datasets, these return None if the paths are None self.known_genes = open_known_genes(known_genes) self.cnv_regions = open_cnv_regions(regions) self.last_base = open_last_base_sites(lof_sites) #open file containing sum of mean log 2 ratios on X, returns an empty dict if path is None self.sum_x_lr2 = open_x_lr2_file(sum_x_lr2_file) self.reporter = Report(output_path, export_vcf, date) def filter_trio(self, family): """ loads trio variants, and screens for candidate variants """ # some families have more than one child in the family, so run # through each child. family.set_child() while family.child is not None: if family.child.is_affected(): self.count += 1 logging.info("opening trio {} of {}".format(self.count, self.total)) found_vars = self.analyse_trio(family) # export the results to either tab-separated table or VCF format self.reporter.export_data(found_vars, family) family.set_child_examined() def analyse_trio(self, family): """identify candidate variants in exome data for a single trio. takes variants that passed the initial filtering from VCF loading, and splits the variants into groups for each gene with variants. Then analyses variants in a single gene (so we can utilise the appropriate inheritance mechanisms for that gene), before running some pos-inheritance filters, and exporting the data (ir required). Args: family: Family object Returns: list of (TrioGenotype, [genes], [inheritances], [type]) tuples for variants that pass inheritance and post-inheritance checks. """ variants = load_variants(family, self.pp_filter, self.populations, self.known_genes, self.last_base, self.sum_x_lr2, self.debug_chrom, self.debug_pos) # organise variants by gene, then find variants that fit different # inheritance models. We have to flatten the list of variant lists genes = self.create_gene_dict(variants) variants = [ self.find_variants(genes[x], x, family) for x in genes ] variants = [ x for sublist in variants for x in sublist ] # remove any duplicate variants (which might ocur due to CNVs being # checked against all the genes that they encompass) variants = self.exclude_duplicates(variants) # apply some final filters to the flagged variants post_filter = PostInheritanceFilter(family, self.debug_chrom, self.debug_pos) return post_filter.filter_variants(variants) def create_gene_dict(self, variants): """creates dictionary of variants indexed by gene Args: variants: list of TrioGenotypes objects Returns: dictionary of variants indexed by HGNC ID """ # organise the variants into entries for each gene genes = {} for var in variants: # variants (particularly CNVs) can span multiple genes, so we need # to check each gene separately, and then collapse duplicates later for gene_list in var.get_genes(): for gene in gene_list: if gene not in genes: genes[gene] = [] # add the variant to the gene entry genes[gene].append(var) return genes def find_variants(self, variants, gene, family): """ finds variants that fit inheritance models Args: variants: list of TrioGenotype objects gene: gene ID as string Returns: list of variants that pass inheritance checks """ # get the inheritance for the gene (monoalleleic, biallelic, hemizygous # etc), but allow for times when we haven't specified a list of genes # to use known_gene = None gene_inh = None if self.known_genes is not None and gene in self.known_genes: known_gene = self.known_genes[gene] gene_inh = known_gene['inh'] chrom_inheritance = variants[0].get_inheritance_type() # If we are looking for variants in a set of known genes, and the gene # isn't part of that set, then we don't ant to examine the variant for # that gene, UNLESS the variant is a CNV, since CNVs can be included # purely from size thresholds, regardless of which gene they overlap. if self.known_genes is not None and gene not in self.known_genes: variants = [ x for x in variants if x.is_cnv() ] # ignore intergenic variants if gene is None: for var in variants: if var.get_chrom() == self.debug_chrom and var.get_position() == self.debug_pos: print(var, "lacks HGNC/gene symbol") return [] # Now that we are examining a single gene, check that the consequences # for the gene are in the required functional categories. variants = [ var for var in variants if var.child.is_lof(gene) or var.child.is_missense(var.child.is_cnv(), gene) ] if variants == []: return [] for x in variants[0].child.info.symbols: try: symbol = x.get(gene, ['HGNC', 'SYMBOL', 'ENSG']) break except KeyError: continue logging.info("{}\t{}\tvariants: {}\trequired_mode: {}".format( family.child.get_id(), symbol, [str(x) for x in variants], gene_inh)) if chrom_inheritance == "autosomal": finder = Autosomal(variants, family, known_gene, gene, self.cnv_regions) elif chrom_inheritance in ["XChrMale", "XChrFemale", "YChrMale"]: finder = Allosomal(variants, family, known_gene, gene, self.cnv_regions) return finder.get_candidate_variants() def exclude_duplicates(self, variants): """ rejig variants included under multiple inheritance mechanisms Args: variants: list of candidate variants Returns: list of (variant, check_type, inheritance) tuples, with duplicates excluded, and originals modified to show both mechanisms """ unique_vars = {} for variant in variants: key = variant[0].child.get_key() if key not in unique_vars: unique_vars[key] = list(variant) else: result = variant[1] inh = variant[2] hgnc = variant[3] # append the check type and inheritance type to the first # instance of the variant unique_vars[key][1] += [x for x in result if x not in unique_vars[key][1]] unique_vars[key][2] += [x for x in inh if x not in unique_vars[key][2]] unique_vars[key][1] = sorted(unique_vars[key][1]) unique_vars[key][2] = sorted(unique_vars[key][2]) # add the gene IDs that are unique to the current variant # to the merged variant genes = [x for x in hgnc if x not in unique_vars[key][3]] unique_vars[key][3] += genes unique_vars = [tuple(unique_vars[x]) for x in unique_vars] return unique_vars
class ClinicalFilter(LoadOptions): """ filters trios for candidate variants that might contribute to a probands disorder. """ def __init__(self, opts): """intialise the class with the some definitions """ self.set_definitions(opts) self.report = Report(self.output_path, self.export_vcf, self.ID_mapper, self.known_genes_date) def filter_trios(self): """ loads trio variants, and screens for candidate variants """ self.vcf_loader = LoadVCFs(len(self.families), self.known_genes, \ self.debug_chrom, self.debug_pos) # load the trio paths into the current path setup for family_ID in sorted(self.families): self.family = self.families[family_ID] # some families have more than one child in the family, so run # through each child. self.family.set_child() while self.family.child is not None: if self.family.child.is_affected(): variants = self.vcf_loader.get_trio_variants( self.family, self.pp_filter) self.vcf_provenance = self.vcf_loader.get_trio_provenance() self.analyse_trio(variants) self.family.set_child_examined() sys.exit(0) def analyse_trio(self, variants): """identify candidate variants in exome data for a single trio. takes variants that passed the initial filtering from VCF loading, and splits the variants into groups for each gene with variants. Then analyses variants in a single gene (so we can utilise the appropriate inheritance mechanisms for that gene), before running some pos-inheritance filters, and exporting the data (ir required). Args: variants: list of TrioGenotypes objects """ # organise variants by gene, then find variants that fit # different inheritance models genes_dict = self.create_gene_dict(variants) found_vars = [] for gene in genes_dict: gene_vars = genes_dict[gene] found_vars += self.find_variants(gene_vars, gene) # remove any duplicate variants (which might ocur due to CNVs being # checked against all the genes that they encompass) found_vars = self.exclude_duplicates(found_vars) # apply some final filters to the flagged variants post_filter = PostInheritanceFilter(found_vars, self.family, self.debug_chrom, self.debug_pos) found_vars = post_filter.filter_variants() # export the results to either tab-separated table or VCF format self.report.export_data(found_vars, self.family, \ self.vcf_loader.child_header, self.vcf_provenance) def create_gene_dict(self, variants): """creates dictionary of variants indexed by gene Args: variants: list of TrioGenotypes objects Returns: dictionary of variants indexed by HGNC symbols """ # organise the variants into entries for each gene genes = {} for var in variants: # variants (particularly CNVs) can span multiple genes, so we need # to check each gene separately, and then collapse duplicates later for gene in var.get_genes(): if gene not in genes: genes[gene] = [] # add the variant to the gene entry genes[gene].append(var) return genes def find_variants(self, variants, gene): """ finds variants that fit inheritance models Args: variants: list of TrioGenotype objects gene: gene ID as string Returns: list of variants that pass inheritance checks """ # get the inheritance for the gene (monoalleleic, biallelic, hemizygous # etc), but allow for times when we haven't specified a list of genes # to use gene_inh = None if self.known_genes is not None and gene in self.known_genes: gene_inh = self.known_genes[gene]["inh"] # If we are looking for variants in a set of known genes, and the gene # isn't part of that set, then we don't ant to examine the variant for # that gene, UNLESS the variant is a CNV, since CNVs can be included # purely from size thresholds, regardless of which gene they overlap. if self.known_genes is not None and gene not in self.known_genes: variants = [x for x in variants if x.is_cnv()] # ignore intergenic variants if gene is None: for var in variants: if var.get_chrom() == self.debug_chrom and var.get_position( ) == self.debug_pos: print(var, "lacks HGNC/gene symbol") return [] # Now that we are examining a single gene, check that the consequences # for the gene are in the required functional categories. variants = [ var for var in variants if var.child.is_lof(gene) or var.child.is_missense(gene) ] if variants == []: return [] logging.debug("{} {} {} {}".format(self.family.child.get_id(), gene, variants, gene_inh)) chrom_inheritance = variants[0].get_inheritance_type() if chrom_inheritance == "autosomal": finder = Autosomal(variants, self.family, self.known_genes, gene, self.cnv_regions) elif chrom_inheritance in ["XChrMale", "XChrFemale", "YChrMale"]: finder = Allosomal(variants, self.family, self.known_genes, gene, self.cnv_regions) variants = finder.get_candidate_variants() variants = [(x[0], list(x[1]), list(x[2]), [gene]) for x in variants] return variants def exclude_duplicates(self, variants): """ rejig variants included under multiple inheritance mechanisms Args: variants: list of candidate variants Returns: list of (variant, check_type, inheritance) tuples, with duplicates excluded, and originals modified to show both mechanisms """ unique_vars = {} for variant in variants: key = variant[0].child.get_key() if key not in unique_vars: unique_vars[key] = list(variant) else: result = variant[1] inh = variant[2] hgnc = variant[3] # append the check type and inheritance type to the first # instance of the variant unique_vars[key][1] += [ x for x in result if x not in unique_vars[key][1] ] unique_vars[key][2] += [ x for x in inh if x not in unique_vars[key][2] ] # add the HGNC symbols that are unique to the current variant # to the merged variant hgnc = [x for x in hgnc if x not in unique_vars[key][3]] unique_vars[key][3] += hgnc unique_vars = [tuple(unique_vars[x]) for x in unique_vars] return unique_vars
class ClinicalFilter(LoadOptions): """ filters trios for candidate variants that might contribute to a probands disorder. """ def __init__(self, opts): """intialise the class with the some definitions """ self.set_definitions(opts) self.report = Report(self.output_path, self.export_vcf, self.ID_mapper, self.known_genes_date) def filter_trios(self): """ loads trio variants, and screens for candidate variants """ self.vcf_loader = LoadVCFs(len(self.families), self.known_genes, self.debug_chrom, self.debug_pos) # load the trio paths into the current path setup for family_ID in sorted(self.families): self.family = self.families[family_ID] # some families have more than one child in the family, so run # through each child. self.family.set_child() while self.family.child is not None: if self.family.child.is_affected(): variants = self.vcf_loader.get_trio_variants(self.family, self.pp_filter) self.vcf_provenance = self.vcf_loader.get_trio_provenance() self.analyse_trio(variants) self.family.set_child_examined() sys.exit(0) def analyse_trio(self, variants): """identify candidate variants in exome data for a single trio. takes variants that passed the initial filtering from VCF loading, and splits the variants into groups for each gene with variants. Then analyses variants in a single gene (so we can utilise the appropriate inheritance mechanisms for that gene), before running some pos-inheritance filters, and exporting the data (ir required). Args: variants: list of TrioGenotypes objects """ # organise variants by gene, then find variants that fit # different inheritance models genes_dict = self.create_gene_dict(variants) found_vars = [] for gene in genes_dict: gene_vars = genes_dict[gene] found_vars += self.find_variants(gene_vars, gene) # remove any duplicate variants (which might ocur due to CNVs being # checked against all the genes that they encompass) found_vars = self.exclude_duplicates(found_vars) # apply some final filters to the flagged variants post_filter = PostInheritanceFilter(found_vars, self.family, self.debug_chrom, self.debug_pos) found_vars = post_filter.filter_variants() # export the results to either tab-separated table or VCF format self.report.export_data(found_vars, self.family, self.vcf_loader.child_header, self.vcf_provenance) def create_gene_dict(self, variants): """creates dictionary of variants indexed by gene Args: variants: list of TrioGenotypes objects Returns: dictionary of variants indexed by HGNC symbols """ # organise the variants into entries for each gene genes = {} for var in variants: # variants (particularly CNVs) can span multiple genes, so we need # to check each gene separately, and then collapse duplicates later for gene in var.get_genes(): if gene not in genes: genes[gene] = [] # add the variant to the gene entry genes[gene].append(var) return genes def find_variants(self, variants, gene): """ finds variants that fit inheritance models Args: variants: list of TrioGenotype objects gene: gene ID as string Returns: list of variants that pass inheritance checks """ # get the inheritance for the gene (monoalleleic, biallelic, hemizygous # etc), but allow for times when we haven't specified a list of genes # to use gene_inh = None if self.known_genes is not None and gene in self.known_genes: gene_inh = self.known_genes[gene]["inh"] # If we are looking for variants in a set of known genes, and the gene # isn't part of that set, then we don't ant to examine the variant for # that gene, UNLESS the variant is a CNV, since CNVs can be included # purely from size thresholds, regardless of which gene they overlap. if self.known_genes is not None and gene not in self.known_genes: variants = [x for x in variants if x.is_cnv()] # ignore intergenic variants if gene is None: for var in variants: if var.get_chrom() == self.debug_chrom and var.get_position() == self.debug_pos: print(var, "lacks HGNC/gene symbol") return [] # Now that we are examining a single gene, check that the consequences # for the gene are in the required functional categories. variants = [var for var in variants if var.child.is_lof(gene) or var.child.is_missense(gene)] if variants == []: return [] logging.debug("{} {} {} {}".format(self.family.child.get_id(), gene, variants, gene_inh)) chrom_inheritance = variants[0].get_inheritance_type() if chrom_inheritance == "autosomal": finder = Autosomal(variants, self.family, self.known_genes, gene, self.cnv_regions) elif chrom_inheritance in ["XChrMale", "XChrFemale", "YChrMale"]: finder = Allosomal(variants, self.family, self.known_genes, gene, self.cnv_regions) variants = finder.get_candidate_variants() variants = [(x[0], list(x[1]), list(x[2]), [gene]) for x in variants] return variants def exclude_duplicates(self, variants): """ rejig variants included under multiple inheritance mechanisms Args: variants: list of candidate variants Returns: list of (variant, check_type, inheritance) tuples, with duplicates excluded, and originals modified to show both mechanisms """ unique_vars = {} for variant in variants: key = variant[0].child.get_key() if key not in unique_vars: unique_vars[key] = list(variant) else: result = variant[1] inh = variant[2] hgnc = variant[3] # append the check type and inheritance type to the first # instance of the variant unique_vars[key][1] += [x for x in result if x not in unique_vars[key][1]] unique_vars[key][2] += [x for x in inh if x not in unique_vars[key][2]] # add the HGNC symbols that are unique to the current variant # to the merged variant hgnc = [x for x in hgnc if x not in unique_vars[key][3]] unique_vars[key][3] += hgnc unique_vars = [tuple(unique_vars[x]) for x in unique_vars] return unique_vars