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

tomwer/core/process/control/nxtomomill.py

@@ -28,9 +28,8 @@ __license__ = "MIT"
 __date__ = "30/07/2020"
 
 
+from tomwer.core.utils.scanutils import format_output_location
 from tomwer.core.process.task import TaskWithProgress
-from tomwer.core.process.task import Task
-from tomwer.core.scan.blissscan import BlissScan
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from nxtomomill import converter as nxtomomill_converter
 from nxtomomill.io.config import TomoHDF5Config as HDF5Config
@@ -42,13 +41,18 @@ import logging
 _logger = logging.getLogger(__name__)
 
 
-class H5ToNxProcess(Task, input_names=("data",), output_names=("data",)):
+class H5ToNxProcess(
+    TaskWithProgress,
+    input_names=("h5_to_nx_configuration",),
+    optional_input_names=("progress", "hdf5_scan"),
+    output_names=("data",),
+):
     """
     Process to convert from a bliss dataset to a nexus compliant dataset
     """
 
     @staticmethod
-    def deduce_output_file_path(master_file_name, entry, outputdir=None):
+    def deduce_output_file_path(master_file_name, scan, entry, outputdir=None):
         if outputdir is not None:
             file_dir = outputdir
         else:
@@ -64,67 +68,37 @@ class H5ToNxProcess(Task, input_names=("data",), output_names=("data",)):
         output_file_name = "_".join(
             (os.path.splitext(file_name)[0], entry_for_file_name + ".nx")
         )
+        file_dir = format_output_location(file_dir, scan=scan)
         return os.path.join(file_dir, output_file_name)
 
     def run(self):
-        scan = self.inputs.data
-        if scan is None:
-            self.outputs.data = None
-            return
-
-        _logger.processStarted("Start translate {} to NXTomo".format(str(scan)))
-        if isinstance(scan, dict):
-            scan = BlissScan.from_dict(scan)
-
-        if not isinstance(scan, BlissScan):
-            raise TypeError("Scan is expected to be an instance of BlissScan")
-        output_file_path = self.deduce_output_file_path(
-            master_file_name=scan.master_file, entry=scan.entry
-        )
-        _logger.info(" ".join(("write", str(scan), "to", output_file_path)))
+        config = self.inputs.h5_to_nx_configuration
+        if isinstance(config, dict):
+            config = HDF5Config.from_dict(config)
+        elif not isinstance(config, HDF5Config):
+            raise TypeError(
+                "h5_to_nx_configuration should be a dict or an instance of {HDF5Config}"
+            )
+        config.bam_single_file = True
         try:
-            configuration = HDF5Config.from_dict(self.get_configuration())
-            configuration.input_file = scan.master_file
-            configuration.output_file = output_file_path
-            configuration.entries = (scan.entry,)
-            # overwrite some parameters
-            configuration.single_file = False
-            configuration.overwrite = True
-            configuration.file_extension = ".nx"
-            # ceinture et bretelle. Even if the file has only one
-            # entry enforce creating a sub file.
-            # Because at time T we might have only one file and then
-            # at T+1 we might have another one. Just want to be safe here
-            if hasattr(configuration, "bam_single_file"):
-                configuration.bam_single_file = True
             convs = nxtomomill_converter.from_h5_to_nx(
-                configuration=configuration,
+                configuration=config, progress=self.progress
             )
         except Exception as e:
-            _logger.processFailed(
-                "Fail to convert from bliss file: %s to NXTomo."
-                "Conversion error is: %s" % (scan.master_file, e)
+            _logger.error(e)
+            pass
+
+        if not len(convs) <= 1:
+            raise RuntimeError(
+                f"the H5ToNxProcess expects to create at most one NXtomo. {len(convs)} created"
             )
-            self.outputs.data = None
-            return
-        else:
-            for conv in convs:
-                conv_file, conv_entry = conv
-                scan_converted = HDF5TomoScan(scan=conv_file, entry=conv_entry)
-                _logger.processSucceed(
-                    "{} has been translated to {}"
-                    "".format(str(scan), str(scan_converted))
-                )
-                self.outputs.data = scan_converted
-
-    def set_configuration(self, configuration):
-        # for now the NXProcess cannot be tune
-        if isinstance(configuration, HDF5Config):
-            self._settings = configuration.to_dict()
-        elif isinstance(configuration, dict):
-            self._settings = configuration
-        else:
-            raise TypeError("invalid type: {}".format(type(configuration)))
+        for conv in convs:
+            conv_file, conv_entry = conv
+            scan_converted = HDF5TomoScan(scan=conv_file, entry=conv_entry)
+            _logger.processSucceed(
+                f"{config.input_file} {config.entries} has been translated to {scan_converted}"
+            )
+            self.outputs.data = scan_converted
 
 
 class EDFToNxProcess(
@@ -151,8 +125,9 @@ class EDFToNxProcess(
         self.outputs.data = HDF5TomoScan(entry=entry, scan=file_path)
 
     @staticmethod
-    def deduce_output_file_path(folder_path, output_dir):
+    def deduce_output_file_path(folder_path, output_dir, scan):
         if output_dir is None:
             output_dir = os.path.dirname(folder_path)
 
+        folder_path = format_output_location(folder_path, scan=scan)
         return os.path.join(output_dir, os.path.basename(folder_path) + ".nx")

tomwer/core/process/control/scanlist.py

@@ -32,6 +32,7 @@ __date__ = "05/07/2017"
 
 
 from tomwer.core.process.task import Task
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 import logging
 
 logger = logging.getLogger(__name__)
@@ -46,4 +47,4 @@ class _ScanListPlaceHolder(
     when part of a orange workflow. Those can be added interactively"""
 
     def run(self):
-        self.outputs.data = self.inputs.data
+        self.outputs.data = data_identifier_to_scan(self.inputs.data)

tomwer/core/process/control/scanselector.py

@@ -0,0 +1,7 @@
+from ewokscore.task import Task as EwoksTask
+from tomwer.core.utils.scanutils import data_identifier_to_scan
+
+
+class _ScanSelectorPlaceHolder(EwoksTask, input_names=["data"], output_names=["data"]):
+    def run(self):
+        self.outputs.data = data_identifier_to_scan(self.inputs.data)

tomwer/core/process/control/scantransfer.py

@@ -33,7 +33,7 @@ import shutil
 import fnmatch
 
 from tomwer.core.process.task import Task
-
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.settings import get_lbsram_path, get_dest_path
 from tomwer.core.process.reconstruction.nabu.settings import NABU_CFG_FILE_FOLDER
@@ -444,7 +444,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
             exists
         :param bool noRSync: True if we wan't do sue shutil instead of rsync.
         """
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if scan is None:
             raise ValueError("'scan' should be provided")
 
@@ -500,17 +500,11 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
             return
         for _file in os.listdir(scanfolder):
             if _file.lower().endswith(".par"):
-                par_file_path = os.path.join(scanfolder, _file)
-                try:
-                    rebaseParFile(
-                        par_file_path,
-                        oldfolder=scanfolder,
-                        newfolder=outputdir,
-                    )
-                except Exception as e:
-                    logger.warning(
-                        f"Fail to rebase par file {par_file_path}. Reason is {e}"
-                    )
+                rebaseParFile(
+                    os.path.join(scanfolder, _file),
+                    oldfolder=scanfolder,
+                    newfolder=outputdir,
+                )
 
     def __noticeTransfertSuccess(self, input_scan, output_scan):
         self._signalCopySucceed()
@@ -612,11 +606,8 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         return None
 
     def _getOutputDirLBS(self, scanPath):
-        scanPath = os.path.realpath(scanPath)
-        lbsram_path = os.path.realpath(get_lbsram_path())
-        if scanPath.startswith(lbsram_path):
-            dest_path = os.path.realpath(get_dest_path())
-            return scanPath.replace(lbsram_path, dest_path, 1)
+        if scanPath.startswith(get_lbsram_path()):
+            return scanPath.replace(get_lbsram_path(), get_dest_path(), 1)
         else:
             return None
 

tomwer/core/process/control/scanvalidator.py

@@ -33,6 +33,7 @@ from tomwer.core import utils
 from tomwer.core.process.task import BaseProcessInfo
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils import logconfig
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 import logging
 from tomwer.core.scan.scanbase import TomwerScanBase, _TomwerBaseDock
 from ewokscore.task import Task as EwoksTask
@@ -42,7 +43,7 @@ logger = logging.getLogger(__name__)
 
 class _ScanValidatorPlaceHolder(EwoksTask, input_names=["data"], output_names=["data"]):
     def run(self):
-        self.outputs.data = self.inputs.data
+        self.outputs.data = data_identifier_to_scan(self.inputs.data)
 
 
 class ScanValidator(BaseProcessInfo):
@@ -72,7 +73,7 @@ class ScanValidator(BaseProcessInfo):
     def _clearMemoryReleaser(self):
         if self._memoryReleaser is not None:
             self._memoryReleaser.should_be_stopped = True
-            self._memoryReleaser.wait()
+            self._memoryReleaser.wait(4000)
             self._memoryReleaser = None
 
     def addScan(self, scan):
@@ -237,13 +238,13 @@ class ScanValidator(BaseProcessInfo):
         """
         return self._manualValidation
 
-    def _sendScanReady(self):
+    def _sendScanReady(self, scan):
         raise RuntimeError("ScanValidator is a pure virtual class.")
 
-    def _sendScanCanceledAt(self):
+    def _sendScanCanceledAt(self, scan):
         raise RuntimeError("ScanValidator is a pure virtual class.")
 
-    def _sendUpdateReconsParam(self):
+    def _sendUpdateReconsParam(self, scan):
         raise RuntimeError("ScanValidator is a pure virtual class.")
 
     def clear(self):

tomwer/core/process/control/singletomoobj.py

@@ -1,4 +1,5 @@
 from tomwer.core.process.task import Task
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 
 class SingleTomoObjProcess(
@@ -10,4 +11,4 @@ class SingleTomoObjProcess(
     when part of a orange workflow. Those can be added interactively"""
 
     def run(self):
-        self.outputs.tomo_obj = self.inputs.tomo_obj
+        self.outputs.tomo_obj = data_identifier_to_scan(self.inputs.tomo_obj)

tomwer/core/process/control/timer.py

@@ -31,6 +31,7 @@ __date__ = "12/12/2018"
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 import time
 import logging
 
@@ -66,7 +67,7 @@ class Timer(Task, input_names=("data",), output_names=("data",)):
         self._waiting_time = wait
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if type(scan) is dict:
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:

tomwer/core/process/control/tomoobjserie.py

@@ -0,0 +1,8 @@
+from ewokscore.task import Task as EwoksTask
+
+
+class _TomoobjseriePlaceHolder(
+    EwoksTask, input_names=["serie"], output_names=["serie"]
+):
+    def run(self):
+        self.outputs.serie = self.inputs.serie

tomwer/core/process/control/volumeselector.py

@@ -1,8 +1,9 @@
 from ewokscore.task import Task as EwoksTask
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 
 class _VolumeSelectorPlaceHolder(
     EwoksTask, input_names=["volume"], output_names=["volume"]
 ):
     def run(self):
-        self.outputs.volume = self.inputs.volume
+        self.outputs.volume = data_identifier_to_scan(self.inputs.volume)

tomwer/core/process/control/volumesymlink.py

@@ -34,6 +34,7 @@ from tomoscan.factory import Factory
 from tomoscan.volumebase import VolumeBase
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 from silx.utils.enum import Enum as _Enum
 from tomwer.utils import docstring
 import tomwer.version
@@ -118,7 +119,7 @@ class VolumeSymbolicLinkProcess(Task, input_names=("data",), output_names=("data
 
     @docstring(Task.run)
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if type(scan) is dict:
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:

tomwer/core/process/edit/darkflatpatch.py

@@ -30,6 +30,7 @@ __date__ = "04/11/2020"
 
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 from nxtomomill.utils import add_dark_flat_nx_file
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanfactory import ScanFactory
@@ -69,7 +70,7 @@ class DarkFlatPatch(Task, input_names=("data",), output_names=("data",)):
     """
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if type(scan) is dict:
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:

tomwer/core/process/edit/imagekeyeditor.py

@@ -28,13 +28,14 @@ __license__ = "MIT"
 __date__ = "26/10/2020"
 
 
-from tomoscan.esrf.hdf5scan import ImageKey as _ImageKey
+from tomoscan.esrf.scan.hdf5scan import ImageKey as _ImageKey
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from nxtomomill.utils import change_image_key_control as _change_image_key_control
 from tomwer.core.process.task import Task
-from tomoscan.esrf.hdf5scan import ImageKey
+from tomoscan.esrf.scan.hdf5scan import ImageKey
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 import nxtomomill.version
 import logging
 
@@ -108,7 +109,7 @@ class ImageKeyEditor(Task, input_names=("data",), output_names=("data",)):
         self.set_configuration(inputs.get("image_key_edition", {}))
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if type(scan) is dict:
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:

tomwer/core/process/reconstruction/axis/axis.py

@@ -29,7 +29,12 @@ __authors__ = ["C.Nemoz", "H.Payno"]
 __license__ = "MIT"
 __date__ = "19/03/2019"
 
-from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
+import nabu
+import numpy
+import logging
+from processview.core.manager import ProcessManager
+from processview.core.manager import DatasetState
+import tomwer.version
 from .params import (
     AxisRP,
     DEFAULT_CMP_TAKE_LOG,
@@ -45,16 +50,13 @@ from .anglemode import CorAngleMode
 from tomwer.core.process.task import Task
 from processview.core.superviseprocess import SuperviseProcess
 from tomwer.core.scan.scanbase import TomwerScanBase
-from processview.core.manager import ProcessManager
-from processview.core.manager import DatasetState
+from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
 from tomwer.core.scan.scanfactory import ScanFactory
-import logging
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.utils import logconfig
-import numpy
 from typing import Optional, Union
 from tomwer.utils import docstring
 from tomwer.core.utils import image
-import tomwer.version
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from nabu.estimation.cor import (
     CenterOfRotation,
@@ -73,7 +75,6 @@ else:
 from silx.io.url import DataUrl
 from tomoscan.io import HDF5File
 from silx.io.utils import h5py_read_dataset
-import nabu
 
 _logger = logging.getLogger(__name__)
 if not has_composite_cor_finder:
@@ -119,7 +120,7 @@ def adapt_tomwer_scan_to_nabu(scan: TomwerScanBase):
             "processes_file"
             in inspect.signature(update_dataset_info_flats_darks).parameters
         ):
-            update_dataset_info_flats_darks(
+            update_dataset_info_flats_darks(  # pylint: disable=E1123
                 dataset_infos,
                 processes_file=scan.get_relative_file(
                     "nabu_processes.h5", with_dataset_prefix=True
@@ -186,14 +187,15 @@ def compute_cor_nabu_growing_window_sinogram(
     :return:
     """
     corfinder = SinoCORFinder(
-        adapt_tomwer_scan_to_nabu(scan),
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="growing-window",
         slice_idx=scan.axis_params.sinogram_line or "middle",
         subsampling=scan.axis_params.sinogram_subsampling,
         do_flatfield=True,
-        cor_options=scan.axis_params.get_nabu_cor_options(),
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
     )
-    res = corfinder.find_cor(method="growing-window")
+    res = corfinder.find_cor()
     if isinstance(res, numpy.ndarray):
         if len(res) == 1:
             res = res[0]
@@ -215,14 +217,15 @@ def compute_scan_sino_coarse_to_fine(scan):
     :return:
     """
     corfinder = SinoCORFinder(
-        adapt_tomwer_scan_to_nabu(scan),
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method=AxisMode.sino_coarse_to_fine.value,
         slice_idx=scan.axis_params.sinogram_line or "middle",
         subsampling=scan.axis_params.sinogram_subsampling,
         do_flatfield=True,
-        cor_options=scan.axis_params.get_nabu_cor_options(),
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
     )
-    res = corfinder.find_cor(method=AxisMode.sino_coarse_to_fine.value)
+    res = corfinder.find_cor()
     return _absolute_pos_to_relative_with_warning(
         absolute_pos=res, det_width=scan.dim_1
     )
@@ -255,11 +258,11 @@ def compute_scan_composite_coarse_to_fine(scan: TomwerScanBase):
     extra_args = {}
 
     corfinder = CompositeCOREstimator(
-        adapt_tomwer_scan_to_nabu(scan),
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
         theta_interval=theta,
         n_subsampling_y=n_subsampling_y,
         oversampling=oversampling,
-        cor_options=scan.axis_params.get_nabu_cor_options(),
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
         take_log=take_log,
         **extra_args
@@ -378,14 +381,15 @@ def compute_cor_nabu_sliding_window_sinogram(
     :return:
     """
     corfinder = SinoCORFinder(
-        adapt_tomwer_scan_to_nabu(scan),
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="sliding-window",
         slice_idx=scan.axis_params.sinogram_line or "middle",
         subsampling=scan.axis_params.sinogram_subsampling,
         do_flatfield=True,
-        cor_options=scan.axis_params.get_nabu_cor_options(),
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
     )
-    res = corfinder.find_cor(method="sliding-window")
+    res = corfinder.find_cor()
     # now fixed but on some version nabu could return a numpy array instead of float
     if isinstance(res, numpy.ndarray):
         if len(res) == 1:
@@ -630,9 +634,11 @@ class AxisProcess(
         """Recons parameters register before locking the position"""
 
     def set_configuration(self, configuration):
-        self.set_recons_params(
-            recons_params=AxisRP.from_dict(configuration["_rpSetting"])
-        )
+        if "_rpSetting" in configuration:
+            recons_params = AxisRP.from_dict(configuration["_rpSetting"])
+        else:
+            recons_params = AxisRP.from_dict(configuration)
+        self.set_recons_params(recons_params=recons_params)
 
     def set_recons_params(self, recons_params):
         assert isinstance(recons_params, AxisRP)
@@ -664,7 +670,7 @@ class AxisProcess(
         .. note:: this simply call `compute`.
                   But this is needed for the AxisProcessThreaded class
         """
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if scan is None:
             return
 
@@ -702,14 +708,6 @@ class AxisProcess(
                 self._process_end(scan, cor=cor, error=error)
         self.outputs.data = scan_res
 
-    def reprocess(self, scan):
-        """
-        Reprocess the scan. For now simply call process
-
-        :param scan:
-        """
-        return self.process(scan)
-
     def _process_end(self, scan, cor, error=None):
         assert isinstance(scan, TomwerScanBase)
         if scan.process_file is not None:
@@ -869,7 +867,6 @@ class AxisProcess(
                 "".format(scan_name, e)
             )
         else:
-            print("position is", position)
             scan.axis_params.set_relative_value(position)
             self._axis_params.frame_width = scan.dim_1
             self._axis_params.set_relative_value(position)

tomwer/core/process/reconstruction/axis/mode.py

@@ -58,16 +58,17 @@ class AxisMode(_Enum):
 
     @classmethod
     def from_value(cls, value):
+        # ensure backward compatiblity with workflow defined before COR method on sinograms
         if value == "growing-window":
             _logger.warning(
                 "Axis mode requested is 'growing-window'. To insure backward compatibility replace it by 'growing-window-radios'"
             )
-            value = "growing-window-radios"
+            value = AxisMode.growing_window_radios
         elif value == "sliding-window":
             _logger.warning(
                 "Axis mode requested is 'sliding-window'. To insure backward compatibility replace it by 'sliding-window-radios'"
             )
-            value = "sliding-window-radios"
+            value = AxisMode.sliding_window_radios
 
         return super().from_value(value=value)
 

tomwer/core/process/reconstruction/axis/params.py

@@ -77,7 +77,7 @@ class AxisCalculationInput(_Enum):
     transmission = _calculation_conf(ProjectionType.transmission, False)
     transmission_pag = _calculation_conf(ProjectionType.transmission, True)
 
-    def name(self):
+    def name(self):  # pylint: disable=E0102
         if self.value.paganin is True:
             return " ".join((self.value.projection_type.value, "paganin"))
         else:
@@ -677,7 +677,7 @@ class AxisRP:
                             res = float(values[0])
                         except Exception:
                             _logger.info(
-                                "fail to load center of rotation " "from ", file_path
+                                f"fail to load center of rotation from {file_path}"
                             )
                             return None
                         else:
@@ -875,28 +875,47 @@ class AxisRP:
             results = ", ".join((results, extra_info))
         return results
 
-    def get_nabu_cor_options(self) -> str:
-        """return cor option for nabu"""
+    def get_nabu_cor_options_as_dict(self) -> str:
+        options = {}
         if self.mode in (
             AxisMode.sliding_window_sinogram,
             AxisMode.sliding_window_radios,
             AxisMode.growing_window_sinogram,
             AxisMode.growing_window_radios,
         ):
-            options = "side='{}'".format(self.side)
+            options["side"] = self.side
         elif self.mode in (AxisMode.composite_coarse_to_fine,):
             near_pos = self.composite_options.get("near_pos", 0.0)
             near_width = self.composite_options.get("near_width", 20.0)
-            options = (
-                f"side='{self.side}'; near_pos={near_pos}; near_width={near_width}"
-            )
-        else:
-            options = None
+            options["side"] = self.side
+            options["near_pos"] = near_pos
+            options["near_width"] = near_width
 
         # append "extra_cor_options" to already handled cor options
-        if self.extra_cor_options.replace(" ", "") == "":
-            return options
-        elif options is None:
-            return self.extra_cor_options
-        else:
-            return " ; ".join([options, self.extra_cor_options])
+        extra_cor_options = self.extra_cor_options.replace(" ", "")
+
+        if extra_cor_options != "":
+            for opt in self.extra_cor_options.replace(" ", "").split(";"):
+                key, value = opt.split("=")
+                options[key] = value
+        return options
+
+    @deprecated(replacement="get_nabu_cor_options_as_str", since_version="1.1")
+    def get_nabu_cor_options(self) -> str:
+        return self.get_nabu_cor_options_as_str()
+
+    def get_nabu_cor_options_as_str(self) -> str:
+        """return cor option for nabu"""
+
+        def cast_key_value(key, value):
+            if key in ("side",):
+                return f"{key}='{value}'"
+            else:
+                return f"{key}={value}"
+
+        return " ; ".join(
+            [
+                cast_key_value(key, value)
+                for key, value in self.get_nabu_cor_options_as_dict().items()
+            ]
+        )