Various tweaks to boost Python test coverage.

Author: jeromekelleher

python/CHANGELOG.rst

@@ -1,3 +1,18 @@
+--------------------
+[0.1.0] - 2019-XX-XX
+--------------------
+
+Initial release after separation from msprime 0.6.2.
+
+**Breaking changes**
+- Removal of the previously deprecated ``sort_tables``, ``simplify_tables``
+  and ``load_tables`` functions. All code should change to using corresponding
+  TableCollection methods.
+
+**New features**:
+
+**Bug fixes**:
+
 ----------------------
 [0.1.0a1] - 2019-01-19
 ----------------------

python/requirements/development.txt

@@ -16,3 +16,4 @@ svgwrite
 pyparsing 
 pysam
 PyVCF
+python_jsonschema_objects

python/tests/test_file_format.py

@@ -379,6 +379,12 @@ def test_no_version_number(self):
         root.close()
         self.assertRaises(ValueError, tskit.load_legacy, self.temp_file)
 
+    def test_unknown_legacy_version(self):
+        root = h5py.File(self.temp_file, "w")
+        root.attrs['format_version'] = (1024, 0)  # Arbitrary unknown version
+        root.close()
+        self.assertRaises(ValueError, tskit.load_legacy, self.temp_file)
+
 
 class TestDumpFormat(TestFileFormat):
     """

python/tests/test_highlevel.py

@@ -1484,6 +1484,25 @@ def test_tables_sequence_length_round_trip(self):
             new_ts = tables.tree_sequence()
             self.assertEqual(new_ts.sequence_length, sequence_length)
 
+    def test_migrations(self):
+        ts = msprime.simulate(
+            population_configurations=[
+                msprime.PopulationConfiguration(10),
+                msprime.PopulationConfiguration(10)],
+            migration_matrix=[[0, 1], [1, 0]],
+            random_seed=2,
+            record_migrations=True)
+        self.assertGreater(ts.num_migrations, 0)
+        migrations = list(ts.migrations())
+        self.assertEqual(len(migrations), ts.num_migrations)
+        for migration in migrations:
+            self.assertIn(migration.source, [0, 1])
+            self.assertIn(migration.dest, [0, 1])
+            self.assertGreater(migration.time, 0)
+            self.assertEqual(migration.left, 0)
+            self.assertEqual(migration.right, 1)
+            self.assertTrue(0 <= migration.node < ts.num_nodes)
+
 
 class TestFileUuid(HighLevelTestCase):
     """
@@ -2045,3 +2064,95 @@ def test_nonbinary(self):
         self.assertTrue(found)
         for _ in range(self.num_random_permutations):
             self.verify_random_permutation(ts)
+
+
+class SimpleContainersMixin(object):
+    """
+    Tests for the SimpleContainer classes.
+    """
+    def test_equality(self):
+        c1, c2 = self.get_instances(2)
+        self.assertTrue(c1 == c1)
+        self.assertFalse(c1 == c2)
+        self.assertFalse(c1 != c1)
+        self.assertTrue(c1 != c2)
+        c3, = self.get_instances(1)
+        self.assertTrue(c1 == c3)
+        self.assertFalse(c1 != c3)
+
+    def test_repr(self):
+        c, = self.get_instances(1)
+        self.assertGreater(len(repr(c)), 0)
+
+
+class TestIndividualContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Individual(id_=j, flags=j, location=[j], nodes=[j], metadata=b"x" * j)
+            for j in range(n)]
+
+
+class TestNodeContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Node(
+                id_=j, flags=j, time=j, population=j, individual=j, metadata=b"x" * j)
+            for j in range(n)]
+
+
+class TestEdgeContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Edge(left=j, right=j, parent=j, child=j) for j in range(n)]
+
+
+class TestSiteContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Site(
+                id_=j, position=j, ancestral_state="A" * j,
+                mutations=TestMutationContainer().get_instances(j),
+                metadata=b"x" * j)
+            for j in range(n)]
+
+
+class TestMutationContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Mutation(
+                id_=j, site=j, node=j, derived_state="A" * j, parent=j,
+                metadata=b"x" * j)
+            for j in range(n)]
+
+
+class TestMigrationContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Migration(left=j, right=j, node=j, source=j, dest=j, time=j)
+            for j in range(n)]
+
+
+class TestPopulationContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [tskit.Population(id_=j, metadata="x" * j) for j in range(n)]
+
+
+class TestProvenanceContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Provenance(id_=j, timestamp="x" * j, record="y" * j) for j in range(n)]
+
+
+class TestEdgesetContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Edgeset(left=j, right=j, parent=j, children=j) for j in range(n)]
+
+
+class TestVariantContainer(unittest.TestCase, SimpleContainersMixin):
+    def get_instances(self, n):
+        return [
+            tskit.Variant(
+                site=TestSiteContainer().get_instances(1)[0],
+                alleles=["A" * j, "T"], genotypes=np.zeros(j, dtype=np.int8))
+            for j in range(n)]

python/tskit/drawing.py

@@ -11,7 +11,7 @@
 try:
     import svgwrite
     _svgwrite_imported = True
-except ImportError:
+except ImportError:  # pragma: no cover
     _svgwrite_imported = False
 
 IS_PY2 = sys.version_info[0] < 3

python/tskit/exceptions.py

@@ -24,7 +24,7 @@
     VersionTooOldError.__doc__ = """
     The version of the file is too old and cannot be read by the library.
     """
-except AttributeError:
+except AttributeError:  # pragma: no cover
     # Python2 throws attribute error. Ignore.
     pass
 

python/tskit/trees.py

@@ -14,7 +14,7 @@
 import functools
 try:
     import concurrent.futures
-except ImportError:
+except ImportError:  # pragma: no cover
     # We're on Python2; any attempts to use futures are dealt with below.
     pass
 
@@ -339,6 +339,12 @@ def __init__(self, site, alleles, genotypes):
         self.position = site.position
         self.index = site.id
 
+    def __eq__(self, other):
+        return (
+            self.site == other.site and
+            self.alleles == other.alleles and
+            np.array_equal(self.genotypes, other.genotypes))
+
 
 class Edgeset(SimpleContainer):
     def __init__(self, left, right, parent, children):
@@ -1170,82 +1176,6 @@ def load(path):
         formats.raise_hdf5_format_error(path, e)
 
 
-def __load_tables(
-        nodes, edges, migrations=None, sites=None, mutations=None,
-        provenances=None, individuals=None, populations=None, sequence_length=0):
-    """
-    **This method is now deprecated. Please use TableCollection.tree_sequence()
-    instead**
-
-    Loads the tree sequence data from the specified table objects, and
-    returns the resulting :class:`.TreeSequence` object. These tables
-    must fulfil the properties required for an input tree sequence as
-    described in the :ref:`sec_valid_tree_sequence_requirements` section.
-
-    The ``sequence_length`` parameter determines the
-    :attr:`.TreeSequence.sequence_length` of the returned tree sequence. If it
-    is 0 or not specified, the value is taken to be the maximum right
-    coordinate of the input edges. This parameter is useful in degenerate
-    situations (such as when there are zero edges), but can usually be ignored.
-
-    :param NodeTable nodes: The :ref:`node table <sec_node_table_definition>`
-        (required).
-    :param EdgeTable edges: The :ref:`edge table <sec_edge_table_definition>`
-        (required).
-    :param MigrationTable migrations: The :ref:`migration table
-        <sec_migration_table_definition>` (optional).
-    :param SiteTable sites: The :ref:`site table <sec_site_table_definition>`
-        (optional; but if supplied, ``mutations`` must also be specified).
-    :param MutationTable mutations: The :ref:`mutation table
-        <sec_mutation_table_definition>` (optional; but if supplied, ``sites``
-        must also be specified).
-    :param ProvenanceTable provenances: The :ref:`provenance table
-        <sec_provenance_table_definition>` (optional).
-    :param IndividualTable individuals: The :ref:`individual table
-        <sec_individual_table_definition>` (optional).
-    :param PopulationTable populations: The :ref:`population table
-        <sec_population_table_definition>` (optional).
-    :param float sequence_length: The sequence length of the returned tree sequence. If
-        not supplied or zero this will be inferred from the set of edges.
-    :return: A :class:`.TreeSequence` consistent with the specified tables.
-    :rtype: TreeSequence
-    """
-    if sequence_length is None:
-        sequence_length = 0
-    if sequence_length == 0 and len(edges) > 0:
-        sequence_length = edges.right.max()
-    kwargs = {
-        "nodes": nodes.ll_table, "edges": edges.ll_table,
-        "sequence_length": sequence_length}
-    if migrations is not None:
-        kwargs["migrations"] = migrations.ll_table
-    else:
-        kwargs["migrations"] = _tskit.MigrationTable()
-    if sites is not None:
-        kwargs["sites"] = sites.ll_table
-    else:
-        kwargs["sites"] = _tskit.SiteTable()
-    if mutations is not None:
-        kwargs["mutations"] = mutations.ll_table
-    else:
-        kwargs["mutations"] = _tskit.MutationTable()
-    if provenances is not None:
-        kwargs["provenances"] = provenances.ll_table
-    else:
-        kwargs["provenances"] = _tskit.ProvenanceTable()
-    if individuals is not None:
-        kwargs["individuals"] = individuals.ll_table
-    else:
-        kwargs["individuals"] = _tskit.IndividualTable()
-    if populations is not None:
-        kwargs["populations"] = populations.ll_table
-    else:
-        kwargs["populations"] = _tskit.PopulationTable()
-
-    ll_tables = _tskit.TableCollection(**kwargs)
-    return TreeSequence.load_tables(tables.TableCollection(ll_tables=ll_tables))
-
-
 def parse_individuals(
         source, strict=True, encoding='utf8', base64_metadata=True, table=None):
     """
@@ -2460,7 +2390,7 @@ def genealogical_nearest_neighbours(self, focal, reference_sets, num_threads=0):
             return self._ll_tree_sequence.genealogical_nearest_neighbours(
                 focal, reference_sets)
         else:
-            if IS_PY2:
+            if IS_PY2:  # pragma: no cover
                 raise ValueError("Threads not supported on Python 2.")
             worker = functools.partial(
                 self._ll_tree_sequence.genealogical_nearest_neighbours,