Merge pull request #1264 from benjeffery/interval

Replace interval numbers with attr names

Author: mergify[bot]

python/tests/test_combinatorics.py

@@ -1169,11 +1169,11 @@ def verify_tree_sequence_splits(self, ts):
             resolved_ts = binary_tree.tree_sequence
             assert resolved_ts.sequence_length == ts.sequence_length
             assert resolved_ts.num_trees <= 3
-            if tree.interval[0] == 0:
+            if tree.interval.left == 0:
                 assert resolved_ts.num_trees == 2
                 null_tree = resolved_ts.last()
                 assert null_tree.num_roots == ts.num_samples
-            elif tree.interval[1] == ts.sequence_length:
+            elif tree.interval.right == ts.sequence_length:
                 assert resolved_ts.num_trees == 2
                 null_tree = resolved_ts.first()
                 assert null_tree.num_roots == ts.num_samples

python/tests/test_haplotype_matching.py

@@ -765,9 +765,9 @@ def traceback(self):
 
         rr_index = len(self.recombination_required) - 1
         for site in reversed(self.ts.sites()):
-            while tree.interval[0] > site.position:
+            while tree.interval.left > site.position:
                 tree.prev()
-            assert tree.interval[0] <= site.position < tree.interval[1]
+            assert tree.interval.left <= site.position < tree.interval.right
 
             # Fill in the recombination tree
             j = rr_index

python/tests/test_highlevel.py

@@ -135,8 +135,8 @@ def get_gap_examples():
         ts = insert_gap(ts, x, gap)
         found = False
         for t in ts.trees():
-            if t.interval[0] == x:
-                assert t.interval[1] == x + gap
+            if t.interval.left == x:
+                assert t.interval.right == x + gap
                 assert len(t.parent_dict) == 0
                 found = True
         assert found
@@ -638,7 +638,7 @@ def verify_edge_diffs(self, ts):
                 edge_ids.append(edge.id)
                 assert edge == ts.edge(edge.id)
                 children[edge.parent].add(edge.child)
-            while tree.interval[1] <= left:
+            while tree.interval.right <= left:
                 tree = next(trees)
             assert left >= tree.interval.left
             assert right <= tree.interval.right
@@ -729,7 +729,9 @@ def test_breakpoints(self):
         for ts in get_example_tree_sequences():
             breakpoints = ts.breakpoints(as_array=True)
             assert breakpoints.shape == (ts.num_trees + 1,)
-            other = np.fromiter(iter([0] + [t.interval[1] for t in ts.trees()]), float)
+            other = np.fromiter(
+                iter([0] + [t.interval.right for t in ts.trees()]), float
+            )
             assert np.array_equal(other, breakpoints)
             # in case downstream code has
             for j, x in enumerate(ts.breakpoints()):
@@ -2498,7 +2500,7 @@ def test_apis(self):
         assert t1.get_num_mutations() == t1.num_mutations
         assert t1.get_parent_dict() == t1.parent_dict
         assert t1.get_total_branch_length() == t1.total_branch_length
-        assert t1.span == t1.interval[1] - t1.interval[0]
+        assert t1.span == t1.interval.right - t1.interval.left
         # node properties
         root = t1.get_root()
         for node in t1.nodes():
@@ -2608,15 +2610,15 @@ def test_seek(self):
             for j in range(L):
                 tree.seek(j)
                 index = tree.index
-                assert tree.interval[0] <= j < tree.interval[1]
-                tree.seek(tree.interval[0])
+                assert tree.interval.left <= j < tree.interval.right
+                tree.seek(tree.interval.left)
                 assert tree.index == index
-                if tree.interval[1] < L:
-                    tree.seek(tree.interval[1])
+                if tree.interval.right < L:
+                    tree.seek(tree.interval.right)
                     assert tree.index == index + 1
             for j in reversed(range(L)):
                 tree.seek(j)
-                assert tree.interval[0] <= j < tree.interval[1]
+                assert tree.interval.left <= j < tree.interval.right
         for bad_position in [-1, L, L + 1, -L]:
             with pytest.raises(ValueError):
                 tree.seek(bad_position)
@@ -2628,9 +2630,9 @@ def test_interval(self):
         assert breakpoints[0] == 0
         assert breakpoints[-1] == ts.sequence_length
         for i, tree in enumerate(ts.trees()):
-            assert tree.interval[0] == pytest.approx(breakpoints[i])
             assert tree.interval.left == pytest.approx(breakpoints[i])
-            assert tree.interval[1] == pytest.approx(breakpoints[i + 1])
+            assert tree.interval.left == pytest.approx(breakpoints[i])
+            assert tree.interval.right == pytest.approx(breakpoints[i + 1])
             assert tree.interval.right == pytest.approx(breakpoints[i + 1])
             assert tree.interval.span == pytest.approx(
                 breakpoints[i + 1] - breakpoints[i]

python/tests/test_ibd.py

@@ -106,7 +106,7 @@ def get_ibd(
             prev_dict = t.get_parent_dict()
 
         for interval in interval_list:
-            if min_length == 0 or interval[1] - interval[0] > min_length:
+            if min_length == 0 or interval.right - interval.left > min_length:
                 orig_id = node_map.index(node_id)
                 ibd_list.append(ibd.Segment(interval[0], interval[1], orig_id))
 

python/tests/test_phylo_formats.py

@@ -283,8 +283,8 @@ def verify_nexus_topology(self, treeseq):
             assert len(split_name) == 2
             start = float(split_name[0][4:])
             end = float(split_name[1])
-            self.assertAlmostEqual(tree.interval[0], start)
-            self.assertAlmostEqual(tree.interval[1], end)
+            self.assertAlmostEqual(tree.interval.left, start)
+            self.assertAlmostEqual(tree.interval.right, end)
 
             self.verify_tree(nexus_tree, tree)
 

python/tests/test_stats.py

@@ -356,7 +356,7 @@ def naive_genealogical_nearest_neighbours(ts, focal, reference_sets):
     ]
     for _ in range(ts.num_trees):
         trees = list(map(next, tree_iters))
-        length = trees[0].interval[1] - trees[0].interval[0]
+        length = trees[0].interval.right - trees[0].interval.left
         for j, u in enumerate(focal):
             focal_node_set = reference_set_map[u]
             # delta(u) = 1 if u exists in any of the reference sets; 0 otherwise
@@ -687,7 +687,7 @@ def exact_genealogical_nearest_neighbours(ts, focal, reference_sets):
             v = trees[0].parent(v)
         if v != tskit.NULL:
             # The length is only reported where the statistic is defined.
-            L[trees[0].index] = trees[0].interval[1] - trees[0].interval[0]
+            L[trees[0].index] = trees[0].interval.right - trees[0].interval.left
             for k, tree in enumerate(trees):
                 # If the focal node is in the current set, we subtract its
                 # contribution from the numerator
@@ -763,8 +763,8 @@ def verify(self, ts, reference_sets, focal=None):
 
         G, lefts, rights = local_gnn(ts, focal, reference_sets)
         for tree in ts.trees():
-            assert lefts[tree.index] == tree.interval[0]
-            assert rights[tree.index] == tree.interval[1]
+            assert lefts[tree.index] == tree.interval.left
+            assert rights[tree.index] == tree.interval.right
 
         for j, u in enumerate(focal):
             T, L = exact_genealogical_nearest_neighbours(ts, u, reference_sets)

python/tests/test_topology.py

@@ -1036,14 +1036,14 @@ def ts_kc_distance(ts1, ts2, lambda_=0):
     tree1_iter = ts1.trees(sample_lists=True)
     tree1 = next(tree1_iter)
     for tree2 in ts2.trees(sample_lists=True):
-        while tree1.interval[1] < tree2.interval[1]:
-            span = tree1.interval[1] - left
+        while tree1.interval.right < tree2.interval.right:
+            span = tree1.interval.right - left
             total += tree1.kc_distance(tree2, lambda_) * span
 
-            left = tree1.interval[1]
+            left = tree1.interval.right
             tree1 = next(tree1_iter)
-        span = tree2.interval[1] - left
-        left = tree2.interval[1]
+        span = tree2.interval.right - left
+        left = tree2.interval.right
         total += tree1.kc_distance(tree2, lambda_) * span
 
     return total / ts1.sequence_length
@@ -1167,7 +1167,7 @@ def check_kc_tree_sequence_inputs(ts1, ts2):
     tree1_iter = ts1.trees(sample_lists=True)
     tree1 = next(tree1_iter)
     for tree2 in ts2.trees(sample_lists=True):
-        while tree1.interval[1] < tree2.interval[1]:
+        while tree1.interval.right < tree2.interval.right:
             check_kc_tree_inputs(tree1, tree2)
             tree1 = next(tree1_iter)
         check_kc_tree_inputs(tree1, tree2)
@@ -2260,7 +2260,10 @@ def test_many_trees(self):
         redundant_t = next(redundant_trees)
         comparisons = 0
         for t in ts.trees():
-            while redundant_t is not None and redundant_t.interval[1] <= t.interval[1]:
+            while (
+                redundant_t is not None
+                and redundant_t.interval.right <= t.interval.right
+            ):
                 assert t.parent_dict == redundant_t.parent_dict
                 comparisons += 1
                 redundant_t = next(redundant_trees, None)
@@ -5018,8 +5021,8 @@ def verify_multiroot_internal_samples(self, ts, keep_unary=False):
         trees2 = ts2.trees()
         t2 = next(trees2)
         for t1 in ts1.trees():
-            assert t2.interval[0] <= t1.interval[0]
-            assert t2.interval[1] >= t1.interval[1]
+            assert t2.interval.left <= t1.interval.left
+            assert t2.interval.right >= t1.interval.right
             pairs = itertools.combinations(ts1.samples(), 2)
             for pair in pairs:
                 mapped_pair = [node_map[u] for u in pair]
@@ -5029,7 +5032,7 @@ def verify_multiroot_internal_samples(self, ts, keep_unary=False):
                     assert mrca2 == tskit.NULL
                 else:
                     assert node_map[mrca1] == mrca2
-            if t2.interval[1] == t1.interval[1]:
+            if t2.interval.right == t1.interval.right:
                 t2 = next(trees2, None)
 
     def test_single_tree(self):
@@ -6184,9 +6187,9 @@ def verify(self, ts, sample_nodes, ancestral_nodes):
             ):
                 # Loop through trees.
                 for tree in ts.trees():
