tomwer 1.3.27__py3-none-any.whl → 1.4.0rc0__py3-none-any.whl

tomwer/tests/test_ewoks/test_conversion.py

@@ -0,0 +1,104 @@
+import pytest
+from ewoksorange.bindings import owsconvert
+from tomwer.tests.datasets import TomwerCIDatasets
+
+
+ows_files_to_convert = ("from_nxtomo_to_volume.ows",)
+
+
+@pytest.mark.parametrize("orange_file_name", ows_files_to_convert)
+def test_conversion(orange_file_name):
+    """test orange file can be converted to ewoks Graph"""
+    scheme_file = TomwerCIDatasets.get_dataset(f"workflows/{orange_file_name}")
+    graph = owsconvert.ows_to_ewoks(scheme_file)
+    # make sure settings where correctly saved
+    assert len(graph.graph.nodes) == 7
+    assert len(graph.graph.edges) == 6
+    # make sure the settings are properly loaded
+    for node in graph.graph.nodes.values():
+        assert node["task_type"] == "class"
+        assert node["task_identifier"].startswith("tomwer")
+    # check settings of some specific nodes
+    # dark and flat
+    dark_flat_node = graph.graph.nodes["1"]
+    assert (
+        dark_flat_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.darkref.darkrefscopy.DarkRefsCopy"
+    )
+    assert "default_inputs" in dark_flat_node
+
+    def fileter_dark_ref_params(my_dict):
+        return my_dict["name"] == "dark_ref_params"
+
+    dark_ref_params_settings = tuple(
+        filter(fileter_dark_ref_params, dark_flat_node["default_inputs"])
+    )
+    assert len(dark_ref_params_settings) == 1
+    dark_ref_params_as_dict = dark_ref_params_settings[0]["value"]
+
+    assert "DOWHEN" in dark_ref_params_as_dict
+    assert "DARKCAL" in dark_ref_params_as_dict
+    assert "DKFILE" in dark_ref_params_as_dict
+
+    # axis
+    axis_node = graph.graph.nodes["2"]
+    assert (
+        axis_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.axis.axis.AxisTask"
+    )
+    assert "default_inputs" in axis_node
+    assert len(axis_node["default_inputs"]) == 2  # axis_params + gui metadata
+
+    def filter_axis_params(my_dict):
+        return my_dict["name"] == "axis_params"
+
+    axis_params_settings = tuple(
+        filter(filter_axis_params, axis_node["default_inputs"])
+    )
+    assert len(axis_params_settings) == 1
+    axis_params_as_dict = axis_params_settings[0]["value"]
+
+    assert "MODE" in axis_params_as_dict
+    assert "POSITION_VALUE" in axis_params_as_dict
+    assert "SINOGRAM_LINE" in axis_params_as_dict
+
+    # nabu slice
+    nabu_slice_node = graph.graph.nodes["3"]
+    assert (
+        nabu_slice_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.nabu.nabuslices.NabuSlicesTask"
+    )
+    assert "default_inputs" in axis_node
+
+    def filter_nabu_params(my_dict):
+        return my_dict["name"] == "nabu_params"
+
+    nabu_params_settings = tuple(
+        filter(filter_nabu_params, nabu_slice_node["default_inputs"])
+    )
+    assert len(nabu_params_settings) == 1
+    nabu_params_as_dict = nabu_params_settings[0]["value"]
+
+    assert "preproc" in nabu_params_as_dict
+    assert "phase" in nabu_params_as_dict
+    assert "tomwer_slices" in nabu_params_as_dict
+
+    # nabu volume
+    nabu_volume_node = graph.graph.nodes["4"]
+    assert (
+        nabu_volume_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.nabu.nabuvolume.NabuVolumeTask"
+    )
+    assert "default_inputs" in axis_node
+
+    def filter_nabu_volume_params(my_dict):
+        return my_dict["name"] == "nabu_volume_params"
+
+    nabu_volume_params_settings = tuple(
+        filter(filter_nabu_volume_params, nabu_volume_node["default_inputs"])
+    )
+    assert len(nabu_volume_params_settings) == 1
+    nabu_volume_params_as_dict = nabu_volume_params_settings[0]["value"]
+
+    assert "start_z" in nabu_volume_params_as_dict
+    assert "end_z" in nabu_volume_params_as_dict

