tomwer 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

tomwer/core/process/reconstruction/test/test_axis_params.py

@@ -1,6 +1,9 @@
 import os
 import pytest
-from tomwer.core.process.reconstruction.axis.params import AxisResource
+from tomwer.core.process.reconstruction.axis.params import (
+    AxisResource,
+    AxisCalculationInput,
+)
 from tomwer.core.utils.scanutils import MockHDF5
 import numpy
 
@@ -22,7 +25,8 @@ def test_axis_resource(tmp_path):
     first_proj = list(scan.projections.keys())[0]
     data_url = scan.projections[first_proj]
 
-    axis_resource = AxisResource(data_url)
+    axis_resource = AxisResource(url=data_url)
+    assert axis_resource.data is not None
 
     with pytest.raises(TypeError):
         axis_resource.normalize_data(scan=None, log_=True)
@@ -34,4 +38,22 @@ def test_axis_resource(tmp_path):
 
     assert isinstance(axis_resource.normalized_data_paganin, numpy.ndarray)
 
-    assert isinstance(axis_resource.normalized_data_paganin, numpy.ndarray)
+    assert isinstance(str(axis_resource), str)
+    axis_resource.data = None
+    assert axis_resource is not None
+
+
+def test_AxisCalculationInput():
+    """test all class AxisCalculationInput which is a bit 'malformed'"""
+    assert (
+        AxisCalculationInput.from_value("transmission_withpag")
+        is AxisCalculationInput.transmission_pag
+    )
+    assert (
+        AxisCalculationInput.from_value("transmission_nopag")
+        is AxisCalculationInput.transmission
+    )
+    assert (
+        AxisCalculationInput.from_value("transmission")
+        is AxisCalculationInput.transmission
+    )

tomwer/core/process/reconstruction/test/test_darkref_copy.py

@@ -1,7 +1,9 @@
 import os
+import numpy
+import pytest
+from silx.io.dictdump import dicttoh5
 from tomwer.core.process.reconstruction.darkref.darkrefscopy import DarkRefsCopy
 from tomwer.core.utils.scanutils import MockHDF5
-import pytest
 
 
 @pytest.mark.parametrize(
@@ -82,3 +84,117 @@ def test_register_and_copy_darks_and_flats(
     elif process_only_dkrf_scan_without_raw:
         assert scan_without_raw.load_reduced_darks() not in (None, {})
         assert scan_without_raw.load_reduced_flats() not in (None, {})
+
+
+def test_save_reduced_frames_to_be_copied(tmp_path):
+    """
+    test save_flats_to_be_copied and save_darks_to_be_copied functions
+    """
+    # create raw data
+    from tomoscan.scanbase import ReducedFramesInfos
+    from silx.io.url import DataUrl
+
+    raw_data = tmp_path / "raw_data"
+    raw_data.mkdir()
+    dark_file_path = os.path.join(raw_data, "darks.h5")
+    darks_dict = {
+        "0": numpy.linspace(0, 100, 10000).reshape(100, 100),
+        ReducedFramesInfos.COUNT_TIME_KEY: numpy.array(
+            [
+                0.2,
+            ]
+        ),
+        ReducedFramesInfos.MACHINE_ELECT_CURRENT_KEY: numpy.array(
+            [
+                12.2,
+            ]
+        ),
+    }
+
+    dicttoh5(
+        darks_dict,
+        h5file=dark_file_path,
+        h5path="entry0000/darks",
+        update_mode="modify",
+        mode="a",
+    )
+
+    flat_file_path = os.path.join(raw_data, "flats.hdf5")
+    flats_dict = {
+        "0": numpy.linspace(0, 100, 10000).reshape(100, 100),
+        "200": numpy.ones((100, 100)).reshape(100, 100),
+        ReducedFramesInfos.COUNT_TIME_KEY: numpy.array([0.2, 0.3]),
+        ReducedFramesInfos.MACHINE_ELECT_CURRENT_KEY: numpy.array([12.2, 12.1]),
+    }
+
+    dicttoh5(
+        flats_dict,
+        h5file=flat_file_path,
+        h5path="entry0000/flats",
+        update_mode="modify",
+        mode="a",
+    )
+
+    raw_darks_url_1 = DataUrl(
+        file_path=dark_file_path,
+        data_path="entry0000",
+    )
+    raw_darks_url_2 = DataUrl(
+        file_path=dark_file_path,
+        data_path="entry0000/darks",
+    )
+    raw_darks_url_3 = DataUrl(
+        file_path=dark_file_path,
+        data_path="",
+    )
+
+    assert (
+        DarkRefsCopy.get_reduced_frame_data(
+            url=raw_darks_url_1, reduced_target="darks"
+        ).keys()
+        == darks_dict.keys()
+    )
+    assert (
+        DarkRefsCopy.get_reduced_frame_data(
+            url=raw_darks_url_2, reduced_target="darks"
+        ).keys()
+        == darks_dict.keys()
+    )
+    assert (
+        DarkRefsCopy.get_reduced_frame_data(
+            url=raw_darks_url_3, reduced_target="darks"
+        ).keys()
+        != darks_dict.keys()
+    )
+
+    flat_darks_url_1 = DataUrl(
+        file_path=flat_file_path,
+        data_path="entry0000",
+    )
+    flat_darks_url_2 = DataUrl(
+        file_path=flat_file_path,
+        data_path="entry0000/flats",
+    )
+    flat_darks_url_3 = DataUrl(
+        file_path=flat_file_path,
+        data_path="",
+    )
+
+    assert (
+        DarkRefsCopy.get_reduced_frame_data(
+            url=flat_darks_url_1, reduced_target="flats"
+        ).keys()
+        == flats_dict.keys()
+    )
+    assert (
+        DarkRefsCopy.get_reduced_frame_data(
+            url=flat_darks_url_2, reduced_target="flats"
+        ).keys()
+        == flats_dict.keys()
+    )
+    assert (
+        DarkRefsCopy.get_reduced_frame_data(
+            url=flat_darks_url_3, reduced_target="flats"
+        ).keys()
+        != flats_dict.keys()
+    )

tomwer/core/process/script/python.py

@@ -32,6 +32,8 @@ from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.core.utils.volumeutils import volume_identifier_to_volume
 import tomwer.version
 import logging
 import code
@@ -40,22 +42,29 @@ import code
 _logger = logging.getLogger(__name__)
 
 
-class PythonScript(Task, input_names=("data",), output_names=("data",)):
+class PythonScript(
+    Task, optional_input_names=("data", "volume"), output_names=("data", "volume")
+):
     def run(self):
-        scan = self.inputs.data
+        # load data
+        scan = data_identifier_to_scan(self.inputs.data)
         if isinstance(scan, dict):
             scan = ScanFactory.create_scan_object_frm_dict(scan)
-        elif isinstance(scan, TomwerScanBase):
+        elif isinstance(scan, (TomwerScanBase, type(None))):
             scan = scan
         else:
             raise ValueError(
                 "input type of {}: {} is not managed" "".format(scan, type(scan))
             )
+        # load volume
+        volume = volume_identifier_to_volume(self.inputs.volume)
 
         cfg = self.get_configuration()
         interpreter = code.InteractiveConsole(locals={"in_data": scan})
+        interpreter = code.InteractiveConsole(locals={"in_volume": volume})
         interpreter.runcode(cfg["scriptText"])
-        res = interpreter.locals.get("out_data")
+        out_data = data_identifier_to_scan(interpreter.locals.get("out_data"))
+        out_volume = data_identifier_to_scan(interpreter.locals.get("out_volume"))
 
         # register process
         if isinstance(scan, EDFTomoScan):
@@ -63,25 +72,20 @@ class PythonScript(Task, input_names=("data",), output_names=("data",)):
         else:
             entry = scan.entry
 
-        results = {}
-        if res is not None:
-            if hasattr(res, "to_dict"):
-                results = res.to_dict()
-            else:
-                results = res
         try:
             self.register_process(
                 process_file=scan.process_file,
                 entry=entry,
                 configuration={"scriptText": self.get_configuration()["scriptText"]},
-                results=results,
+                results=None,
                 process_index=scan.pop_process_index(),
                 overwrite=True,
             )
         except Exception as e:
             _logger.error("Fail to register process. Error is " + str(e))
 
-        self.outputs.data = res
+        self.outputs.data = out_data
+        self.outputs.volume = out_volume
 
     @staticmethod
     def program_name():

tomwer/core/process/task.py

@@ -97,7 +97,9 @@ class BaseProcessInfo:
     @staticmethod
     def _get_lock(file_name):
         if file_name not in _MULTIPROCESSING_LOCKERS:
-            _MULTIPROCESSING_LOCKERS[file_name] = mult_manager.Lock()
+            _MULTIPROCESSING_LOCKERS[
+                file_name
+            ] = mult_manager.Lock()  # pylint: disable=E1101
         return _MULTIPROCESSING_LOCKERS[file_name]
 
     @staticmethod
@@ -133,12 +135,6 @@ class BaseProcessInfo:
         """
         self._output_values[key] = value
 
-    def key_exist(self, key):
-        for _output in self.outputs:
-            if _output.name == key:
-                return True
-        return False
-
     @staticmethod
     def program_name():
         """Name of the program used for this processing"""

tomwer/core/process/test/test_axis.py

@@ -34,7 +34,7 @@ import unittest
 import numpy
 import os
 import h5py
-from tomwer.test.utils import UtilsTest
+from tomwer.tests.utils import UtilsTest
 from tomwer.core.utils.scanutils import MockEDF, MockHDF5
 from ..reconstruction.axis.axis import AxisProcess
 from tomwer.core.scan.scanbase import TomwerScanBase

tomwer/core/process/test/test_dark_and_flat.py

@@ -33,13 +33,15 @@ import shutil
 import tempfile
 import unittest
 import numpy
-import time
 from tomwer.core.utils.scanutils import MockEDF, MockHDF5
-from tomwer.core.process.reconstruction.darkref.params import DKRFRP, Method as cMethod
+from tomwer.core.process.reconstruction.darkref.params import (
+    DKRFRP,
+    ReduceMethod as cMethod,
+)
 from tomwer.core.scan.scanbase import TomwerScanBase
 from ..reconstruction.darkref.darkrefs import DarkRefs
 from ..reconstruction.darkref.darkrefscopy import DarkRefsCopy
-from tomwer.test.utils import UtilsTest
+from tomwer.tests.utils import UtilsTest
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomoscan.esrf.scan.utils import get_data
 
@@ -145,11 +147,13 @@ class TestDarkRefEdf(unittest.TestCase):
 
     def setUp(self) -> None:
         self.scan_folder = tempfile.mkdtemp()
-        self.dark_data = numpy.array(
-            numpy.random.random(4 * 200 * 200) * 100, numpy.uint16
+        self.dark_data = numpy.array(  # pylint: disable=E1121
+            numpy.random.random(4 * 200 * 200) * 100,
+            dtype=numpy.uint16,
         ).reshape(4, 200, 200)
-        self.flat_data = numpy.array(
-            numpy.random.random(4 * 200 * 200) * 100, numpy.uint32
+        self.flat_data = numpy.array(  # pylint: disable=E1121
+            numpy.random.random(4 * 200 * 200) * 100,
+            dtype=numpy.uint32,
         ).reshape(4, 200, 200)
         self.scan = MockEDF.mockScan(
             scanID=self.scan_folder,
@@ -175,10 +179,10 @@ class TestDarkRefEdf(unittest.TestCase):
         Test darks are computed when only dark are requested
         """
         method_to_test = (
-            cMethod.median,
-            cMethod.average,
-            cMethod.first,
-            cMethod.last,
+            cMethod.MEDIAN,
+            cMethod.MEAN,
+            cMethod.FIRST,
+            cMethod.LAST,
         )
         th_results = (
             numpy.median(self.dark_data, axis=0),
@@ -198,13 +202,8 @@ class TestDarkRefEdf(unittest.TestCase):
                 )
 
                 self.recons_params.dark_calc_method = method
-                self.recons_params.ref_calc_method = cMethod.none
+                self.recons_params.flat_calc_method = cMethod.NONE
                 process.run()
-                self.assertTrue(os.path.exists(self.scan.process_file))
-                darks = DarkRefs.get_darks_frm_process_file(
-                    self.scan.process_file, entry="entry"
-                )
-                self.assertEqual(len(darks), 1)
                 numpy.testing.assert_array_almost_equal(
                     self.scan.reduced_darks[0], th_res.astype(numpy.uint16)
                 )
@@ -214,10 +213,10 @@ class TestDarkRefEdf(unittest.TestCase):
         Test flats are computed when only flat are requested
         """
         method_to_test = (
-            cMethod.median,
-            cMethod.average,
-            cMethod.first,
-            cMethod.last,
+            cMethod.MEDIAN,
+            cMethod.MEAN,
+            cMethod.FIRST,
+            cMethod.LAST,
         )
         th_results = (
             numpy.median(self.flat_data, axis=0),
@@ -229,8 +228,8 @@ class TestDarkRefEdf(unittest.TestCase):
             with self.subTest(method=method):
                 if os.path.exists(self.scan.process_file):
                     os.remove(self.scan.process_file)
-                self.recons_params.dark_calc_method = cMethod.none
-                self.recons_params.ref_calc_method = method
+                self.recons_params.dark_calc_method = cMethod.NONE
+                self.recons_params.flat_calc_method = method
                 process = DarkRefs(
                     inputs={
                         "dark_ref_params": self.recons_params,
@@ -238,11 +237,6 @@ class TestDarkRefEdf(unittest.TestCase):
                     }
                 )
                 process.run()
-                self.assertTrue(os.path.exists(self.scan.process_file))
-                flats = DarkRefs.get_flats_frm_process_file(
-                    self.scan.process_file, entry="entry"
-                )
-                self.assertEqual(len(flats), 1)
                 numpy.testing.assert_array_almost_equal(
                     self.scan.reduced_flats[0], th_res.astype(numpy.uint16)
                 )
@@ -277,33 +271,23 @@ class TestDarkRefNx(unittest.TestCase):
         """
         darks = self.scan.darks
         self.assertEqual(len(darks), 1)
-        dark_data = get_data(list(darks.values())[0])
 
-        method_to_test = (cMethod.average, cMethod.median, cMethod.last, cMethod.last)
+        method_to_test = (cMethod.MEAN, cMethod.MEDIAN, cMethod.FIRST, cMethod.LAST)
         for method in method_to_test:
             with self.subTest(method=method):
                 self.recons_params.dark_calc_method = method
-                self.recons_params.ref_calc_method = cMethod.none
+                self.recons_params.flat_calc_method = cMethod.NONE
                 process = DarkRefs(
                     inputs={
                         "dark_ref_params": self.recons_params,
                         "data": self.scan,
                     }
                 )
-                if os.path.exists(self.scan.process_file):
-                    os.remove(self.scan.process_file)
-
                 process.run()
-                self.assertTrue(os.path.exists(self.scan.process_file))
-                darks = DarkRefs.get_darks_frm_process_file(
-                    self.scan.process_file, entry=self.scan.entry
-                )
-                self.assertEqual(len(darks), 1)
-                self.assertTrue(numpy.allclose(darks[0], dark_data))
-                flats = DarkRefs.get_flats_frm_process_file(
-                    self.scan.process_file, entry=self.scan.entry
-                )
+                flats = self.scan.load_reduced_flats()
                 self.assertEqual(len(flats), 0)
+                darks = self.scan.load_reduced_darks()
+                self.assertEqual(len(darks), 1)
 
     def testFlat(self):
         """
@@ -321,26 +305,26 @@ class TestDarkRefNx(unittest.TestCase):
         self.recons_params.overwrite_dark = True
         self.recons_params.overwrite_ref = True
 
-        method_to_test = (cMethod.average, cMethod.median, cMethod.last, cMethod.last)
+        method_to_test = (cMethod.MEAN, cMethod.MEDIAN, cMethod.FIRST, cMethod.LAST)
         for method in method_to_test:
             with self.subTest(method=method):
-                if method is cMethod.median:
+                if method is cMethod.MEDIAN:
                     expected_res_s1 = numpy.median(data_flat_serie_1, axis=0)
                     expected_res_s2 = numpy.median(data_flat_serie_2, axis=0)
-                elif method is cMethod.average:
+                elif method is cMethod.MEAN:
                     expected_res_s1 = numpy.mean(data_flat_serie_1, axis=0)
                     expected_res_s2 = numpy.mean(data_flat_serie_2, axis=0)
-                elif method is cMethod.first:
+                elif method is cMethod.FIRST:
                     expected_res_s1 = data_flat_serie_1[0]
                     expected_res_s2 = data_flat_serie_2[0]
-                elif method is cMethod.last:
+                elif method is cMethod.LAST:
                     expected_res_s1 = data_flat_serie_1[-1]
                     expected_res_s2 = data_flat_serie_2[-1]
                 else:
                     raise ValueError("method not managed")
 
-                self.recons_params.dark_calc_method = cMethod.none
-                self.recons_params.ref_calc_method = method
+                self.recons_params.dark_calc_method = cMethod.NONE
+                self.recons_params.flat_calc_method = method
                 process = DarkRefs(
                     inputs={
                         "dark_ref_params": self.recons_params,
@@ -348,14 +332,10 @@ class TestDarkRefNx(unittest.TestCase):
                     }
                 )
                 process.run()
-                self.assertTrue(os.path.exists(self.scan.process_file))
-                darks = DarkRefs.get_darks_frm_process_file(
-                    self.scan.process_file, entry=self.scan.entry
-                )
+
+                darks = self.scan.load_reduced_darks()
                 self.assertEqual(len(darks), 0)
-                flats = DarkRefs.get_flats_frm_process_file(
-                    self.scan.process_file, entry=self.scan.entry
-                )
+                flats = self.scan.load_reduced_flats()
                 self.assertEqual(len(flats), 2)
                 self.assertTrue(1 in flats)
                 self.assertTrue(1521 in flats)
@@ -375,8 +355,8 @@ class TestDarkRefNx(unittest.TestCase):
         data_flat_serie_1 = [get_data(url) for url in url_flat_serie_1]
         data_flat_serie_2 = [get_data(url) for url in url_flat_serie_2]
 
-        self.recons_params.dark_calc_method = cMethod.average
-        self.recons_params.ref_calc_method = cMethod.median
+        self.recons_params.dark_calc_method = cMethod.MEAN
+        self.recons_params.flat_calc_method = cMethod.MEDIAN
         darks = self.scan.darks
         self.assertEqual(len(darks), 1)
         dark_data = get_data(list(darks.values())[0])
@@ -390,14 +370,9 @@ class TestDarkRefNx(unittest.TestCase):
             }
         )
         process.run()
-        self.assertTrue(os.path.exists(self.scan.process_file))
-        darks = DarkRefs.get_darks_frm_process_file(
-            self.scan.process_file, entry=self.scan.entry
-        )
+        darks = self.scan.load_reduced_darks()
+        flats = self.scan.load_reduced_flats()
         self.assertEqual(len(darks), 1)
-        flats = DarkRefs.get_flats_frm_process_file(
-            self.scan.process_file, entry=self.scan.entry
-        )
         self.assertEqual(len(flats), 2)
         self.assertTrue(0 in darks)
         self.assertTrue(1 in flats)
@@ -405,48 +380,3 @@ class TestDarkRefNx(unittest.TestCase):
         self.assertTrue(numpy.allclose(flats[1], expected_flats_s1))
         self.assertTrue(numpy.allclose(flats[1521], expected_flats_s2))
         self.assertTrue(numpy.allclose(darks[0], dark_data))
-
-    def testReprocessing(self):
-        """
-        Make sure computation is executed only when necessary
-        """
-        self.assertTrue(self.scan.reduced_darks in (None, {}))
-        self.assertTrue(self.scan.reduced_flats in (None, {}))
-        process = DarkRefs(
-            inputs={
-                "dark_ref_params": self.recons_params,
-                "data": self.scan,
-            }
-        )
-        process.run()
-        self.assertEqual(len(self.scan.reduced_darks), 1)
-        self.assertEqual(len(self.scan.reduced_flats), 2)
-
-        # test behavior if overwrite is False
-        self.recons_params.overwrite_dark = False
-        self.recons_params.overwrite_flat = False
-        self.scan.set_reduced_darks(None)
-        self.scan.set_reduced_flats(None)
-        timestamp_tomwer_processes = os.path.getmtime(self.scan.process_file)
-        time.sleep(1)
-        process.run()
-        self.assertEqual(
-            timestamp_tomwer_processes, os.path.getmtime(self.scan.process_file)
-        )
-        self.assertEqual(len(self.scan.reduced_darks), 1)
-        self.assertEqual(len(self.scan.reduced_flats), 2)
-
-        # test behavior if overwrite is True
-        self.recons_params.overwrite_dark = True
-        self.recons_params.overwrite_flat = True
-        self.scan.set_reduced_darks(None)
-        self.scan.set_reduced_flats(None)
-
-        timestamp_tomwer_processes = os.path.getmtime(self.scan.process_file)
-        time.sleep(1)
-        process.run()
-        self.assertNotEqual(
-            timestamp_tomwer_processes, os.path.getmtime(self.scan.process_file)
-        )
-        self.assertEqual(len(self.scan.reduced_darks), 1)
-        self.assertEqual(len(self.scan.reduced_flats), 2)

tomwer/core/process/test/test_data_listener.py

@@ -29,7 +29,6 @@ __date__ = "09/06/2020"
 
 
 import unittest
-import requests
 import tempfile
 import shutil
 import os
@@ -81,34 +80,6 @@ class JSONRPCClient:
             "id": 3,
         }
 
-    def execute(self):
-        url = "http://localhost:4000/jsonrpc"
-        timeout = 1.5
-
-        requests.post(
-            url,
-            json=self.sequence_started(
-                saving_file="saving_file.h5",
-                scan_title="my scan title",
-                entry_name="entry0000",
-                proposal_file="ihpropfile.h5",
-            ),
-            timeout=timeout,
-        ).json()
-        requests.post(
-            url, json=self.scan_started(scan_number="0001"), timeout=timeout
-        ).json()
-        requests.post(
-            url, json=self.scan_ended(scan_number="0001"), timeout=timeout
-        ).json()
-        requests.post(
-            url,
-            json=self.sequence_ended(
-                saving_file="saving_file.h5", entry_name="entry0000", suceed=True
-            ),
-            timeout=timeout,
-        ).json()
-
 
 class TestJsonRPCServer(unittest.TestCase):
     """test the json rpc server"""

tomwer/core/process/test/test_data_transfer.py

@@ -28,27 +28,27 @@ __license__ = "MIT"
 __date__ = "05/04/2019"
 
 
-import unittest
-import tempfile
-import shutil
-import time
+import gc
 import os
 import h5py
+import time
 import numpy
-
+import pytest
+import shutil
+import unittest
+import tempfile
 from tomoscan.io import HDF5File
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.utils.scanutils import MockEDF
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.process.control.scantransfer import ScanTransfer
-from tomwer.test.utils import UtilsTest
+from tomwer.tests.utils import UtilsTest
 from tomwer.synctools.rsyncmanager import RSyncManager
 from tomwer.core.process.control.datalistener import DataListener
 from nxtomomill.converter import from_h5_to_nx
 from nxtomomill.io.config.hdf5config import TomoHDF5Config
-import pytest
 from tomoscan.validator import is_valid_for_reconstruction
-from tomoscan.esrf.hdf5scan import ImageKey
+from tomoscan.esrf.scan.hdf5scan import ImageKey
 
 
 class TestDataTransferIO(unittest.TestCase):
@@ -146,6 +146,7 @@ class TestBlissDataTransfer(unittest.TestCase):
     def tearDown(self):
         shutil.rmtree(self.input_dir)
         shutil.rmtree(self.output_dir)
+        gc.collect()
 
     def testDataTransfer(self):
         """Make sure the data transfer is able to retrieve the scan,
@@ -153,10 +154,6 @@ class TestBlissDataTransfer(unittest.TestCase):
         Check that only the specific scan folders will be copy and removed
         and the other won't be affected.
         """
-        out_nx = os.path.join(
-            self.output_dir, "sample_29042021", "sample_29042021_1_1.nx"
-        )
-        self.assertFalse(os.path.exists(out_nx))
         out_proposal = os.path.join(self.output_dir, "ihpayno_sample.h5")
         self.assertFalse(os.path.exists(out_proposal))
         out_sample_file = os.path.join(
@@ -186,8 +183,7 @@ class TestBlissDataTransfer(unittest.TestCase):
         process.run()
 
         time.sleep(1)
-        self.assertTrue(os.path.exists(out_nx), f"{out_nx} does not exists")
-        # self.assertTrue(os.path.exists(out_proposal), f"{out_proposal} does not exists")
+        self.assertTrue(os.path.exists(out_proposal), f"{out_proposal} does not exists")
         self.assertTrue(
             os.path.exists(out_sample_file), f"{out_sample_file} does not exists"
         )

tomwer/core/process/test/test_nabu.py

@@ -32,7 +32,7 @@ import shutil
 import tempfile
 from glob import glob
 import unittest
-from tomwer.test.utils import UtilsTest
+from tomwer.tests.utils import UtilsTest
 from tomwer.core.process.reconstruction.nabu import nabuslices as nabu
 from tomwer.core.process.reconstruction.nabu import utils as nabuutils
 from tomwer.core.scan.scanfactory import ScanFactory

tomwer/core/process/test/test_normalization.py

@@ -63,7 +63,7 @@ class TestNormalization(unittest.TestCase):
         # step1: rewrite the detector data to simplify result check
         with h5py.File(self.scan.master_file, mode="a") as h5f:
             dataset = h5f["/entry/instrument/detector/data"]
-            assert dataset.shape == (2, 100, 100)
+            assert dataset.shape == (2, 100, 100)  # pylint: disable=E1101
             del h5f["/entry/instrument/detector/data"]
             h5f["/entry/instrument/detector/data"] = numpy.arange(
                 100 * 100 * 2

tomwer/core/process/visualization/liveslice.py

@@ -0,0 +1,6 @@
+from ewokscore.task import Task as EwoksTask
+
+
+class _LiveSlicePlaceHolder(EwoksTask, input_names=("data",), output_names=("data",)):
+    def run(self):
+        self.outputs.data = self.inputs.data