-                    if tree.interval[0] >= current_right:
+                    if tree.interval.left >= current_right:
                         break
-                    while tree.interval[1] <= current_left:
+                    while tree.interval.right <= current_left:
                         tree.next()
                     # Check that the most recent ancestor of the descendants is the
                     # current_ancestor.
@@ -7796,7 +7799,7 @@ def verify_ltrim(self, source_ts, trimmed_ts):
             assert source_tree.parent_dict == trimmed_tree.parent_dict
             self.assertAlmostEqual(source_tree.span, trimmed_tree.span)
             self.assertAlmostEqual(
-                source_tree.interval[0], trimmed_tree.interval[0] + deleted_span
+                source_tree.interval.left, trimmed_tree.interval.left + deleted_span
             )
             self.verify_sites(source_tree, trimmed_tree, deleted_span)
 
@@ -8063,7 +8066,7 @@ def ts_missing_middle(self):
     def test_is_isolated(self):
         ts, missing_from, missing_to = self.ts_missing_middle()
         for tree in ts.trees():
-            if tree.interval[1] > missing_from and tree.interval[0] < missing_to:
+            if tree.interval.right > missing_from and tree.interval.left < missing_to:
                 assert tree.is_isolated(0)
                 assert not tree.is_isolated(1)
             else: