Merge pull request #42 from jeromekelleher/bump-python-coverage

Bump python coverage

Author: jeromekelleher

c/tsk_genotypes.c

@@ -180,7 +180,7 @@ tsk_hapgen_get_haplotype(tsk_hapgen_t *self, tsk_id_t sample_index, char **haplo
 {
     int ret = 0;
 
-    if (sample_index >= (tsk_id_t) self->num_samples) {
+    if (sample_index < 0 || sample_index >= (tsk_id_t) self->num_samples) {
         ret = TSK_ERR_OUT_OF_BOUNDS;
         goto out;
     }

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/_tskitmodule.c

@@ -195,9 +195,6 @@ handle_library_error(int err)
             case TSK_ERR_FILE_FORMAT:
                 PyErr_SetString(TskitFileFormatError, tsk_strerror(err));
                 break;
-            case TSK_ERR_OUT_OF_BOUNDS:
-                PyErr_SetString(PyExc_IndexError, tsk_strerror(err));
-                break;
             default:
                 PyErr_SetString(TskitLibraryError, tsk_strerror(err));
         }
@@ -6167,6 +6164,7 @@ TreeSequence_get_pairwise_diversity(TreeSequence *self, PyObject *args, PyObject
             &PyList_Type, &py_samples)) {
         goto out;
     }
+    /* TODO Change this to reading numpy array */
     if (parse_sample_ids(py_samples, self->tree_sequence, &num_samples, &samples) != 0) {
         goto out;
     }
@@ -7893,16 +7891,16 @@ HaplotypeGenerator_get_haplotype(HaplotypeGenerator *self, PyObject *args)
     int err;
     PyObject *ret = NULL;
     char *haplotype;
-    unsigned int sample_id;
+    int sample_id;
 
     if (HaplotypeGenerator_check_state(self) != 0) {
         goto out;
     }
-    if (!PyArg_ParseTuple(args, "I", &sample_id)) {
+    if (!PyArg_ParseTuple(args, "i", &sample_id)) {
         goto out;
     }
     err = tsk_hapgen_get_haplotype(self->haplotype_generator,
-            (uint32_t) sample_id, &haplotype);
+            (tsk_id_t) sample_id, &haplotype);
     if (err != 0) {
         handle_library_error(err);
         goto out;
@@ -8203,6 +8201,9 @@ LdCalculator_get_r2(LdCalculator *self, PyObject *args)
     return ret;
 }
 
+/* TODO this implementation is brittle and cumbersome. Replace with something that
+ * returns a numpy array directly. Passing in the memory is a premature optimisation.
+ */
 static PyObject *
 LdCalculator_get_r2_array(LdCalculator *self, PyObject *args, PyObject *kwds)
 {

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/tests/test_lowlevel.py

@@ -88,7 +88,7 @@ def verify_tree_dict(self, n, pi):
                 self.assertGreaterEqual(num_children[j], 2)
 
     def get_example_tree_sequence(self):
-        ts = msprime.simulate(10, recombination_rate=0.1, random_seed=1)
+        ts = msprime.simulate(10, recombination_rate=0.1, mutation_rate=1, random_seed=1)
         return ts.ll_tree_sequence
 
     def get_example_tree_sequences(self):
@@ -288,8 +288,8 @@ def test_get_samples(self):
     def test_pairwise_diversity(self):
         for ts in self.get_example_tree_sequences():
             for bad_type in ["", None, {}]:
-                self.assertRaises(
-                    TypeError, ts.get_pairwise_diversity, bad_type)
+                self.assertRaises(TypeError, ts.get_pairwise_diversity, bad_type)
+                self.assertRaises(TypeError, ts.get_pairwise_diversity, [0, bad_type])
             self.assertRaises(
                 ValueError, ts.get_pairwise_diversity, [])
             self.assertRaises(
@@ -419,6 +419,121 @@ def test_iterator(self):
         self.verify_iterator(_tskit.TreeIterator(tree))
 
 
+class TestVcfConverter(LowLevelTestCase):
+    """
+    Tests for the VcfConverter class.
+    """
+    def test_uninitialised_tree_sequence(self):
+        ts = _tskit.TreeSequence()
+        self.assertRaises(ValueError, _tskit.VcfConverter, ts)
+
+    def test_constructor(self):
+        self.assertRaises(TypeError, _tskit.VcfConverter)
+        self.assertRaises(TypeError, _tskit.VcfConverter, None)
+        ts = self.get_example_tree_sequence()
+        self.assertRaises(TypeError, _tskit.VcfConverter, ts, ploidy="xyt")
+        self.assertRaises(ValueError, _tskit.VcfConverter, ts, ploidy=0)
+        self.assertRaises(TypeError, _tskit.VcfConverter, ts, contig_id=None)
+        self.assertRaises(ValueError, _tskit.VcfConverter, ts, contig_id="")
+
+    def test_iterator(self):
+        ts = self.get_example_tree_sequence()
+        self.verify_iterator(_tskit.VcfConverter(ts))
+
+
+class TestVariantGenerator(LowLevelTestCase):
+    """
+    Tests for the VariantGenerator class.
+    """
+    def test_uninitialised_tree_sequence(self):
+        ts = _tskit.TreeSequence()
+        self.assertRaises(ValueError, _tskit.VariantGenerator, ts)
+
+    def test_constructor(self):
+        self.assertRaises(TypeError, _tskit.VariantGenerator)
+        self.assertRaises(TypeError, _tskit.VariantGenerator, None)
+        ts = self.get_example_tree_sequence()
+        self.assertRaises(ValueError, _tskit.VariantGenerator, ts, samples={})
+        self.assertRaises(
+            _tskit.LibraryError, _tskit.VariantGenerator, ts, samples=[-1, 2])
+
+    def test_iterator(self):
+        ts = self.get_example_tree_sequence()
+        self.verify_iterator(_tskit.VariantGenerator(ts))
+
+
+class TestHaplotypeGenerator(LowLevelTestCase):
+    """
+    Tests for the HaplotypeGenerator class.
+    """
+    def test_uninitialised_tree_sequence(self):
+        ts = _tskit.TreeSequence()
+        self.assertRaises(ValueError, _tskit.HaplotypeGenerator, ts)
+
+    def test_constructor(self):
+        self.assertRaises(TypeError, _tskit.HaplotypeGenerator)
+        self.assertRaises(TypeError, _tskit.HaplotypeGenerator, None)
+
+    def test_bad_id(self):
+        ts = self.get_example_tree_sequence()
+        hg = _tskit.HaplotypeGenerator(ts)
+        n = ts.get_num_samples()
+        for bad_id in [-1, n, n + 1]:
+            with self.assertRaises(_tskit.LibraryError):
+                hg.get_haplotype(bad_id)
+
+
+class TestLdCalculator(LowLevelTestCase):
+    """
+    Tests for the LdCalculator class.
+    """
+    def test_uninitialised_tree_sequence(self):
+        ts = _tskit.TreeSequence()
+        self.assertRaises(ValueError, _tskit.LdCalculator, ts)
+
+    def test_constructor(self):
+        self.assertRaises(TypeError, _tskit.LdCalculator)
+        self.assertRaises(TypeError, _tskit.LdCalculator, None)
+
+    def test_get_r2(self):
+        ts = self.get_example_tree_sequence()
+        calc = _tskit.LdCalculator(ts)
+        n = ts.get_num_sites()
+        for bad_id in [-1, n, n + 1]:
+            with self.assertRaises(_tskit.LibraryError):
+                calc.get_r2(0, bad_id)
+            with self.assertRaises(_tskit.LibraryError):
+                calc.get_r2(bad_id, 0)
+
+    def test_get_r2_array(self):
+        ts = self.get_example_tree_sequence()
+        calc = _tskit.LdCalculator(ts)
+
+        self.assertRaises(TypeError, calc.get_r2_array)
+        self.assertRaises(TypeError, calc.get_r2_array, None)
+        # Doesn't support buffer protocol, so raises typeerror
+        self.assertRaises(TypeError, calc.get_r2_array, None, 0)
+
+        n = ts.get_num_sites()
+        self.assertGreater(n, 2)
+        with self.assertRaises(BufferError):
+            calc.get_r2_array(bytes(100), 0)
+
+        buff = bytearray(1024)
+        with self.assertRaises(ValueError):
+            calc.get_r2_array(buff, 0, max_distance=-1)
+        with self.assertRaises(ValueError):
+            calc.get_r2_array(buff, 0, direction=1000)
+        # TODO this API is poor, we should explicitly catch these negative
+        # size errors.
+        for bad_max_mutations in [-2, -3, -2**32]:
+            with self.assertRaises(BufferError):
+                calc.get_r2_array(buff, 0, max_mutations=bad_max_mutations)
+        for bad_start_pos in [-1, n, n + 1]:
+            with self.assertRaises(_tskit.LibraryError):
+                calc.get_r2_array(buff, bad_start_pos)
+
+
 class TestTree(LowLevelTestCase):
     """
     Tests on the low-level sparse tree interface.
@@ -450,6 +565,31 @@ def test_flags(self):
                 self.assertRaises(ValueError, st.get_right_sample, 0)
                 self.assertRaises(ValueError, st.get_next_sample, 0)
 
+    def test_site_errors(self):
+        ts = self.get_example_tree_sequence()
+        for bad_index in [-1, ts.get_num_sites(), ts.get_num_sites() + 1]:
+            self.assertRaises(IndexError, ts.get_site, bad_index)
+
+    def test_mutation_errors(self):
+        ts = self.get_example_tree_sequence()
+        for bad_index in [-1, ts.get_num_mutations(), ts.get_num_mutations() + 1]:
+            self.assertRaises(IndexError, ts.get_mutation, bad_index)
+
+    def test_individual_errors(self):
+        ts = self.get_example_tree_sequence()
+        for bad_index in [-1, ts.get_num_individuals(), ts.get_num_individuals() + 1]:
+            self.assertRaises(IndexError, ts.get_individual, bad_index)
+
+    def test_population_errors(self):
+        ts = self.get_example_tree_sequence()
+        for bad_index in [-1, ts.get_num_populations(), ts.get_num_populations() + 1]:
+            self.assertRaises(IndexError, ts.get_population, bad_index)
+
+    def test_provenance_errors(self):
+        ts = self.get_example_tree_sequence()
+        for bad_index in [-1, ts.get_num_provenances(), ts.get_num_provenances() + 1]:
+            self.assertRaises(IndexError, ts.get_provenance, bad_index)
+
     def test_sites(self):
         for ts in self.get_example_tree_sequences():
             st = _tskit.Tree(ts)

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