tomwer/tests/test_ewoks/test_single_node_execution.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import os
+import tempfile
+from glob import glob
+
+import pytest
+from ewokscore.graph import analysis, load_graph
+from ewokscore.graph.validate import validate_graph
+
+from tomwer.core.utils.scanutils import HDF5MockContext
+from nabu.pipeline.config import get_default_nabu_config
+from nabu.pipeline.fullfield.nabu_config import (
+    nabu_config as nabu_fullfield_default_config,
+)
+
+try:
+    from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
+        FullFieldReconstructor,
+    )
+except ImportError:
+    try:
+        from nabu.pipeline.fullfield.local_reconstruction import (  # noqa F401
+            ChunkedReconstructor,
+        )
+    except ImportError:
+        has_nabu = False
+    else:
+        has_nabu = True
+else:
+    has_nabu = True
+
+pytest.mark.skipif(condition=not has_nabu, reason="nabu not installed")
+
+
+classes_to_test = {
+    "darkref": "tomwer.core.process.reconstruction.darkref.darkrefs.DarkRefs",
+    "axis": "tomwer.core.process.reconstruction.axis.axis.AxisProcess",
+    "nabu slices": "tomwer.core.process.reconstruction.nabu.nabuslices.NabuSlices",
+}
+
+
+@pytest.mark.parametrize("node_name, node_qual_name", classes_to_test.items())
+def test_single_class_instanciation(node_name, node_qual_name):
+    with HDF5MockContext(
+        scan_path=os.path.join(tempfile.mkdtemp(), "scan_test"), n_proj=100
+    ) as scan:
+        # insure no cfg yet
+        assert len(glob(os.path.join(scan.path, "*.cfg"))) == 0
+
+        graph = load_graph(
+            {
+                "nodes": [
+                    {
+                        "id": node_name,
+                        "task_type": "class",
+                        "task_identifier": node_qual_name,
+                        "default_inputs": [
+                            {
+                                "name": "data",
+                                "value": scan,
+                            },
+                            {
+                                "name": "nabu_params",
+                                "value": get_default_nabu_config(
+                                    nabu_fullfield_default_config
+                                ),
+                            },
+                        ],
+                    },
+                ]
+            }
+        )
+
+        assert graph.is_cyclic is False, "graph is expected to be acyclic"
+        assert analysis.start_nodes(graph.graph) == {
+            node_name
+        }, "graph is expected to have only on start nodes"
+        validate_graph(graph.graph)
+        result = graph.execute(varinfo=None)
+
+        assert analysis.end_nodes(graph.graph) == {
+            node_name
+        }, "graph is expected to have only one end node"
+        assert "data" in result, "data is expected to be part of the output_values"

tomwer/tests/test_ewoks/test_workflows.py

