def test_in(self):
ms = MutationSet('A10IL')
self.assertIn(Mutation('A10I'), ms)
self.assertIn(Mutation('A10L'), ms)
self.assertIn(Mutation('10L'), ms)
self.assertNotIn(Mutation('A10S'), ms)
def test_init_wildtype_mismatch(self):
wildtype = 'R'
position = 1
mutations = {Mutation('Q1A'), Mutation('Q1C')}
with self.assertRaisesRegex(ValueError,
r'Multiple wildtypes found: Q, R\.'):
MutationSet(wildtype=wildtype, pos=position, mutations=mutations)
def test_init_position_mismatch(self):
wildtype = 'Q'
position = 2
mutations = {Mutation('Q1A'), Mutation('Q1C')}
with self.assertRaisesRegex(ValueError,
r'Multiple positions found: 1, 2\.'):
MutationSet(wildtype=wildtype, pos=position, mutations=mutations)
def test_equal_with_wildtype_mismatch(self):
set1 = Mutation('Q1A')
set2 = Mutation('R1A')
expected_message = 'Wild type mismatch between Q1A and R1A'
with self.assertRaisesRegex(ValueError, expected_message):
if set1 == set2:
pass
def test_init_text(self):
expected_wildtype = 'Q'
expected_position = 1
expected_mutations = {Mutation('Q1A'), Mutation('Q1C')}
ms = MutationSet('Q1AC')
self.assertEqual(expected_wildtype, ms.wildtype)
self.assertEqual(expected_position, ms.pos)
self.assertEqual(expected_mutations, ms.mutations)
def test_init_mutations_some_without_wildtype(self):
expected_wildtype = 'Q'
expected_position = 1
expected_mutations = {Mutation('Q1A'), Mutation('1C')}
ms = MutationSet(mutations=expected_mutations)
self.assertEqual(expected_wildtype, ms.wildtype)
self.assertEqual(expected_position, ms.pos)
self.assertEqual(expected_mutations, ms.mutations)
def test_init_variants(self):
expected_wildtype = 'Q'
expected_position = 1
expected_mutations = {Mutation('Q1A'), Mutation('Q1C')}
ms = MutationSet(wildtype=expected_wildtype,
pos=expected_position,
variants='AC')
self.assertEqual(expected_wildtype, ms.wildtype)
self.assertEqual(expected_position, ms.pos)
self.assertEqual(expected_mutations, ms.mutations)
def test_repr(self):
expected_repr = "Score(10, {Mutation('A23R')})"
score = Score(10, {Mutation('A23R')})
r = repr(score)
self.assertEqual(expected_repr, r)
def test_score_residues(self):
rule = ASI2("SCORE FROM ( 100G => 10, 101D => 20 )")
expected_residue = repr({Mutation('S100G')})
result = rule.dtree(VariantCalls("S100G R101d"))
self.assertEqual(expected_residue, repr(result.residues))
def test_init(self):
expected_value = 10
expected_mutations = {Mutation('A23R')}
score = Score(expected_value, expected_mutations)
self.assertEqual(expected_value, score.score)
self.assertEqual(expected_mutations, score.residues)
def test_init_text(self):
expected_wildtype = 'Q'
expected_position = 20
expected_variant = 'A'
m = Mutation('Q20A')
self.assertEqual(expected_wildtype, m.wildtype)
self.assertEqual(expected_position, m.pos)
self.assertEqual(expected_variant, m.variant)
def test_no_wildtypes(self):
expected_position = 10
expected_mutations = {Mutation('10C')}
ms = MutationSet(pos=expected_position, mutations=expected_mutations)
self.assertIsNone(ms.wildtype)
self.assertEqual(expected_position, ms.pos)
self.assertEqual(expected_mutations, ms.mutations)
def test_init_details(self):
expected_wildtype = 'Q'
expected_position = 20
expected_variant = 'A'
m = Mutation(wildtype=expected_wildtype,
pos=expected_position,
variant=expected_variant)
self.assertEqual(expected_wildtype, m.wildtype)
self.assertEqual(expected_position, m.pos)
self.assertEqual(expected_variant, m.variant)
def test_init_multiple_variants(self):
expected_message = \
r'Mutation text only allows one variant\.'
with self.assertRaisesRegex(ValueError, expected_message):
Mutation('Q20AE')
def test_immutable(self):
m = Mutation('Q1A')
with self.assertRaises(AttributeError):
m.pos = 2
def test_ineq_aa(self):
r1 = Mutation("20A")
r2 = Mutation("20C")
self.assertNotEqual(r2, r1)
def test_eq(self):
r1 = Mutation("20A")
r2 = Mutation("20A")
self.assertEqual(r2, r1)
def test_no_wildtype(self):
m = Mutation('20A')
r = repr(m)
self.assertEqual("Mutation('20A')", r)
self.assertIsNone(m.wildtype)
def test_str(self):
m = Mutation('Q20A')
s = str(m)
self.assertEqual("Q20A", s)
def test_init_multiple_positions(self):
mutations = {Mutation('Q3A'), Mutation('Q2C')}
with self.assertRaisesRegex(ValueError,
r'Multiple positions found: 2, 3\.'):
MutationSet(mutations=mutations)
def test_init_multiple_wildtypes(self):
mutations = {Mutation('R1A'), Mutation('Q1C')}
with self.assertRaisesRegex(ValueError,
r'Multiple wildtypes found: Q, R\.'):
MutationSet(mutations=mutations)
def test_init_bad_text(self):
expected_message = \
r'Mutation text expects wild type \(optional\), position, and one variant\.'
with self.assertRaisesRegex(ValueError, expected_message):
Mutation('!20A')
def test_repr(self):
m = Mutation('Q20A')
r = repr(m)
self.assertEqual("Mutation('Q20A')", r)
def write_resistance(aminos,
resistance_csv,
mutations_csv,
algorithms=None,
resistance_consensus_csv=None):
""" Calculate resistance scores and write them to files.
:param list[AminoList] aminos: region is the coordinate
reference name that this gene region was mapped to, and prevalance is a
float between 0.0 and 1.0
:param resistance_csv: open file to write resistance calls to, grouped by
genotype, region, drug_class
:param mutations_csv: open file to write mutations to, grouped by genotype,
drug_class
:param dict algorithms: {region: AsiAlgorithm}
:param resistance_consensus_csv: open file to write resistance consensus to
"""
resistance_writer = DictWriter(
resistance_csv,
['region',
'drug_class',
'drug',
'drug_name',
'level',
'level_name',
'score',
'genotype',
'seed',
'coord_region',
'version'],
lineterminator=os.linesep)
resistance_writer.writeheader()
mutations_writer = DictWriter(mutations_csv,
['drug_class',
'mutation',
'prevalence',
'genotype',
'region',
'seed',
'coord_region',
'version'],
lineterminator=os.linesep)
mutations_writer.writeheader()
if resistance_consensus_csv is None:
resistance_consensus_writer = None
else:
resistance_consensus_writer = create_consensus_writer(
resistance_consensus_csv)
if algorithms is None:
algorithms = load_asi()
for genotype, genotype_aminos in groupby(aminos, attrgetter('genotype')):
region_results = []
for amino_list in genotype_aminos:
asi = algorithms.get(genotype)
write_consensus(resistance_consensus_writer,
amino_list,
asi.alg_version)
if asi is None:
continue
region = amino_list.region
if region == 'INT':
region = 'IN'
result = interpret(asi, amino_list.aminos, region)
region_results.append((region, amino_list, asi.alg_version, result))
if all(drug_result.level == HcvResistanceLevels.FAIL.level
for region, amino_seq, alg_version, result in region_results
for drug_result in result.drugs):
continue
for region, amino_list, alg_version, result in region_results:
amino_seq = amino_list.aminos
reported_region = get_reported_region(region)
for drug_result in result.drugs:
resistance_writer.writerow(dict(region=reported_region,
drug_class=drug_result.drug_class,
drug=drug_result.code,
drug_name=drug_result.name,
level_name=drug_result.level_name,
level=drug_result.level,
score=drug_result.score,
genotype=genotype,
seed=amino_list.seed,
coord_region=amino_list.region,
version=alg_version))
for drug_class, class_mutations in result.mutations.items():
mutations = [Mutation(m) for m in class_mutations]
mutations.sort()
for mutation in mutations:
amino = mutation.variant
pos = mutation.pos
pos_aminos = amino_seq[pos-1]
prevalence = pos_aminos.get(amino, 0)
mutations_writer.writerow(dict(drug_class=drug_class,
mutation=mutation,
prevalence=prevalence,
genotype=genotype,
region=reported_region,
seed=amino_list.seed,
coord_region=amino_list.region,
version=alg_version))