tomwer 1.2.0a1__py3-none-any.whl → 1.2.0a3__py3-none-any.whl

tomwer/core/process/control/email.py

@@ -0,0 +1,148 @@
+import smtplib
+import platform
+import os
+import string
+
+from processview.core.manager import ProcessManager
+
+from tomwer.core.process.task import Task
+from tomwer.core.tomwer_object import TomwerObject
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.volume.hdf5volume import HDF5Volume
+
+from datetime import datetime
+from tomwer.version import version as __version
+
+
+class EmailTask(
+    Task,
+    input_names=("subject", "from_addr", "to_addrs", "text"),
+    optional_input_names=("mail_options", "rcpt_options", "host", "port"),
+):
+    """
+    Generic task to send a simple email
+    """
+
+    def run(self):
+        port = self.get_input_value("port", 0)
+        assert isinstance(port, int), "port is expected to be an int"
+        host = self.get_input_value("host", "smtps.esrf.fr")
+        server = smtplib.SMTP(host, port, timeout=5)
+        server.sendmail(
+            self.inputs.from_addr,
+            self.inputs.to_addrs,
+            f"Subject: {self.inputs.subject}\n\n{self.inputs.text}",
+        )
+        server.quit()
+
+
+class TomoEmailTask(
+    Task,
+    input_names=("tomo_obj", "configuration"),
+    output_names=("tomo_obj",),
+):
+    """Dedicated task for tomography and gui approach"""
+
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)
+
+    def run(self):
+        tomo_obj = self.inputs.tomo_obj
+        configuration = self.inputs.configuration
+        configuration["text"] = format_email_info(
+            configuration.get("text", ""), tomo_obj=tomo_obj
+        )
+        configuration["subject"] = format_email_info(
+            configuration.get("subject", ""), tomo_obj=tomo_obj
+        )
+        task = EmailTask(inputs=configuration)
+        task.run()
+        self.outputs.tomo_obj = self.inputs.tomo_obj
+
+
+def _ls_tomo_obj(tomo_obj) -> tuple:
+    """
+    list information regarding a tomo obj
+    """
+    if isinstance(tomo_obj, TomwerScanBase):
+        # for tomoscan base use the `path` attribut
+        file_path_to_list = tomo_obj.path
+    elif isinstance(tomo_obj, TomwerVolumeBase):
+        if isinstance(tomo_obj, HDF5Volume):
+            file_path_to_list = os.path.dirname(tomo_obj.url.file_path())
+        else:
+            file_path_to_list = tomo_obj.url.file_path()
+    else:
+        raise TypeError
+
+    def get_size(file_path, decimal_places=2) -> str:
+        size = os.path.getsize(file_path)
+        for unit in ("B", "KiB", "MiB", "GiB", "TiB", "PiB"):
+            if size < 1024.0 or unit == "PiB":
+                break
+            size /= 1024.0
+        return f"{size:.{decimal_places}f} {unit}"
+
+    return tuple(
+        [
+            f"{get_size(os.path.join(file_path_to_list, file_path))} - {file_path}"
+            for file_path in os.listdir(file_path_to_list)
+        ]
+    )
+
+
+def _ls_dataset_state(tomo_obj) -> str:
+    """
+    list the status of all met processes by the tomo_obj
+    """
+    states = {}
+    for process in ProcessManager().get_processes():
+        state = ProcessManager().get_dataset_state(
+            dataset_id=tomo_obj.get_identifier(),
+            process=process,
+        )
+        if state is not None:
+            states[process] = state
+
+    return "\n".join(
+        [f"* {process.name}: {state.value}" for process, state in states.items()]
+    )
+
+
+def format_email_info(my_str: str, tomo_obj: TomwerObject) -> str:
+    """
+    format `my_str` string. It can contain one of the following keyword:
+
+    - {tomo_obj_short_id}: tomo_obj 'short id' (calling identifier.short_description)
+    - {tomo_obj_id}: tomo_obj id
+    - {ls_tomo_obj}: ls of the scan folder
+    - {timestamp}: current time
+    - {footnote}: some footnote defined by tomwer
+    - {dataset_processing_states}: list the status of all met processing
+    """
+
+    keywords = {
+        "tomo_obj_short_id": tomo_obj.get_identifier().short_description(),
+        "tomo_obj_id": tomo_obj.get_identifier().to_str(),
+        "ls_tomo_obj": "\n".join(_ls_tomo_obj(tomo_obj)),
+        "timestamp": datetime.utcnow().isoformat(timespec="seconds"),
+        "footnote": f"email send by tomwer - {__version} from {platform.node()}",
+        "dataset_processing_states": _ls_dataset_state(tomo_obj),
+    }
+
+    # filter necessary keywords
+    def get_necessary_keywords():
+        formatter = string.Formatter()
+        return [field for _, field, _, _ in formatter.parse(my_str) if field]
+
+    requested_keywords = get_necessary_keywords()
+
+    def keyword_needed(pair):
+        keyword, _ = pair
+        return keyword in requested_keywords
+
+    keywords = dict(filter(keyword_needed, keywords.items()))
+    return my_str.format(**keywords)

