Check VariantCalls for duplicate positions.

Author: donkirkby

pyvdrm/tests/test_vcf.py

@@ -203,6 +203,15 @@ def test_init_multiple_wildtypes(self):
                                     r'Multiple wildtypes found: Q, R\.'):
             MutationSet(mutations=mutations)
 
+    def test_init_bad_text(self):
+        expected_message = \
+            r'MutationSet text expects wild type \(optional\), position, and ' \
+            r'zero or more variants\.'
+        for bad_text in ('!20A', '20Ac', 'r20Q'):
+            with self.subTest(bad_text):
+                with self.assertRaisesRegex(ValueError, expected_message):
+                    MutationSet(bad_text)
+
     def test_repr(self):
         expected_repr = "MutationSet('Q1AC')"
         ms = MutationSet('Q1AC')
@@ -263,6 +272,19 @@ def test_immutable(self):
         with self.assertRaises(AttributeError):
             ms.wildtype = 'D'
 
+    def test_length(self):
+        self.assertEqual(0, len(MutationSet('A10')))
+        self.assertEqual(1, len(MutationSet('A10I')))
+        self.assertEqual(2, len(MutationSet('A10IL')))
+
+    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)
+
 
 class TestVariantCalls(unittest.TestCase):
     def test_init_text(self):
@@ -300,6 +322,11 @@ def test_init_bad_length(self):
                 ValueError, r'Reference length was 4 and sample length was 5\.'):
             VariantCalls(reference=reference, sample=sample)
 
+    def test_init_with_duplicate_positions(self):
+        with self.assertRaisesRegex(
+                ValueError, r'Multiple mutation sets at position 10\.'):
+            VariantCalls('H10R A1IN H10C')
+
     def test_init_with_reference(self):
         expected_reference = 'ASH'
         expected_repr = "VariantCalls('A1IL H3R')"
@@ -362,6 +389,11 @@ def test_in(self):
         self.assertIn(mutation_set1, calls)
         self.assertNotIn(mutation_set2, calls)
 
+    def test_length(self):
+        self.assertEqual(0, len(VariantCalls('')))
+        self.assertEqual(1, len(VariantCalls('A10IL')))
+        self.assertEqual(2, len(VariantCalls('A10IL H3R')))
+
     def test_immutable(self):
         calls = VariantCalls('A1IL H3R')
 

pyvdrm/vcf.py

@@ -37,6 +37,13 @@ def __new__(cls, text=None, reference=None, sample=None):
                              for i, (alt, ref) in enumerate(zip(sample,
                                                                 reference),
                                                             1)}
+        positions = set()
+        for mutation_set in mutation_sets:
+            if mutation_set.pos in positions:
+                message = 'Multiple mutation sets at position {}.'.format(
+                    mutation_set.pos)
+                raise ValueError(message)
+            positions.add(mutation_set.pos)
         # noinspection PyArgumentList
         return super().__new__(cls,
                                mutation_sets=mutation_sets,
@@ -62,6 +69,9 @@ def __hash__(self):
     def __iter__(self):
         return iter(self.mutation_sets)
 
+    def __len__(self):
+        return len(self.mutation_sets)
+
     def __contains__(self, item):
         return item in self.mutation_sets
 
@@ -143,9 +153,11 @@ def __new__(cls,
                 mutations=None,
                 reference=None):
         if text:
-            match = re.match(r"([A-Z]?)(\d+)([idA-Z]*)", text)
+            match = re.match(r"([A-Z]?)(\d+)([idA-Z]*)$", text)
             if match is None:
-                raise ValueError
+                message = 'MutationSet text expects wild type (optional), ' \
+                          'position, and zero or more variants.'
+                raise ValueError(message)
 
             wildtype, pos, variants = match.groups()
             if reference:
@@ -157,7 +169,7 @@ def __new__(cls,
                                            variant=variant)
                                   for variant in variants)
         else:
-            mutations = frozenset(mutations)
+            mutations = frozenset(mutations or tuple())
             positions = {mutation.pos for mutation in mutations}
             wildtypes = {mutation.wildtype for mutation in mutations}
             if pos is not None: