Update upstream source from tag 'upstream/0.12.0_b0+dfsg'

Update to upstream version '0.12.0~b0+dfsg'
with Debian dir 92f448758e24d5e4b53a9474665fea15b0286295

2 files changed, 74 insertions, 2 deletions

diff --git a/silx/io/test/test_dictdump.py b/silx/io/test/test_dictdump.py
index ab8161d..12e13f5 100644
--- a/silx/io/test/test_dictdump.py
+++ b/silx/io/test/test_dictdump.py
@@ -1,6 +1,6 @@
 # coding: utf-8
 # /*##########################################################################
-# Copyright (C) 2016-2017 European Synchrotron Radiation Facility
+# Copyright (C) 2016-2019 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -49,9 +49,11 @@ def tree():
     return defaultdict(tree)
 
 
+inhabitants = 160215
+
 city_attrs = tree()
 city_attrs["Europe"]["France"]["Grenoble"]["area"] = "18.44 km2"
-city_attrs["Europe"]["France"]["Grenoble"]["inhabitants"] = 160215
+city_attrs["Europe"]["France"]["Grenoble"]["inhabitants"] = inhabitants
 city_attrs["Europe"]["France"]["Grenoble"]["coordinates"] = [45.1830, 5.7196]
 city_attrs["Europe"]["France"]["Tourcoing"]["area"]
 
@@ -129,6 +131,16 @@ class TestH5ToDict(unittest.TestCase):
         self.assertIn("coordinates", ddict["Grenoble"])
         self.assertIn("area", ddict["Grenoble"])
 
+    def testAsArrayTrue(self):
+        """Test with asarray=True, the default"""
+        ddict = h5todict(self.h5_fname, path="/Europe/France/Grenoble")
+        self.assertTrue(numpy.array_equal(ddict["inhabitants"], numpy.array(inhabitants)))
+
+    def testAsArrayFalse(self):
+        """Test with asarray=False"""
+        ddict = h5todict(self.h5_fname, path="/Europe/France/Grenoble", asarray=False)
+        self.assertEqual(ddict["inhabitants"], inhabitants)
+
 
 class TestDictToJson(unittest.TestCase):
     def setUp(self):
diff --git a/silx/io/test/test_fabioh5.py b/silx/io/test/test_fabioh5.py
index afd1b49..7b4abbc 100644..100755
--- a/silx/io/test/test_fabioh5.py
+++ b/silx/io/test/test_fabioh5.py
@@ -238,6 +238,66 @@ class TestFabioH5(unittest.TestCase):
         self.assertIn(data.dtype.kind, ['d', 'f'])
         self.assertGreaterEqual(data.dtype.itemsize, 64 / 8)
 
+    def test_mixed_float_size__scalar(self):
+        # We expect to have a precision of 32 bits
+        float_list = [u'1.2', u'1.3001']
+        expected_float_result = [1.2, 1.3001]
+        data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
+        fabio_image = None
+        for float_item in float_list:
+            header = {"float_item": float_item}
+            if fabio_image is None:
+                fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
+            else:
+                fabio_image.appendFrame(data=data, header=header)
+        h5_image = fabioh5.File(fabio_image=fabio_image)
+        data = h5_image["/scan_0/instrument/detector_0/others/float_item"]
+        # At worst a float32
+        self.assertIn(data.dtype.kind, ['d', 'f'])
+        self.assertLessEqual(data.dtype.itemsize, 32 / 8)
+        for computed, expected in zip(data, expected_float_result):
+            numpy.testing.assert_almost_equal(computed, expected, 5)
+
+    def test_mixed_float_size__list(self):
+        # We expect to have a precision of 32 bits
+        float_list = [u'1.2 1.3001']
+        expected_float_result = numpy.array([[1.2, 1.3001]])
+        data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
+        fabio_image = None
+        for float_item in float_list:
+            header = {"float_item": float_item}
+            if fabio_image is None:
+                fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
+            else:
+                fabio_image.appendFrame(data=data, header=header)
+        h5_image = fabioh5.File(fabio_image=fabio_image)
+        data = h5_image["/scan_0/instrument/detector_0/others/float_item"]
+        # At worst a float32
+        self.assertIn(data.dtype.kind, ['d', 'f'])
+        self.assertLessEqual(data.dtype.itemsize, 32 / 8)
+        for computed, expected in zip(data, expected_float_result):
+            numpy.testing.assert_almost_equal(computed, expected, 5)
+
+    def test_mixed_float_size__list_of_list(self):
+        # We expect to have a precision of 32 bits
+        float_list = [u'1.2 1.3001', u'1.3001 1.3001']
+        expected_float_result = numpy.array([[1.2, 1.3001], [1.3001, 1.3001]])
+        data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
+        fabio_image = None
+        for float_item in float_list:
+            header = {"float_item": float_item}
+            if fabio_image is None:
+                fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
+            else:
+                fabio_image.appendFrame(data=data, header=header)
+        h5_image = fabioh5.File(fabio_image=fabio_image)
+        data = h5_image["/scan_0/instrument/detector_0/others/float_item"]
+        # At worst a float32
+        self.assertIn(data.dtype.kind, ['d', 'f'])
+        self.assertLessEqual(data.dtype.itemsize, 32 / 8)
+        for computed, expected in zip(data, expected_float_result):
+            numpy.testing.assert_almost_equal(computed, expected, 5)
+
     def test_ub_matrix(self):
         """Data from mediapix.edf"""
         header = {}