tomwer/core/process/control/nxtomoconcatenate.py

@@ -21,7 +21,10 @@ class ConcatenateNXtomoTask(
         "output_entry",
         "overwrite",
     ),
-    optional_input_names=("progress",),
+    optional_input_names=(
+        "progress",
+        "serialize_output_data",
+    ),
     output_names=("data",),
 ):
     """
@@ -66,10 +69,14 @@ class ConcatenateNXtomoTask(
         )
 
         # cast back nxtomomill NXtomo to HDF5TomoScan (reference object for tomwer)
-        self.outputs.data = HDF5TomoScan(
+        scan = HDF5TomoScan(
             scan=output_file,
             entry=self.inputs.output_entry,
         )
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan.to_dict()
+        else:
+            self.outputs.data = scan
 
 
 def format_output_location(file_path, serie: Serie):

tomwer/core/process/control/nxtomomill.py

@@ -30,34 +30,62 @@ __date__ = "30/07/2020"
 
 import logging
 import os
+import pathlib
 
 from nxtomomill import converter as nxtomomill_converter
 from nxtomomill.io.config import TomoEDFConfig as EDFConfig
 from nxtomomill.io.config import TomoHDF5Config as HDF5Config
+from nxtomomill.converter.hdf5.utils import get_default_output_file
 
 from tomwer.core.process.task import TaskWithProgress
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.utils.scanutils import format_output_location
 
+from silx.utils.enum import Enum as _Enum
+
 _logger = logging.getLogger(__name__)
 
 
+class NXtomomillNXDefaultOutput(_Enum):
+    NEAR_INPUT_FILE = "near input"
+    PROCESSED_DATA = "processed data dir"
+
+
 class H5ToNxProcess(
     TaskWithProgress,
     input_names=("h5_to_nx_configuration",),
-    optional_input_names=("progress", "hdf5_scan"),
+    optional_input_names=(
+        "progress",
+        "hdf5_scan",
+        "serialize_output_data",
+    ),
     output_names=("data",),
 ):
     """
