Merge pull request #343 from jgrewe/bindings

Bindings

LGTM

nixio/pycore/dimensions.py

@@ -241,8 +241,8 @@ def index_of(self, position):
             return len(ticks) - 1
 
         ticks = np.array(ticks)
-        pidxs = np.flatnonzero((ticks - position) >= 0)
-        return pidxs[0]
+        pidxs = np.flatnonzero((ticks - position) <= 0)
+        return pidxs[-1]
 
     def tick_at(self, index):
         """

nixio/pycore/multi_tag.py

@@ -121,7 +121,7 @@ def _get_offset_and_count(self, data, index):
                     unit = units[idx]
                 c = self._pos_to_idx(offset.item(idx) + extent.item(idx),
                                      unit, dim) - offsets[idx]
-                counts.append(c if c > 1 else 1)
+                counts.append(c + 1 if c >= 1 else 1)
         else:
             counts = [1]*len(data.dimensions)
 

nixio/pycore/tag.py

@@ -248,12 +248,12 @@ def _get_offset_and_count(self, data):
                 unit = self.units[idx]
             else:
                 unit = None
-            o = self._pos_to_idx(position[idx], unit, dim)
+            o = self._pos_to_idx(pos, unit, dim)
             offset.append(o)
             if idx < len(extent):
                 ext = extent[idx]
                 c = self._pos_to_idx(pos + ext, unit, dim) - o
-                count.append(c if c > 1 else 1)
+                count.append(c + 1 if c >= 1 else 1)
             else:
                 count.append(1)
         return tuple(offset), tuple(count)

nixio/test/test_backend_compatibility.py

@@ -417,9 +417,9 @@ def test_multi_tag_features(self):
 
         self.check_attributes(wfdata, rfdata)
 
-        wfdataview = wmtag.retrieve_feature_data(9, 0)
-        rfdataview = rmtag.retrieve_feature_data(9, 0)
-        self.check_attributes(wfdataview, rfdataview)
+       # wfdataview = wmtag.retrieve_feature_data(9, 0)
+       # rfdataview = rmtag.retrieve_feature_data(9, 0)
+        #self.check_attributes(wfdataview, rfdataview)
 
         wfdataview = wmtag.retrieve_feature_data(0, 2)
         rfdataview = rmtag.retrieve_feature_data(0, 2)
@@ -446,12 +446,12 @@ def test_multi_tag_references(self):
         dim = da.append_sampled_dimension(interval)
         dim.unit = "s"
 
-        pos = blk.create_data_array("pos1", "positions", data=np.array([[0]]))
+        pos = blk.create_data_array("pos1", "positions", data=np.array([0.]).reshape((1, 1)))
         pos.append_set_dimension()
         pos.append_set_dimension()
         pos.unit = "ms"
         ext = blk.create_data_array("ext1", "extents",
-                                    data=np.array([[2000]]))
+                                    data=np.array([2000]).reshape((1,1)))
         ext.append_set_dimension()
         ext.append_set_dimension()
         ext.unit = "ms"
@@ -466,6 +466,8 @@ def test_multi_tag_references(self):
 
         for wmtag, rmtag in zip(self.write_file.blocks[0].multi_tags,
                                 self.read_file.blocks[0].multi_tags):
+            temp = wmtag.retrieve_data(0, 0)[:]
+            temp2 = rmtag.retrieve_data(0, 0)[:]
             np.testing.assert_almost_equal(wmtag.retrieve_data(0, 0)[:],
                                            rmtag.retrieve_data(0, 0)[:])
 

nixio/test/test_dimensions.py

@@ -113,7 +113,7 @@ def test_range_dimension(self):
         assert(self.range_dim.ticks == other)
 
         assert(self.range_dim.index_of(0.) == 0)
-        assert(self.range_dim.index_of(10.) == (np.ceil(10./3.14)))
+        assert(self.range_dim.index_of(10.) == (np.floor(10./3.14)))
         assert(self.range_dim.index_of(100.) == 9)
         assert(self.range_dim.index_of(-100.) == 0)
 

nixio/test/test_multi_tag.py

@@ -265,12 +265,12 @@ def test_multi_tag_retrieve_data(self):
         dim.unit = 's'
 
         pos = block.create_data_array('pos1', 'positions',
-                                      data=np.array([0.]).reshape((1, 1)))
+                                      data=np.array([0.]).reshape(1, 1))
         pos.append_set_dimension()
         pos.append_set_dimension()
         pos.unit = 'ms'
         ext = block.create_data_array('ext1', 'extents',
-                                      data=np.array([2000.]).reshape((1, 1)))
+                                      data=np.array([2000.]).reshape(1, 1))
         ext.append_set_dimension()
         ext.append_set_dimension()
         ext.unit = 'ms'
@@ -280,18 +280,18 @@ def test_multi_tag_retrieve_data(self):
         mtag.units = ['ms']
         mtag.references.append(da)
 
-        assert(mtag.retrieve_data(0, 0).shape == (2000,))
-        assert(np.array_equal(y[:2000], mtag.retrieve_data(0, 0)[:]))
+        assert(mtag.retrieve_data(0, 0).shape == (2001,))
+        assert(np.array_equal(y[:2001], mtag.retrieve_data(0, 0)[:]))
 
         # get by name
         data = mtag.retrieve_data(0, da.name)
-        assert(data.shape == (2000,))
-        assert(np.array_equal(y[:2000], data[:]))
+        assert(data.shape == (2001,))
+        assert(np.array_equal(y[:2001], data[:]))
 
         # get by id
         data = mtag.retrieve_data(0, da.id)
-        assert(data.shape == (2000,))
-        assert(np.array_equal(y[:2000], data[:]))
+        assert(data.shape == (2001,))
+        assert(np.array_equal(y[:2001], data[:]))
 
         # multi dimensional data
         sample_iv = 1.0
@@ -303,7 +303,7 @@ def test_multi_tag_retrieve_data(self):
         pos.append_set_dimension()
         pos.append_set_dimension()
         ext = self.block.create_data_array("ext", "test",
-                                           data=[[2, 5, 2],
+                                           data=[[1, 5, 2],
                                                  [0, 4, 1]])
         ext.append_set_dimension()
         ext.append_set_dimension()
@@ -336,14 +336,14 @@ def test_multi_tag_retrieve_data(self):
         assert(len(posdata.shape) == 3)
         assert(posdata.shape == (1, 1, 1))
         assert(np.isclose(posdata[0, 0, 0], data[1, 1, 0]))
-
+ 
         segdata = segtag.retrieve_data(0, 0)
         assert(len(segdata.shape) == 3)
-        assert(segdata.shape == (2, 5, 2))
+        assert(segdata.shape == (2, 6, 2))
 
         segdata = segtag.retrieve_data(1, 0)
         assert(len(segdata.shape) == 3)
-        assert(segdata.shape == (1, 4, 1))
+        assert(segdata.shape == (1, 5, 1))
 
     def test_multi_tag_feature_data(self):
         index_data = self.block.create_data_array("indexed feature data",
@@ -402,8 +402,10 @@ def test_multi_tag_feature_data(self):
         assert(feat_data.size == 10)
         assert(np.sum(feat_data) == 55)
 
-        data_view = self.feature_tag.retrieve_feature_data(9, 0)
-        assert(np.sum(data_view[:, :]) == 9055)
+        # disabled, don't understand how it could ever have worked,
+        # there are only 3 positions
+        # data_view = self.feature_tag.retrieve_feature_data(9, 0)
+        # assert(np.sum(data_view[:, :]) == 9055)
 
         # untagged feature
         data_view = self.feature_tag.retrieve_feature_data(0, 2)
@@ -427,8 +429,9 @@ def test_multi_tag_feature_data(self):
         assert(feat_data.size == 10)
         assert(np.sum(feat_data) == 55)
 
-        data_view = self.feature_tag.retrieve_feature_data(9, index_data.name)
-        assert(np.sum(data_view[:, :]) == 9055)
+        # disabled, there are only 3 positions
+        #data_view = self.feature_tag.retrieve_feature_data(9, index_data.name)
+        #assert(np.sum(data_view[:, :]) == 9055)
 
         # tagged feature
         data_view = self.feature_tag.retrieve_feature_data(0, tagged_data.name)

nixio/test/test_tag.py

@@ -211,22 +211,22 @@ def test_tag_retrieve_data(self):
 
         segdata = segtag.retrieve_data(0)
         assert(len(segdata.shape) == 3)
-        assert(segdata.shape == (1, 6, 2))
+        assert(segdata.shape == (1, 7, 2))
 
         # retrieve data by id and name
         posdata = postag.retrieve_data(da.name)
         assert(len(posdata.shape) == 3)
         assert(posdata.shape == (1, 1, 1))
         segdata = segtag.retrieve_data(da.name)
         assert(len(segdata.shape) == 3)
-        assert(segdata.shape == (1, 6, 2))
+        assert(segdata.shape == (1, 7, 2))
 
         posdata = postag.retrieve_data(da.id)
         assert(len(posdata.shape) == 3)
         assert(posdata.shape == (1, 1, 1))
         segdata = segtag.retrieve_data(da.id)
         assert(len(segdata.shape) == 3)
-        assert(segdata.shape == (1, 6, 2))
+        assert(segdata.shape == (1, 7, 2))
 
     def test_tag_retrieve_feature_data(self):
         number_feat = self.block.create_data_array("number feature", "test",
@@ -262,15 +262,15 @@ def test_tag_retrieve_feature_data(self):
         data3 = pos_tag.retrieve_feature_data(2)
 
         assert(data1.size == 1)
-        assert(data2.size == 2)
+        assert(data2.size == 3)
         assert(data3.size == len(ramp_data))
 
         # get by name
         data1 = pos_tag.retrieve_feature_data(number_feat.name)
         data2 = pos_tag.retrieve_feature_data(ramp_feat.name)
 
         assert(data1.size == 1)
-        assert(data2.size == 2)
+        assert(data2.size == 3)
 
 
 @unittest.skipIf(skip_cpp, "HDF5 backend not available.")

src/PyDataArray.cpp

@@ -59,7 +59,17 @@ void setPolynomCoefficients(DataArray& da, const std::vector<double>& pc) {
         da.polynomCoefficients(boost::none);
 }
 
+SetDimension dataArrayAppendSetDimension(DataArray& da) {
+  return da.appendSetDimension();
+}
+
+SampledDimension dataArrayAppendSampledDimension(DataArray& da, const double sampling_interval){
+    return da.appendSampledDimension(sampling_interval);
+}
 
+RangeDimension dataArrayAppendRangeDimension(DataArray& da, const std::vector<double>& ticks) {
+    return da.appendRangeDimension(ticks);
+}
 // Dimensions
 
 PyObject* getDimension(const DataArray& da, size_t index) {
@@ -88,8 +98,6 @@ PyObject* getDimension(const DataArray& da, size_t index) {
 
 void PyDataArray::do_export() {
 
-
-
     PyEntityWithSources<base::IDataArray>::do_export("DataArray");
     class_<DataArray, bases<base::EntityWithSources<base::IDataArray>, DataSet>>("DataArray")
         .add_property("label",
@@ -118,11 +126,11 @@ void PyDataArray::do_export() {
              doc::data_array_create_range_dimension)
         .def("create_alias_range_dimension", &DataArray::createAliasRangeDimension,
              doc::data_array_create_alias_range_dimension)
-        .def("append_set_dimension", &DataArray::appendSetDimension,
+        .def("append_set_dimension", dataArrayAppendSetDimension,
              doc::data_array_append_set_dimension)
-        .def("append_sampled_dimension", &DataArray::appendSampledDimension,
+        .def("append_sampled_dimension", dataArrayAppendSampledDimension,
              doc::data_array_append_sampled_dimension)
-        .def("append_range_dimension", &DataArray::appendRangeDimension,
+        .def("append_range_dimension", dataArrayAppendRangeDimension,
              doc::data_array_append_range_dimension)
         .def("append_alias_range_dimension", &DataArray::appendAliasRangeDimension,
              doc::data_array_append_alias_range_dimension)

src/PyDimensions.cpp

@@ -88,6 +88,15 @@ std::vector<double> getRangeDimensionAxis2(RangeDimension& dim, const size_t cou
     return dim.axis(count, start_index);
 }
 
+ndsize_t getSampledDimensionIndexOf(SampledDimension& dim, const double position) {
+  return dim.indexOf(position);
+}
+
+
+ndsize_t getRangeDimensionIndexOf(RangeDimension& dim, const double position) {
+  return dim.indexOf(position);
+}
+
 void PyDimensions::do_export() {
 
     class_<SampledDimension>("SampledDimension")
@@ -105,7 +114,7 @@ void PyDimensions::do_export() {
                       OPT_GETTER(double, SampledDimension, offset),
                       setSampledDimensionOffset)
         .def("position_at", &SampledDimension::positionAt, doc::sampled_dimension_position_at)
-        .def("index_of", &SampledDimension::indexOf, doc::sampled_dimension_index_of)
+        .def("index_of", getSampledDimensionIndexOf, doc::sampled_dimension_index_of)
         .def("axis", getSampledDimensionAxis1, doc::sampled_dimension_axis)
         .def("axis", getSampledDimensionAxis2, doc::sampled_dimension_axis)
         ;
@@ -121,7 +130,7 @@ void PyDimensions::do_export() {
         .add_property("ticks",
                       GETTER(std::vector<double>, RangeDimension, ticks),
                       REF_SETTER(std::vector<double>, RangeDimension, ticks))
-        .def("index_of", &RangeDimension::indexOf, doc::range_dimension_index_of)
+        .def("index_of", getRangeDimensionIndexOf, doc::range_dimension_index_of)
         .def("tick_at", &RangeDimension::tickAt, doc::range_dimension_tick_at)
         .def("axis", getRangeDimensionAxis1, doc::range_dimension_axis)
         .def("axis", getRangeDimensionAxis2, doc::range_dimension_axis)

src/PyFile.cpp

@@ -36,7 +36,7 @@ File open(std::string path, std::string mode = "a") {
     } else if (mode == "r") {
         nixmode = FileMode::ReadOnly;
     } else {
-        // TODO: Raise error
+      throw std::invalid_argument("File::open: invalid file mode flag (valid flags are: a, w, r for read-write, overwrite and read-only, respectively)!");
     }
     return File::open(path, nixmode);
 }

src/PyTag.cpp

@@ -62,7 +62,8 @@ Feature createNewFeature(Tag& st, const DataArray &data, const std::string& link
         lt = LinkType::Untagged;
     else if (link_type == "Indexed")
         lt = LinkType::Indexed;
-    // TODO: Throw error
+    else
+      throw std::invalid_argument("Tag::createNewFeature: invalid link type (Possible types: Tagged, Untagged or Indexed)!");
 
     return st.createFeature(data, lt);
 }

src/core.cc

@@ -2,10 +2,10 @@
 #include <boost/optional/optional.hpp>
 
 #include <nix.hpp>
-#include <transmorgify.hpp>
-#include <accessors.hpp>
+#include "transmorgify.hpp"
+#include "accessors.hpp"
 
-#include <PyEntity.hpp>
+#include "PyEntity.hpp"
 
 using namespace boost::python;
 using namespace nix;

src/transmorgify.hpp

@@ -56,7 +56,7 @@ struct vector_transmogrify {
 
         std::vector<T>* vec= static_cast<std::vector<T> *>(raw);
 
-        for(size_t index = 0; index < length; index++) {
+        for(int index = 0; index < length; index++) {
             vec->push_back(extract<T>(PySequence_GetItem(obj, index)));
         }