Merge pull request #114 from jeromekelleher/py-0.1.4

Py 0.1.4

Author: jeromekelleher

docs/c-api.rst

@@ -163,11 +163,11 @@ ensure that it is a **released version**. Released versions are
 tagged on GitHub using the convention ``C_{VERSION}``. The code
 can either be downloaded from GitHub on the `releases page
 <https://github.com/tskit-dev/tskit/releases>`_ or checked out
-using git. For example, to check out the ``C_0.99.0`` release::
+using git. For example, to check out the ``C_0.99.1`` release::
 
     $ git clone https://github.com/tskit-dev/tskit.git
     $ cd tskit
-    $ git checkout C_0.99.0
+    $ git checkout C_0.99.1
 
 Git submodules may also be considered---see the
 `example <https://github.com/tskit-dev/tskit-build-examples/tree/master/meson>`_

python/CHANGELOG.rst

@@ -1,3 +1,17 @@
+--------------------
+[0.1.4] - 2019-02-01
+--------------------
+
+Minor feature update. Using the C API 0.99.1.
+
+**New features**
+
+- Add interface for setting TableCollection.sequence_length:
+  https://github.com/tskit-dev/tskit/issues/107
+- Add support for building and dropping TableCollection indexes:
+  https://github.com/tskit-dev/tskit/issues/108
+
+
 --------------------
 [0.1.3] - 2019-01-14
 --------------------

python/_tskitmodule.c

@@ -5372,6 +5372,25 @@ TableCollection_get_sequence_length(TableCollection *self, void *closure)
     return Py_BuildValue("f", self->tables->sequence_length);
 }
 
+static int
+TableCollection_set_sequence_length(TableCollection *self, PyObject *value, void *closure)
+{
+    int ret = -1;
+
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "Cannot delete the sequence_length attribute");
+        goto out;
+    }
+    if (! PyNumber_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "sequence_length must be a number");
+        goto out;
+    }
+    self->tables->sequence_length = PyFloat_AsDouble(value);
+    ret = 0;
+out:
+    return ret;
+}
+
 static PyObject *
 TableCollection_get_file_uuid(TableCollection *self, void *closure)
 {
@@ -5499,6 +5518,45 @@ TableCollection_deduplicate_sites(TableCollection *self)
     return ret;
 }
 
+static PyObject *
+TableCollection_build_index(TableCollection *self)
+{
+    int err;
+    PyObject *ret = NULL;
+
+    err = tsk_table_collection_build_index(self->tables, 0);
+    if (err != 0) {
+        handle_library_error(err);
+        goto out;
+    }
+    ret = Py_BuildValue("");
+out:
+    return ret;
+}
+
+static PyObject *
+TableCollection_drop_index(TableCollection *self)
+{
+    int err;
+    PyObject *ret = NULL;
+
+    err = tsk_table_collection_drop_index(self->tables, 0);
+    if (err != 0) {
+        handle_library_error(err);
+        goto out;
+    }
+    ret = Py_BuildValue("");
+out:
+    return ret;
+}
+
+static PyObject *
+TableCollection_has_index(TableCollection *self)
+{
+    bool has_index = tsk_table_collection_has_index(self->tables, 0);
+    return Py_BuildValue("i", (int) has_index);
+}
+
 /* Forward declaration */
 static PyTypeObject TableCollectionType;
 