-    Process to convert from a bliss dataset to a nexus compliant dataset
+    Task to convert from a bliss dataset to a nexus compliant dataset
     """
 
     @staticmethod
-    def deduce_output_file_path(master_file_name, scan, entry, outputdir=None):
-        if outputdir is not None:
-            file_dir = outputdir
+    def deduce_output_file_path(master_file_name, scan, entry, outputdir):
+        assert isinstance(outputdir, str), "outputdir is expected to be a str"
+
+        master_file_name = os.path.realpath(master_file_name)
+        # step 1: get output dir
+        try:
+            outputdir = NXtomomillNXDefaultOutput.from_value(outputdir)
+        except ValueError:
+            output_folder = format_output_location(outputdir, scan=scan)
         else:
-            file_dir = os.path.dirname(master_file_name)
+            if outputdir is NXtomomillNXDefaultOutput.PROCESSED_DATA:
+                path = pathlib.Path(
+                    get_default_output_file(input_file=master_file_name)
+                )
+                output_folder = str(path.parent)
+            elif outputdir is NXtomomillNXDefaultOutput.NEAR_INPUT_FILE:
+                output_folder = os.path.dirname(master_file_name)
+            else:
+                raise RuntimeError(f"output dir {outputdir} not handled")
+
         file_name = os.path.basename(master_file_name)
         if "." in file_name:
             file_name = "".join(file_name.split(".")[:-1])
@@ -69,8 +97,7 @@ class H5ToNxProcess(
         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)
+        return os.path.join(output_folder, output_file_name)
 
     def run(self):
         config = self.inputs.h5_to_nx_configuration
@@ -102,13 +129,20 @@ class H5ToNxProcess(
         _logger.processSucceed(
             f"{config.input_file} {config.entries} has been translated to {scan_converted}"
         )
-        self.outputs.data = scan_converted
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan_converted.to_dict()
+        else:
+            self.outputs.data = scan_converted
 
 
 class EDFToNxProcess(
     TaskWithProgress,
     input_names=("edf_to_nx_configuration",),
-    optional_input_names=("progress", "edf_scan"),
+    optional_input_names=(
+        "progress",
+        "edf_scan",
+        "serialize_output_data",
+    ),
     output_names=("data",),
 ):
     """
