Cigar tools: swap names of query and reference strips

Also adjust the contig stitcher to the change.

Author: Donaim

micall/core/contig_stitcher.py

@@ -97,13 +97,13 @@ def cut_reference(self, cut_point: float) -> Tuple['AlignedContig', 'AlignedCont
         return (left, right)
 
 
-    def lstrip_query(self) -> 'AlignedContig':
+    def lstrip(self) -> 'AlignedContig':
         """
         Trims the query sequence of the contig from its beginning up to the start of the
         alignment. The CIGAR alignment is also updated to reflect the trimming.
         """
 
-        alignment = self.alignment.lstrip_query().lstrip_reference()
+        alignment = self.alignment.lstrip_reference().lstrip_query()
         q_remainder, query = self.cut_query(alignment.q_st - 0.5)
         alignment = alignment.translate(0, -1 * alignment.q_st)
         result = AlignedContig.make(query, alignment, self.strand)
@@ -114,13 +114,13 @@ def lstrip_query(self) -> 'AlignedContig':
         return result
 
 
-    def rstrip_query(self) -> 'AlignedContig':
+    def rstrip(self) -> 'AlignedContig':
         """
         Trims the query sequence of the contig from its end based on the end of the
         alignment. The CIGAR alignment is also updated to reflect the trimming.
         """
 
-        alignment = self.alignment.rstrip_query().rstrip_reference()
+        alignment = self.alignment.rstrip_reference().rstrip_query()
         query, q_remainder = self.cut_query(alignment.q_ei + 0.5)
         result = AlignedContig.make(query, alignment, self.strand)
         logger.debug("Doing rstrip of %r resulted in %r, so %s (len %s) became %s (len %s)",
@@ -196,9 +196,9 @@ def combine_contigs(parts: List[AlignedContig]) -> AlignedContig:
     stripped_parts = []
     for prev_part, part, next_part in sliding_window(parts):
         if prev_part is not None:
-            part = part.lstrip_query()
+            part = part.lstrip()
         if next_part is not None:
-            part = part.rstrip_query()
+            part = part.rstrip()
         stripped_parts.append(part)
 
     ret = reduce(AlignedContig.munge, stripped_parts)
@@ -288,9 +288,9 @@ def is_out_of_order(name: str) -> bool:
         if isinstance(contig, AlignedContig):
             name = contig.name
             if prev_contig is not None or is_out_of_order(name):
-                contig = contig.lstrip_query()
+                contig = contig.lstrip()
             if next_contig is not None or is_out_of_order(name):
-                contig = contig.rstrip_query()
+                contig = contig.rstrip()
 
         yield contig
 
@@ -426,10 +426,10 @@ def stitch_2_contigs(left, right):
     # Cut in 4 parts.
     left_remainder, left_overlap = left.cut_reference(right.alignment.r_st - 0.5)
     right_overlap, right_remainder = right.cut_reference(left.alignment.r_ei + 0.5)
-    left_overlap = left_overlap.rstrip_query().lstrip_query()
-    right_overlap = right_overlap.lstrip_query().rstrip_query()
-    left_remainder = left_remainder.rstrip_query()
-    right_remainder = right_remainder.lstrip_query()
+    left_overlap = left_overlap.rstrip().lstrip()
+    right_overlap = right_overlap.lstrip().rstrip()
+    left_remainder = left_remainder.rstrip()
+    right_remainder = right_remainder.lstrip()
 
     logger.debug("Stitching %r at %s (len %s) with %r at %s (len %s)."
                  " The left_overlap %r is at %s (len %s)"
@@ -603,8 +603,8 @@ def try_split(contig):
             if covered(contig, gap):
                 midpoint = gap.r_st + (gap.r_ei - gap.r_st) / 2 + contig.alignment.epsilon
                 left_part, right_part = contig.cut_reference(midpoint)
-                left_part = left_part.rstrip_query()
-                right_part = right_part.lstrip_query()
+                left_part = left_part.rstrip()
+                right_part = right_part.lstrip()
 
                 contigs.remove(contig)
                 contigs.append(left_part)

micall/tests/test_cigar_tools.py

@@ -329,7 +329,7 @@ def test_cigar_hit_ref_cut_add_prop_exhaustive(hit, cut_point):
         assert left + right == hit
 
 
-lstrip_reference_cases = [
+lstrip_query_cases = [
     ('9M@1->1', '9M@1->1'),
     ('5M6D@1->1', '5M6D@1->1'),
     ('6D5M@1->1', '6D5M@1->1'),
@@ -352,7 +352,7 @@ def test_cigar_hit_ref_cut_add_prop_exhaustive(hit, cut_point):
 ]
 
 
-rstrip_reference_cases = [
+rstrip_query_cases = [
     ('9M@1->1', '9M@1->1'),
     ('5M6D@1->1', '5M6D@1->1'),
     ('5M6I@1->1', '5M@1->1'),
@@ -375,7 +375,7 @@ def test_cigar_hit_ref_cut_add_prop_exhaustive(hit, cut_point):
 ]
 
 
-lstrip_query_cases = [
+lstrip_reference_cases = [
     ('9M@1->1', '9M@1->1'),
     ('5M6D@1->1', '5M6D@1->1'),
     ('6D5M@1->1', '5M@1->7'),
@@ -398,7 +398,7 @@ def test_cigar_hit_ref_cut_add_prop_exhaustive(hit, cut_point):
 ]
 
 
-rstrip_query_cases = [
+rstrip_reference_cases = [
     ('9M@1->1', '9M@1->1'),
     ('5M6D@1->1', '5M@1->1'),
     ('5M6I@1->1', '5M6I@1->1'),
@@ -423,22 +423,22 @@ def test_cigar_hit_ref_cut_add_prop_exhaustive(hit, cut_point):
 
 strip_prop_cases_all = \
     [x[0] for x in cigar_hit_ref_cut_cases] + \
-    [x[0] for x in lstrip_reference_cases] + \
-    [x[0] for x in rstrip_reference_cases]
+    [x[0] for x in lstrip_query_cases] + \
+    [x[0] for x in rstrip_query_cases]
 
 
-@pytest.mark.parametrize('hit, expected', lstrip_reference_cases)
+@pytest.mark.parametrize('hit, expected', lstrip_query_cases)
 def test_cigar_hit_lstrip_reference(hit, expected):
     hit = parsed_hit(hit)
     expected = parsed_hit(expected)
-    assert expected == hit.lstrip_reference()
+    assert expected == hit.lstrip_query()
 
 
-@pytest.mark.parametrize('hit, expected', rstrip_reference_cases)
+@pytest.mark.parametrize('hit, expected', rstrip_query_cases)
 def test_cigar_hit_rstrip_reference(hit, expected):
     hit = parsed_hit(hit)
     expected = parsed_hit(expected)
-    assert expected == hit.rstrip_reference()
+    assert expected == hit.rstrip_query()
 
 
 
@@ -449,8 +449,8 @@ def test_cigar_hit_reference_strip_combines_with_connect(hit):
     for cut_point in range(hit.r_st - 1, hit.r_ei):
         left, right = hit.cut_reference(cut_point + hit.epsilon)
 
-        left = left.rstrip_reference()
-        right = right.lstrip_reference()
+        left = left.rstrip_query()
+        right = right.lstrip_query()
 
         assert left.connect(right).coordinate_mapping.ref_to_query \
             == hit.coordinate_mapping.ref_to_query
@@ -463,8 +463,8 @@ def test_cigar_hit_reference_strip_combines_with_add(hit):
     for cut_point in range(hit.r_st - 1, hit.r_ei):
         left, right = hit.cut_reference(cut_point + hit.epsilon)
 
-        left = left.rstrip_reference()
-        right = right.lstrip_reference()
+        left = left.rstrip_query()
+        right = right.lstrip_query()
 
         if left.touches(right):
             assert left + right == hit
@@ -474,53 +474,53 @@ def test_cigar_hit_reference_strip_combines_with_add(hit):
 def test_cigar_hit_reference_strip_never_crashes(hit):
     hit = parsed_hit(hit)
 
-    hit.rstrip_reference().lstrip_reference()
-    hit.lstrip_reference().rstrip_reference()
-    hit.lstrip_reference().lstrip_reference()
-    hit.rstrip_reference().rstrip_reference()
+    hit.rstrip_query().lstrip_query()
+    hit.lstrip_query().rstrip_query()
+    hit.lstrip_query().lstrip_query()
+    hit.rstrip_query().rstrip_query()
 
 
 @pytest.mark.parametrize('hit', strip_prop_cases_all)
 def test_cigar_hit_reference_strip_is_idempotent(hit):
     hit = parsed_hit(hit)
 
-    h1 = hit.rstrip_reference()
-    assert h1 == h1.rstrip_reference() == h1.rstrip_reference().rstrip_reference()
+    h1 = hit.rstrip_query()
+    assert h1 == h1.rstrip_query() == h1.rstrip_query().rstrip_query()
 
-    h1 = hit.lstrip_reference()
-    assert h1 == h1.lstrip_reference() == h1.lstrip_reference().lstrip_reference()
+    h1 = hit.lstrip_query()
+    assert h1 == h1.lstrip_query() == h1.lstrip_query().lstrip_query()
 
-    h1 = hit.lstrip_reference().rstrip_reference()
-    assert h1 == h1.lstrip_reference() == h1.rstrip_reference()
+    h1 = hit.lstrip_query().rstrip_query()
+    assert h1 == h1.lstrip_query() == h1.rstrip_query()
 
-    h1 = hit.rstrip_reference().lstrip_reference()
-    assert h1 == h1.rstrip_reference() == h1.lstrip_reference()
+    h1 = hit.rstrip_query().lstrip_query()
+    assert h1 == h1.rstrip_query() == h1.lstrip_query()
 
 
 @pytest.mark.parametrize('hit', strip_prop_cases_all)
 def test_cigar_hit_reference_strips_are_commutative(hit):
     hit = parsed_hit(hit)
 
     if len(hit.cigar.coordinate_mapping.ref_to_query) > 0:
-        assert hit.rstrip_reference().lstrip_reference() \
-            == hit.lstrip_reference().rstrip_reference()
+        assert hit.rstrip_query().lstrip_query() \
+            == hit.lstrip_query().rstrip_query()
     else:
-        assert hit.rstrip_reference().lstrip_reference().cigar \
-            == hit.lstrip_reference().rstrip_reference().cigar
+        assert hit.rstrip_query().lstrip_query().cigar \
+            == hit.lstrip_query().rstrip_query().cigar
 
 
-@pytest.mark.parametrize('hit, expected', lstrip_query_cases)
+@pytest.mark.parametrize('hit, expected', lstrip_reference_cases)
 def test_cigar_hit_lstrip_query(hit, expected):
     hit = parsed_hit(hit)
     expected = parsed_hit(expected)
-    assert expected == hit.lstrip_query()
+    assert expected == hit.lstrip_reference()
 
 
-@pytest.mark.parametrize('hit, expected', rstrip_query_cases)
+@pytest.mark.parametrize('hit, expected', rstrip_reference_cases)
 def test_cigar_hit_rstrip_query(hit, expected):
     hit = parsed_hit(hit)
     expected = parsed_hit(expected)
-    assert expected == hit.rstrip_query()
+    assert expected == hit.rstrip_reference()
 
 
 @pytest.mark.parametrize('hit', strip_prop_cases_all)
@@ -530,8 +530,8 @@ def test_cigar_hit_query_strip_combines_with_connect(hit):
     for cut_point in range(hit.r_st - 1, hit.r_ei):
         left, right = hit.cut_reference(cut_point + hit.epsilon)
 
-        left = left.rstrip_query()
-        right = right.lstrip_query()
+        left = left.rstrip_reference()
+        right = right.lstrip_reference()
 
         assert left.connect(right).coordinate_mapping.ref_to_query \
             == hit.coordinate_mapping.ref_to_query
@@ -544,8 +544,8 @@ def test_cigar_hit_query_strip_combines_with_add(hit):
     for cut_point in range(hit.r_st - 1, hit.r_ei):
         left, right = hit.cut_reference(cut_point + hit.epsilon)
 
-        left = left.rstrip_query()
-        right = right.lstrip_query()
+        left = left.rstrip_reference()
+        right = right.lstrip_reference()
 
         if left.touches(right):
             assert left + right == hit
@@ -555,39 +555,39 @@ def test_cigar_hit_query_strip_combines_with_add(hit):
 def test_cigar_hit_strips_work_together(hit):
     hit = parsed_hit(hit)
 
-    rstrip = str(hit.rstrip_query().rstrip_reference().cigar)
+    rstrip = str(hit.rstrip_reference().rstrip_query().cigar)
     assert not rstrip.endswith("I") and not rstrip.endswith("D")
-    lstrip = str(hit.lstrip_query().lstrip_reference().cigar)
+    lstrip = str(hit.lstrip_reference().lstrip_query().cigar)
     assert not lstrip.startswith("I") and not lstrip.startswith("D")
 
 
 @pytest.mark.parametrize('hit', strip_prop_cases_all)
 def test_cigar_hit_query_strip_is_idempotent(hit):
     hit = parsed_hit(hit)
 
-    h1 = hit.rstrip_query()
-    assert h1 == h1.rstrip_query() == h1.rstrip_query().rstrip_query()
+    h1 = hit.rstrip_reference()
+    assert h1 == h1.rstrip_reference() == h1.rstrip_reference().rstrip_reference()
 
-    h1 = hit.lstrip_query()
-    assert h1 == h1.lstrip_query() == h1.lstrip_query().lstrip_query()
+    h1 = hit.lstrip_reference()
+    assert h1 == h1.lstrip_reference() == h1.lstrip_reference().lstrip_reference()
 
-    h1 = hit.lstrip_query().rstrip_query()
-    assert h1 == h1.lstrip_query() == h1.rstrip_query()
+    h1 = hit.lstrip_reference().rstrip_reference()
+    assert h1 == h1.lstrip_reference() == h1.rstrip_reference()
 
-    h1 = hit.rstrip_query().lstrip_query()
-    assert h1 == h1.rstrip_query() == h1.lstrip_query()
+    h1 = hit.rstrip_reference().lstrip_reference()
+    assert h1 == h1.rstrip_reference() == h1.lstrip_reference()
 
 
 @pytest.mark.parametrize('hit', strip_prop_cases_all)
 def test_cigar_hit_query_strips_are_commutative(hit):
     hit = parsed_hit(hit)
 
     if len(hit.cigar.coordinate_mapping.ref_to_query) > 0:
-        assert hit.rstrip_query().lstrip_query() \
-            == hit.lstrip_query().rstrip_query()
+        assert hit.rstrip_reference().lstrip_reference() \
+            == hit.lstrip_reference().rstrip_reference()
     else:
-        assert hit.rstrip_query().lstrip_query().cigar \
-            == hit.lstrip_query().rstrip_query().cigar
+        assert hit.rstrip_reference().lstrip_reference().cigar \
+            == hit.lstrip_reference().rstrip_reference().cigar
 
 
 @pytest.mark.parametrize('hit, cut_point', [(x[0], x[1]) for x in cigar_hit_ref_cut_cases

micall/tests/test_contig_stitcher.py

@@ -543,7 +543,7 @@ def test_stitching_contig_with_small_covered_gap(exact_aligner, visualizer):
 
     assert len(visualizer().elements) > len(contigs)
 
-    assert all(x.seq == x.lstrip_query().rstrip_query().seq for x in results)
+    assert all(x.seq == x.lstrip().rstrip().seq for x in results)
     assert { contig.seq for contig in contigs } \
         == { contig.seq for contig in results }
 
@@ -568,10 +568,10 @@ def test_stitching_partial_align(exact_aligner, visualizer):
 
     assert len(visualizer().elements) > len(contigs)
 
-    assert all(x.seq != x.lstrip_query().rstrip_query().seq for x in results)
+    assert all(x.seq != x.lstrip().rstrip().seq for x in results)
 
     assert { contig.seq for contig in contigs } \
-        != { contig.lstrip_query().rstrip_query().seq for contig in results }
+        != { contig.lstrip().rstrip().seq for contig in results }
 
 
 def test_partial_align_consensus(exact_aligner, visualizer):
@@ -625,7 +625,7 @@ def test_stitching_partial_align_multiple_sequences(exact_aligner, visualizer):
     assert len(visualizer().elements) > len(contigs)
 
     assert { contig.seq for contig in contigs } \
-        != { contig.lstrip_query().rstrip_query().seq for contig in results }
+        != { contig.lstrip().rstrip().seq for contig in results }
 
 
 def test_partial_align_consensus_multiple_sequences(exact_aligner, visualizer):