@@ -5525,24 +5583,31 @@ static PyGetSetDef TableCollection_getsetters[] = {
     {"mutations", (getter) TableCollection_get_mutations, NULL, "The mutation table."},
     {"populations", (getter) TableCollection_get_populations, NULL, "The population table."},
     {"provenances", (getter) TableCollection_get_provenances, NULL, "The provenance table."},
-    {"sequence_length", (getter) TableCollection_get_sequence_length, NULL,
-        "The sequence length."},
+    {"sequence_length",
+        (getter) TableCollection_get_sequence_length,
+        (setter) TableCollection_set_sequence_length, "The sequence length."},
     {"file_uuid", (getter) TableCollection_get_file_uuid, NULL,
         "The UUID of the corresponding file."},
     {NULL}  /* Sentinel */
 };
 
 static PyMethodDef TableCollection_methods[] = {
     {"simplify", (PyCFunction) TableCollection_simplify, METH_VARARGS|METH_KEYWORDS,
-            "Simplifies for a given sample subset." },
+        "Simplifies for a given sample subset." },
     {"sort", (PyCFunction) TableCollection_sort, METH_VARARGS|METH_KEYWORDS,
-            "Sorts the tables to satisfy tree sequence requirements." },
+        "Sorts the tables to satisfy tree sequence requirements." },
     {"equals", (PyCFunction) TableCollection_equals, METH_VARARGS,
-            "Returns True if the parameter table collection is equal to this one." },
+        "Returns True if the parameter table collection is equal to this one." },
     {"compute_mutation_parents", (PyCFunction) TableCollection_compute_mutation_parents,
         METH_NOARGS, "Computes the mutation parents for a the tables." },
     {"deduplicate_sites", (PyCFunction) TableCollection_deduplicate_sites,
         METH_NOARGS, "Removes sites with duplicate positions." },
+    {"build_index", (PyCFunction) TableCollection_build_index,
+        METH_NOARGS, "Builds an index on the table collection." },
+    {"drop_index", (PyCFunction) TableCollection_drop_index,
+        METH_NOARGS, "Drops indexes." },
+    {"has_index", (PyCFunction) TableCollection_has_index,
+        METH_NOARGS, "Returns True if the TableCollection is indexed." },
     {NULL}  /* Sentinel */
 };
 

python/tests/test_lowlevel.py

@@ -156,6 +156,21 @@ def test_reference_deletion(self):
             for table in tables:
                 self.assertGreater(len(str(table)), 0)
 
+    def test_set_sequence_length_errors(self):
+        tables = _tskit.TableCollection(1)
+        with self.assertRaises(TypeError):
+            del tables.sequence_length
+        for bad_value in ["sdf", None, []]:
+            with self.assertRaises(TypeError):
+                tables.sequence_length = bad_value
+
+    def test_set_sequence_length(self):
+        tables = _tskit.TableCollection(1)
+        self.assertEqual(tables.sequence_length, 1)
+        for value in [-1, 1e6, 1e-22, 1000, 2**32, -10000]:
+            tables.sequence_length = value
+            self.assertEqual(tables.sequence_length, value)
+
 
 class TestTreeSequence(LowLevelTestCase):
     """

python/tests/test_tables.py

@@ -1536,6 +1536,89 @@ def test_uuid_empty(self):
         tables = tskit.TableCollection(sequence_length=1)
         self.assertIsNone(tables.file_uuid, None)
 
+    def test_empty_indexes(self):
+        tables = tskit.TableCollection(sequence_length=1)
+        self.assertFalse(tables.has_index())
+        tables.build_index()
+        self.assertTrue(tables.has_index())
+        tables.drop_index()
+        self.assertFalse(tables.has_index())
+
+    def test_index_unsorted(self):
+        tables = tskit.TableCollection(sequence_length=1)
+        tables.nodes.add_row(flags=1, time=0)
+        tables.nodes.add_row(flags=1, time=0)
+        tables.nodes.add_row(flags=1, time=0)
+        tables.nodes.add_row(flags=0, time=1)
+        tables.nodes.add_row(flags=0, time=2)
+        tables.edges.add_row(0, 1, 3, 0)
+        tables.edges.add_row(0, 1, 3, 1)
+        tables.edges.add_row(0, 1, 4, 3)
+        tables.edges.add_row(0, 1, 4, 2)
+
+        self.assertFalse(tables.has_index())
+        with self.assertRaises(tskit.LibraryError):
+            tables.build_index()
+        self.assertFalse(tables.has_index())
+        tables.sort()
+        tables.build_index()
+        self.assertTrue(tables.has_index())
+        ts = tables.tree_sequence()
+        self.assertEqual(ts.tables, tables)
+
+    def test_index_from_ts(self):
+        ts = msprime.simulate(10, random_seed=1)
+        tables = ts.dump_tables()
+        self.assertTrue(tables.has_index())
+        tables.drop_index()
+        self.assertFalse(tables.has_index())
+        ts = tables.tree_sequence()
+        self.assertEqual(ts.tables, tables)
+        self.assertFalse(tables.has_index())
+
+    def test_set_sequence_length_errors(self):
+        tables = tskit.TableCollection(1)
+        with self.assertRaises(AttributeError):
+            del tables.sequence_length
+        for bad_value in ["asdf", None, []]:
+            with self.assertRaises(TypeError):
+                tables.sequence_length = bad_value
+
+    def test_set_sequence_length(self):
+        tables = tskit.TableCollection(1)
+        for value in [-1, 100, 2**32, 1e-6]:
+            tables.sequence_length = value
+            self.assertEqual(tables.sequence_length, value)
+
+    def test_bad_sequence_length(self):
+        tables = msprime.simulate(10, random_seed=1).dump_tables()
+        self.assertEqual(tables.sequence_length, 1)
+        for value in [-1, 0, -0.99, 0.9999]:
+            tables.sequence_length = value
+            with self.assertRaises(tskit.LibraryError):
+                tables.tree_sequence()
+            with self.assertRaises(tskit.LibraryError):
+                tables.sort()
+            with self.assertRaises(tskit.LibraryError):
+                tables.build_index()
+            with self.assertRaises(tskit.LibraryError):
+                tables.compute_mutation_parents()
+            with self.assertRaises(tskit.LibraryError):
+                tables.simplify()
+            self.assertEqual(tables.sequence_length, value)
+
+    def test_sequence_length_longer_than_edges(self):
+        tables = msprime.simulate(10, random_seed=1).dump_tables()
+        tables.sequence_length = 2
+        ts = tables.tree_sequence()
+        self.assertEqual(ts.sequence_length, 2)
+        self.assertEqual(ts.num_trees, 2)
+        trees = ts.trees()
+        tree = next(trees)
+        self.assertGreater(len(tree.parent_dict), 0)
+        tree = next(trees)
+        self.assertEqual(len(tree.parent_dict), 0)
+
 
 class TestTableCollectionPickle(unittest.TestCase):
     """

python/tskit/__main__.py

@@ -0,0 +1,10 @@
+from __future__ import print_function
+from __future__ import division
+
+
+def main():
+    print("Not implemented yet; please be patient!!")
+
+
+if __name__ == "__main__":
+    main()

python/tskit/tables.py

@@ -1517,6 +1517,10 @@ def provenances(self):
     def sequence_length(self):
         return self.ll_tables.sequence_length
 
+    @sequence_length.setter
+    def sequence_length(self, sequence_length):
+        self.ll_tables.sequence_length = sequence_length
+
     @property
     def file_uuid(self):
         return self.ll_tables.file_uuid
@@ -1751,6 +1755,26 @@ def deduplicate_sites(self):
         self.ll_tables.deduplicate_sites()
         # TODO add provenance
 
+    def has_index(self):
+        """
+        Returns True if this TableCollection is indexed.
+        """
+        return bool(self.ll_tables.has_index())
+
+    def build_index(self):
+        """
+        Builds an index on this TableCollection. Any existing indexes are automatically
+        dropped.
+        """
+        self.ll_tables.build_index()
+
+    def drop_index(self):
+        """
+        Drops an indexes present on this table collection. If the table are not currently
+        indexed this method has no effect.
+        """
+        self.ll_tables.drop_index()
+
 
 # Pickle support. See copyreg registration for this function below.
 def _table_collection_pickle(tables):