@@ -126,12 +160,20 @@ class EDFToNxProcess(
         file_path, entry = nxtomomill_converter.from_edf_to_nx(
             configuration=config, progress=self.progress
         )
-        self.outputs.data = HDF5TomoScan(entry=entry, scan=file_path)
+        scan = HDF5TomoScan(entry=entry, scan=file_path)
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan.to_dict()
+        else:
+            self.outputs.data = scan
 
     @staticmethod
     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")
+        if output_dir in (None, NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value):
+            output_folder = os.path.dirname(folder_path)
+        elif output_dir == NXtomomillNXDefaultOutput.PROCESSED_DATA.value:
+            path = pathlib.Path(get_default_output_file(folder_path))
+            output_folder = str(path.parent)
+        else:
+            output_folder = format_output_location(output_dir, scan=scan)
+        print("output output_folder is", output_folder)
+        return os.path.join(output_folder, os.path.basename(folder_path) + ".nx")

tomwer/core/process/control/scanselector.py

@@ -4,5 +4,9 @@ from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 
 class _ScanSelectorPlaceHolder(EwoksTask, input_names=["data"], output_names=["data"]):
+    """
+    task to select one or several scan / data to be processed
+    """
+
     def run(self):
         self.outputs.data = data_identifier_to_scan(self.inputs.data)

tomwer/core/process/control/scantransfer.py

@@ -32,6 +32,7 @@ import fnmatch
 import logging
 import os
 import shutil
+from silx.utils.deprecation import deprecated_warning
 
 import tomwer.version
 from tomwer.core.process.reconstruction.nabu.settings import NABU_CFG_FILE_FOLDER
@@ -58,7 +59,21 @@ else:
     has_rsync = True
 
 
-class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
+class ScanTransferTask(
+    Task,
+    input_names=("data",),
+    optional_input_names=(
+        "serialize_output_data",
+        "copying",
+        "block",
+        "turn_off_print",
+        "dest_dir",
+        "move",
+        "noRsync",
+        "overwrite",
+    ),
+    output_names=("data",),
+):
     """Manage the copy of scan.
 
     .. warning : the destination directory is find out from the file system
@@ -99,17 +114,19 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         else:
             force_sync = False
 
-        self._block = inputs.get("block", force_sync)
+        self._block = self.get_input_value("block", force_sync)
 
-        self._move = inputs.get("move", False)
+        self._move = self.get_input_value("move", False)
         if not isinstance(self._move, bool):
             raise TypeError("move is expected to be a boolean")
 
-        self._force = inputs.get("force", False)
-        if not isinstance(self._force, bool):
+        self._overwrite = self.get_input_value("overwrite", False)
+        if not isinstance(self._overwrite, bool):
             raise TypeError("move is expected to be a boolean")
 
-        self._noRsync = inputs.get("noRsync", False)  # TODO: rename noRsync to no_rsync
+        self._noRsync = self.get_input_value(
+            "noRsync", False
+        )  # TODO: rename noRsync to no_rsync
         if not isinstance(self._noRsync, bool):
             raise TypeError("move is expected to be a boolean")
 
@@ -144,7 +161,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
 
         return ""
 
-    def _process_edf_scan(self, scan, move=False, force=True, noRsync=False):
+    def _process_edf_scan(self, scan, move=False, overwrite=True, noRsync=False):
         if not isinstance(scan, EDFTomoScan):
             raise TypeError(f"{scan} is expected to be an instance of {EDFTomoScan}")
         outputdir = self.getDestinationDir(scan.path)
@@ -154,7 +171,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         self._pretransfertOperations(scan.path, outputdir)
         # as we are in the workflow we want this function to be bloking.
         # so we will not used a thread for folder synchronization
-        # for now rsync is not delaing with force option
+        # for now rsync is not delaing with overwrite option
         if not has_rsync or noRsync is True or RSyncManager().has_rsync() is False:
             logger.info("Can't use rsync, copying files")
             try:
@@ -162,11 +179,11 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
                     self._moveFiles(
                         scanPath=scan.path,
                         outputdir=os.path.dirname(outputdir),
-                        force=force,
+                        overwrite=overwrite,
                     )
                 else:
                     self._copyFiles(
-                        scanPath=scan.path, outputdir=outputdir, force=force
+                        scanPath=scan.path, outputdir=outputdir, overwrite=overwrite
                     )
             except shutil.Error as e:
                 raise e
@@ -440,7 +457,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         :param scan: the path to the file we want to move/process
         :type scan: :class:`.TomoBase`
         :param move: if True, directly move the files. Otherwise copy the files
-        :param force: if True then force the copy even if the file/folder already
+        :param overwrite: if True then force the copy even if the file/folder already
             exists
         :param bool noRSync: True if we wan't do sue shutil instead of rsync.
         """
@@ -450,7 +467,6 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
 
         if scan is None:
             self.outputs.data = None
-        force = self._force
 
         _scan = scan
         if type(_scan) is dict:
@@ -461,7 +477,10 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         logger.info("synchronisation with scanPath")
         if isinstance(scan, EDFTomoScan):
             output_scan = self._process_edf_scan(
-                scan=scan, move=self._move, force=force, noRsync=self._noRsync
+                scan=scan,
+                move=self._move,
+                overwrite=self.get_input_value("overwrite", True),
+                noRsync=self._noRsync,
             )
         elif isinstance(scan, HDF5TomoScan):
             if self._move is True:
@@ -471,7 +490,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
             output_scan = self._process_hdf5_scan(scan=scan)
         else:
             raise TypeError("Other scan than EDF or HDF5 are not managed")
-        if self._return_dict:
+        if self.get_input_value("serialize_output_data", True):
             self.outputs.data = output_scan.to_dict()
         else:
             self.outputs.data = output_scan
@@ -537,13 +556,11 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         assert isinstance(output_scan, TomwerScanBase)
         self.scanready.emit(output_scan)
 
-    def _copyFiles(self, scanPath, outputdir, force):
+    def _copyFiles(self, scanPath, outputdir, overwrite):
         """Copying files and removing them"""
         assert type(scanPath) is str
         assert type(outputdir) is str
         assert os.path.isdir(scanPath)
-        #        if force is False:
-        #            assert(os.path.isdir(outputdir))
         # create the destination dir
         if not os.path.isdir(outputdir):
 
@@ -557,7 +574,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         for f in os.listdir(scanPath):
             file = os.path.join(scanPath, f)
             fileDest = os.path.join(outputdir, f)
-            if force is True:
+            if overwrite is True:
                 if os.path.isdir(fileDest):
                     shutil.rmtree(fileDest)
                 if os.path.isfile(fileDest):
@@ -575,11 +592,9 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         info = "sucessfuly removed file at %s !!!" % scanPath
         logger.info(info)
 
-    def _moveFiles(self, scanPath, outputdir, force):
+    def _moveFiles(self, scanPath, outputdir, overwrite):
         """Function simply moving files"""
         assert os.path.isdir(scanPath)
-        if force is False:
-            assert os.path.isdir(outputdir)
 
         logger.debug(
             "synchronisation with scanPath",
@@ -587,7 +602,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         )
 
         target = os.path.join(outputdir, os.path.basename(scanPath))
-        if force is True and os.path.isdir(target):
+        if overwrite is True and os.path.isdir(target):
             shutil.rmtree(target)
         shutil.move(scanPath, outputdir)
 
@@ -629,7 +644,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
     def setDestDir(self, dist):
         """Force the outpudir to dist.
 
-        :param str dist: path to the folder. If None remove force behavior
+        :param str dist: path to the folder. If None remove overwrite behavior
         """
         self._destDir = dist
         if self._destDir is not None and os.path.isdir(self._destDir):
@@ -688,3 +703,17 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
         :return:
         """
         return os.path.join(self.getDestinationDir(scan), os.path.basename(scan))
+
+
+class ScanTransfer(ScanTransferTask):
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.control.scantransfer.ScanTransfer",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="ScanTransferTask",
+        )
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)

tomwer/core/process/control/test/test_concatenate_nxtomos.py

@@ -38,6 +38,7 @@ def test_concatenate_nx_tomo_task(tmp_path):
             "output_file": output_scan_file,
             "output_entry": "my_entry",
             "overwrite": False,
+            "serialize_output_data": False,
         }
     )
     task.run()

tomwer/core/process/control/test/test_email.py

@@ -0,0 +1,52 @@
+import os
+import numpy
+from tomwer.core.process.control.email import format_email_info, _ls_tomo_obj
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomwer.core.utils.scanutils import HDF5MockContext
+
+
+def test__ls_tomo_obj(tmp_path):
+    """simple test of the `_ls_tomo_obj` function"""
+    for i in range(2):
+        open(os.path.join(tmp_path, f"{i}.nx"), "a").close()
+
+    scan = HDF5TomoScan(
+        scan=os.path.join(tmp_path, "1.nx"),
+        entry="entry0000",
+    )
+    assert isinstance(scan, HDF5TomoScan)
+
+    assert len(_ls_tomo_obj(scan)) == 2
+
+    volume = HDF5Volume(
+        file_path=os.path.join(tmp_path, "myvolume.hdf5"),
+        data_path="myvolume",
+        data=numpy.linspace(0, 10, 100 * 100 * 3).reshape(  # pylint: disable=E1121
+            3, 100, 100
+        ),
+    )
+    volume.save()
+    assert len(_ls_tomo_obj(volume)) == 3
+
+
+def test_format_email_info(tmp_path):
+    """
+    simple test of formatting some information related to an email
+    """
+    with HDF5MockContext(
+        scan_path=os.path.join(tmp_path, "test", "scan"), n_proj=100
+    ) as scan:
+        res = format_email_info(
+            my_str="{tomo_obj_short_id} \n {tomo_obj_id} \n {ls_tomo_obj} \n {timestamp} \n {footnote}",
+            tomo_obj=scan,
+        )
+
+        for keyword in (
+            "{tomo_obj_short_id}",
+            "{tomo_obj_id}",
+            "{ls_tomo_obj}",
+            "{timestamp}",
+            "{footnote}",
+        ):
+            assert keyword not in res

tomwer/core/process/control/test/test_h52nx_process.py

@@ -0,0 +1,106 @@
+import os
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.process.control.nxtomomill import (
+    EDFToNxProcess,
+    H5ToNxProcess,
+    NXtomomillNXDefaultOutput,
+)
+from tomwer.core.utils.scanutils import MockHDF5, MockEDF
+from nxtomomill.converter.hdf5.utils import PROCESSED_DATA_DIR_NAME, RAW_DATA_DIR_NAME
+
+
+def test_h52nx_process_deduce_output_file_path(tmp_path):
+    """test H5ToNxProcess.deduce_output_file_path function"""
+    scan_path = str(tmp_path / "path" / RAW_DATA_DIR_NAME / "my_scan")
+    os.makedirs(scan_path)
+
+    scan = MockHDF5(scan_path=scan_path, n_proj=0).scan
+
+    # test H52NXDefaultOutput.PROCESSED_DATA
+    assert H5ToNxProcess.deduce_output_file_path(
+        master_file_name=scan.master_file,
+        scan=scan,
+        entry=scan.entry,
+        outputdir=NXtomomillNXDefaultOutput.PROCESSED_DATA.value,
+    ) == str(
+        tmp_path
+        / "path"
+        / PROCESSED_DATA_DIR_NAME
+        / "my_scan"
+        / f"my_scan_{scan.entry}.nx"
+    )
+
+    # test H52NXDefaultOutput.NEAR_BLISS_FILE
+    assert H5ToNxProcess.deduce_output_file_path(
+        master_file_name=scan.master_file,
+        scan=scan,
+        entry=scan.entry,
+        outputdir=NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value,
+    ) == str(
+        tmp_path / "path" / RAW_DATA_DIR_NAME / "my_scan" / f"my_scan_{scan.entry}.nx"
+    )
+
+    # test providing output dir with some formatting to be done
+    assert H5ToNxProcess.deduce_output_file_path(
+        master_file_name=scan.master_file,
+        scan=scan,
+        entry=scan.entry,
+        outputdir="{scan_parent_dir_basename}/../../toto/{scan_dir_name}",
+    ) == str(tmp_path / "toto" / "my_scan" / f"my_scan_{scan.entry}.nx")
+
+    # test providing output folder directly
+    assert (
+        H5ToNxProcess.deduce_output_file_path(
+            master_file_name=scan.master_file,
+            scan=scan,
+            entry=scan.entry,
+            outputdir="/tmp/",
+        )
+        == "/tmp/my_scan_entry.nx"
+    )
+
+
+def test_edf2nx_process_deduce_output_file_path(tmp_path):
+    """test EDFToNxProcess.deduce_output_file_path function"""
+    scan_path = str(tmp_path / "path" / RAW_DATA_DIR_NAME / "my_edf_scan")
+    MockEDF(
+        scan_path=scan_path,
+        n_radio=10,
+        n_ini_radio=10,
+        n_extra_radio=0,
+        dim=128,
+        dark_n=1,
+        flat_n=1,
+    )
+    scan = EDFTomoScan(scan_path)
+
+    # test NEAR_INPUT_FILE
+    assert EDFToNxProcess.deduce_output_file_path(
+        folder_path=scan_path,
+        output_dir=NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value,
+        scan=scan,
+    ) == os.path.join(tmp_path, "path", RAW_DATA_DIR_NAME, "my_edf_scan.nx")
+
+    # test PROCESSED_DATA
+    assert EDFToNxProcess.deduce_output_file_path(
+        folder_path=scan_path,
+        output_dir=NXtomomillNXDefaultOutput.PROCESSED_DATA.value,
+        scan=scan,
+    ) == os.path.join(tmp_path, "path", PROCESSED_DATA_DIR_NAME, "my_edf_scan.nx")
+
+    # test providing output dir with some formatting to be done
+    assert EDFToNxProcess.deduce_output_file_path(
+        folder_path=scan_path,
+        output_dir="{scan_parent_dir_basename}/../../toto/",
+        scan=scan,
+    ) == str(tmp_path / "toto" / "my_edf_scan.nx")
+
+    # test providing output folder directly
+    assert (
+        EDFToNxProcess.deduce_output_file_path(
+            folder_path=scan_path,
+            output_dir="/tmp/output",
+            scan=scan,
+        )
+        == "/tmp/output/my_edf_scan.nx"
+    )