How to use the hail.case function in hail
To help you get started, we’ve selected a few hail examples, based on popular ways it is used in public projects.
Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
hail-is / hail / python / hail / expr / tests.py View on Github 
def make_case(x):
x = hl.literal(x)
return (hl.case()
.when(x == 6, 'A')
.when(x % 3 == 0, 'B')
.when(x == 5, 'C')
.when(x < 2, 'D')
.or_missing())def _get_copy_state(locus: hl.expr.LocusExpression) -> hl.expr.Int32Expression:
"""
Helper method to go from LocusExpression to a copy-state int for indexing into the
trans_count_map.
"""
return (
hl.case()
.when(locus.in_autosome_or_par(), auto_or_par)
.when(locus.in_x_nonpar(), hemi_x)
.when(locus.in_y_nonpar(), hemi_y)
.or_missing()min_snv_qual = snv_phred_threshold + snv_phred_het_prior
min_indel_qual = indel_phred_threshold + indel_phred_het_prior
min_mixed_qual = max(min_snv_qual, min_indel_qual)
if isinstance(qual_approx_expr, hl.expr.ArrayNumericExpression):
return hl.range(1, hl.len(alleles)).map(
lambda ai: hl.cond(
hl.is_snp(alleles[0], alleles[ai]),
qual_approx_expr[ai - 1] < min_snv_qual,
qual_approx_expr[ai - 1] < min_indel_qual
)
)
else:
return (
hl.case()
.when(hl.range(1, hl.len(alleles)).all(lambda ai: hl.is_snp(alleles[0], alleles[ai])), qual_approx_expr < min_snv_qual)
.when(hl.range(1, hl.len(alleles)).all(lambda ai: hl.is_indel(alleles[0], alleles[ai])), qual_approx_expr < min_indel_qual)
.default(qual_approx_expr < min_mixed_qual)
)return hl.bind(lambda r, a:
hl.cond(r.matches(_base_regex),
hl.case()
.when(a.matches(_base_regex), hl.case()
.when(r.length() == a.length(),
hl.cond(r.length() == 1,
hl.cond(r != a, _allele_ints['SNP'], _allele_ints['Unknown']),
hl.cond(hamming(r, a) == 1,
_allele_ints['SNP'],
_allele_ints['MNP'])))
.when((r.length() < a.length()) & (r[0] == a[0]) & a.endswith(r[1:]),
_allele_ints["Insertion"])
.when((r[0] == a[0]) & r.endswith(a[1:]),
_allele_ints["Deletion"])
.default(_allele_ints['Complex']))
.when(a == '*', _allele_ints['Star'])
.when(a.matches(_symbolic_regex), _allele_ints['Symbolic'])
.default(_allele_ints['Unknown']),
_allele_ints['Unknown']),
ref, alt)hl.case()
.when(kid.GQ < min_gq, failure)
.when((kid.DP / (parent.DP) < min_dp_ratio) |
(kid_ad_ratio < min_child_ab), failure)
.when((hl.sum(parent.AD) == 0), failure)
.when(parent.AD[1] / hl.sum(parent.AD) > max_parent_ab, failure)
.when(p_de_novo < min_p, failure)
.when(~is_snp, hl.case()
.when((p_de_novo > 0.99) & (kid_ad_ratio > 0.3) & (n_alt_alleles == 1),
hl.struct(p_de_novo=p_de_novo, confidence='HIGH'))
.when((p_de_novo > 0.5) & (kid_ad_ratio > 0.3) & (n_alt_alleles <= 5),
hl.struct(p_de_novo=p_de_novo, confidence='MEDIUM'))
.when(kid_ad_ratio > 0.3,
hl.struct(p_de_novo=p_de_novo, confidence='LOW'))
.or_missing())
.default(hl.case()
.when(((p_de_novo > 0.99) & (kid_ad_ratio > 0.3) & (dp_ratio > 0.2)) |
((p_de_novo > 0.99) & (kid_ad_ratio > 0.3) & (n_alt_alleles == 1)) |
((p_de_novo > 0.5) & (kid_ad_ratio > 0.3) & (n_alt_alleles < 10) & (kid.DP > 10)),
hl.struct(p_de_novo=p_de_novo, confidence='HIGH'))
.when((p_de_novo > 0.5) & ((kid_ad_ratio > 0.3) | (n_alt_alleles == 1)),
hl.struct(p_de_novo=p_de_novo, confidence='MEDIUM'))
.when(kid_ad_ratio > 0.2,
hl.struct(p_de_novo=p_de_novo, confidence='LOW'))
.or_missing()Creates a struct with the following annotation:
- X_karyotype (str)
- Y_karyotype (str)
- sex_karyotype (str)
Note that X0 is currently returned as 'X'.
:param chr_x_ploidy: Chromosome X ploidy (or relative ploidy)
:param chr_y_ploidy: Chromosome Y ploidy (or relative ploidy)
:param x_ploidy_cutoffs: Tuple of X chromosome ploidy cutoffs: (upper cutoff for single X, (lower cutoff for double X, upper cutoff for double X), lower cutoff for triple X)
:param y_ploidy_cutoffs: Tuple of Y chromosome ploidy cutoffs: ((lower cutoff for single Y, upper cutoff for single Y), lower cutoff for double Y)
:return: Struct containing X_karyotype, Y_karyotype, and sex_karyotype
"""
sex_expr = hl.struct(
X_karyotype=(
hl.case()
.when(chr_x_ploidy < x_ploidy_cutoffs[0], "X")
.when(
(
(chr_x_ploidy > x_ploidy_cutoffs[1][0])
& (chr_x_ploidy < x_ploidy_cutoffs[1][1])
),
"XX",
)
.when((chr_x_ploidy >= x_ploidy_cutoffs[2]), "XXX")
.default("ambiguous")
),
Y_karyotype=(
hl.case()
.when(chr_y_ploidy < y_ploidy_cutoffs[0][0], "")
.when(
( last_pos = hl.fold(lambda a, elt: (hl.case()
.when(a <= elt, elt)
.or_error("locus_windows: 'locus_expr' global position must be in ascending order.")),
-1,def get_coverage_expr(mt):
cov_arrays = hl.literal({
x:
[1, 1, 1, 1, 1, 1, 1, 1, 0] if x >= 50
else [1, 1, 1, 1, 1, 1, 1, 0, 0] if x >= 30
else ([1] * (i + 2)) + ([0] * (7 - i))
for i, x in enumerate(range(5, 100, 5))
})
return hl.bind(
lambda array_expr: hl.struct(
**{
f'over_{x}': hl.int32(array_expr[i]) for i, x in enumerate([1, 5, 10, 15, 20, 25, 30, 50, 100])
}
),
hl.agg.array_sum(hl.case()
.when(mt.x >= 100, [1, 1, 1, 1, 1, 1, 1, 1, 1])
.when(mt.x >= 5, cov_arrays[mt.x - (mt.x % 5)])
.when(mt.x >= 1, [1, 0, 0, 0, 0, 0, 0, 0, 0])
.default([0, 0, 0, 0, 0, 0, 0, 0, 0])))lambda tc: tc.annotate(
csq_score=hl.case(missing_false=True)
.when(
(tc.lof == "HC") & (tc.lof_flags == ""),
csq_score(tc) - no_flag_score,
)
.when(
(tc.lof == "HC") & (tc.lof_flags != ""), csq_score(tc) - flag_score
)
.when(tc.lof == "OS", csq_score(tc) - 20)
.when(tc.lof == "LC", csq_score(tc) - 10)
.when(
tc.polyphen_prediction == "probably_damaging", csq_score(tc) - 0.5
)
.when(
tc.polyphen_prediction == "possibly_damaging", csq_score(tc) - 0.25
)
.when(tc.polyphen_prediction == "benign", csq_score(tc) - 0.1)def require_biallelic(dataset, method) -> MatrixTable:
require_row_key_variant(dataset, method)
return dataset._select_rows(method,
hl.case()
.when(dataset.alleles.length() == 2, dataset._rvrow)
.or_error(f"'{method}' expects biallelic variants ('alleles' field of length 2), found " +
hl.str(dataset.locus) + ", " + hl.str(dataset.alleles)))hail
Scalable library for exploring and analyzing genomic data.