@@ -0,0 +1,138 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import os
+import tempfile
+from glob import glob
+
+from ewoks import execute_graph
+from ewokscore.graph import analysis, load_graph
+from ewokscore.graph.validate import validate_graph
+
+from tomwer.core.utils.scanutils import HDF5MockContext
+from tomwer.core.process.reconstruction.output import (
+    PROCESS_FOLDER_RECONSTRUCTED_VOLUMES,
+)
+
+try:
+    from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
+        FullFieldReconstructor,
+    )
+except ImportError:
+    try:
+        from nabu.pipeline.fullfield.local_reconstruction import (  # noqa F401
+            ChunkedReconstructor,
+        )
+    except ImportError:
+        has_nabu = False
+    else:
+        has_nabu = True
+else:
+    has_nabu = True
+
+
+def test_simple_workflow_nabu():
+    """Test the workflow: darkref -> axis -> nabu slices -> nabu volume"""
+
+    with HDF5MockContext(
+        scan_path=os.path.join(tempfile.mkdtemp(), "scan_test"), n_proj=100
+    ) as scan:
+        # insure no cfg yet
+        assert len(glob(os.path.join(scan.path, "*.cfg"))) == 0
+        assert not os.path.exists(
+            scan.process_file
+        ), "check tomwer should not have been processed yet"
+
+        graph = load_graph(
+            source={
+                "nodes": [
+                    {
+                        "id": "darkref",
+                        "task_type": "class",
+                        "task_identifier": "tomwer.core.process.reconstruction.darkref.darkrefs.DarkRefs",
+                    },
+                    {
+                        "id": "axis",
+                        "task_type": "class",
+                        "task_identifier": "tomwer.core.process.reconstruction.axis.axis.AxisProcess",
+                        "default_inputs": [
+                            {
+                                "name": "axis_params",
+                                "value": {
+                                    "MODE": "manual",
+                                    "POSITION_VALUE": 0.2,
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        "id": "nabu slices",
+                        "task_type": "class",
+                        "task_identifier": "tomwer.core.process.reconstruction.nabu.nabuslices.NabuSlices",
+                        "dry_run": True,  # as this is a mock dataset avoid to reconstruct it and only check for the .cfg file created
+                        "default_inputs": [
+                            {
+                                "name": "nabu_params",
+                                "value": {"tomwer_slices": 2},
+                            }
+                        ],
+                    },
+                    {
+                        "id": "nabu volume",
+                        "task_type": "class",
+                        "task_identifier": "tomwer.core.process.reconstruction.nabu.nabuvolume.NabuVolume",
+                        "dry_run": True,
+                        "default_inputs": [
+                            {
+                                "name": "dry_run",
+                                "value": True,
+                            }
+                        ],
+                    },
+                ],
+                "links": [
+                    {
+                        "source": "darkref",
+                        "target": "axis",
+                        "map_all_data": True,
+                    },
+                    {
+                        "source": "axis",
+                        "target": "nabu slices",
+                        "data_mapping": [  # same as all arguments but just here to test both
+                            {
+                                "source_output": "data",
+                                "target_input": "data",
+                            },
+                        ],
+                    },
+                    {
+                        "source": "nabu slices",
+                        "target": "nabu volume",
+                        "map_all_data": True,
+                    },
+                ],
+            }
+        )
+        assert graph.is_cyclic is False, "graph is expected to be acyclic"
+        assert analysis.start_nodes(graph=graph.graph) == {
+            "darkref"
+        }, "start node should be a single task `darkref`"
+        validate_graph(graph.graph)
+        result = execute_graph(
+            graph,
+            inputs=[
+                {"id": "darkref", "name": "data", "value": scan},
+            ],
+        )
+        assert analysis.end_nodes(graph=graph.graph) == {
+            "nabu volume"
+        }, "should only have one result nodes"
+        assert "data" in result, f"cannot find `nabu volume` in {result}"
+        assert os.path.exists(scan.process_file), "check tomwer has been processed"
+        assert os.path.exists(
+            os.path.join(
+                scan.path, PROCESS_FOLDER_RECONSTRUCTED_VOLUMES, "nabu_cfg_files"
+            )
+        ), "nabu has not been executed (even in dry mode)"

tomwer/utils.py

@@ -1,35 +1,9 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016 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
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
 """
 some project general utils functions
 """
 
-__authors__ = ["H. Payno", "T. Vincent"]
-__license__ = "MIT"
-__date__ = "04/01/2018"
-
+from __future__ import annotations
 
 import argparse
 import functools
@@ -103,14 +77,14 @@ class Launcher(_Launcher):
         self, prog=None, usage=None, description=None, epilog=None, version=None
     ):
         """
-        :param str prog: Name of the program. If it is not defined it uses the
+        :param prog: Name of the program. If it is not defined it uses the
             first argument of `sys.argv`
-        :param str usage: Custom the string explaining the usage. Else it is
+        :param usage: Custom the string explaining the usage. Else it is
             autogenerated.
-        :param str description: Description of the application displayed after the
+        :param description: Description of the application displayed after the
             usage.
-        :param str epilog: Custom the string displayed at the end of the help.
-        :param str version: Define the version of the application.
+        :param epilog: Custom the string displayed at the end of the help.
+        :param version: Define the version of the application.
         """
         if prog is None:
             prog = sys.argv[0]
@@ -134,9 +108,9 @@ class Launcher(_Launcher):
 
         See also `LauncherCommand`.
 
-        :param str name: Name of the command
-        :param str module_name: Module to execute
-        :param str description: Description of the command
+        :param name: Name of the command
+        :param module_name: Module to execute
+        :param description: Description of the command
         :param LauncherCommand command: A `LauncherCommand`
         """
         if command is not None:
@@ -173,9 +147,8 @@ class Launcher(_Launcher):
     def execute_help(self, argv):
         """Execute the help command.
 
-        :param list[str] argv: The list of arguments (the first one is the
+        :param argv: The list of arguments (the first one is the
             name of the application with the help command)
-        :rtype: int
         :returns: The execution status
         """
         description = "Display help information about %s" % self.prog
@@ -210,9 +183,8 @@ class Launcher(_Launcher):
     def execute(self, argv=None):
         """Execute the launcher.
 
-        :param list[str] argv: The list of arguments (the first one is the
+        :param argv: The list of arguments (the first one is the
             name of the application)
-        :rtype: int
         :returns: The execution status
         """
         if argv is None:

tomwer/version.py

@@ -76,9 +76,9 @@ RELEASE_LEVEL_VALUE = {
 }
 
 MAJOR = 1
-MINOR = 3
-MICRO = 27
-RELEV = "final"  # <16
+MINOR = 4
+MICRO = 0
+RELEV = "rc"  # <16
 SERIAL = 0  # <16
 
 date = __date__

{tomwer-1.3.27.dist-info → tomwer-1.4.0rc0.dist-info}/LICENSE

@@ -1,9 +1,9 @@
 
-The tomwer library goal is to provide some usefull process for acquisition/reconstruction automation.
+The Tomwer library goal is to provide some useful process for acquisition/reconstruction automation.
 
-tomwer is distributed under the MIT license.
+Tomwer is distributed under the MIT license.
 
-tomwer is using the Qt library. A word of caution is to be provided. If users develop and distribute software using modules accessing Qt by means of Riverbank Computing Qt bindings PyQt4 or PyQt5, those users will be conditioned by the license of their PyQt4/5 software (GPL or commercial). If the end user does not own a commercial license of PyQt4 or PyQt5 and wishes to be free of any distribution condition, (s)he should be able to use PySide because it uses the LGPL license.
+Tomwer is using the Qt library. A word of caution is to be provided. If users develop and distribute software using modules accessing Qt by means of Riverbank Computing Qt bindings PyQt4 or PyQt5, those users will be conditioned by the license of their PyQt4/5 software (GPL or commercial). If the end user does not own a commercial license of PyQt4 or PyQt5 and wishes to be free of any distribution condition, (s)he should be able to use PySide because it uses the LGPL license.
 
 It can also be used as an Orange3 add-on. If you wan't to distribute Orange you must stick to there license (GNU [GPL-3.0]+ license)