tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

tomwer/core/scan/scanbase.py

@@ -1,41 +1,12 @@
-# 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.
-#
-#############################################################################*/
-
-
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "09/08/2018"
-
+from __future__ import annotations
 
 import io
 import json
 import logging
 import os
-import typing
 from glob import glob
-from typing import Optional
 import functools
+from typing import Iterable
 
 import numpy
 from silx.io.url import DataUrl
@@ -46,14 +17,15 @@ from tomoscan.identifier import VolumeIdentifier
 from tomoscan.normalization import IntensityNormalization
 from tomoscan.volumebase import VolumeBase
 from tomoscan.identifier import BaseIdentifier
+from tomoscan.esrf.volume.utils import guess_volumes
 
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.core.utils.ftseriesutils import orderFileByLastLastModification
 from tomwer.core.utils.locker import FileLockerManager
-from tomwer.core.volume.edfvolume import EDFVolume
-from tomwer.core.volume.hdf5volume import HDF5Volume
-from tomwer.core.volume.jp2kvolume import JP2KVolume
-from tomwer.core.volume.tiffvolume import TIFFVolume
+from tomwer.io.utils.raw_and_processed_data import (
+    to_raw_data_path,
+    to_processed_data_path,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -111,6 +83,7 @@ class TomwerScanBase(TomwerObject):
         self._latest_vol_reconstructions = []
         """list of url related to latest volume reconstruction from nabu"""
         self._reconstruction_paths = set()
+        """set of paths containing reconstructions of the scan. Make sure we have an entry point for it"""
         self._proposal_name = None
 
     def _clear_heavy_cache(self):
@@ -120,7 +93,7 @@ class TomwerScanBase(TomwerObject):
         pass
 
     @property
-    def working_directory(self) -> Optional[str]:
+    def working_directory(self) -> str | None:
         """
         working directory to use for this scan (for launching reconstruction for example)
         """
@@ -149,7 +122,7 @@ class TomwerScanBase(TomwerObject):
     def _flat_field_correction(
         self,
         data,
-        index_proj: typing.Union[int, None],
+        index_proj: int | None,
         dark,
         flat1,
         flat2,
@@ -160,7 +133,8 @@ class TomwerScanBase(TomwerObject):
         compute flat field correction for a provided data from is index
         one dark and two flats (require also indexes)
         """
-        assert type(data) is numpy.ndarray
+        if not isinstance(data, numpy.ndarray):
+            raise TypeError("data is expected to be an instance of numpy.ndarray")
         can_process = True
 
         if dark is None:
@@ -178,6 +152,8 @@ class TomwerScanBase(TomwerObject):
             if self._notify_ffc_rsc_missing:
                 logger.warning("cannot make flat field correction, flat not found")
             can_process = False
+        elif not isinstance(flat1, numpy.ndarray):
+            raise TypeError("flat1 is expected to be an instance of numpy.ndarray")
         else:
             if flat1.ndim != 2:
                 logger.error(
@@ -281,15 +257,15 @@ class TomwerScanBase(TomwerObject):
     def projections_with_angle(self):
         raise NotImplementedError("Base class")
 
-    def scan_dir_name(self) -> Optional[str]:
+    def scan_dir_name(self) -> str | None:
         """return name of the directory containing the acquisition"""
         raise NotImplementedError("Base class")
 
-    def scan_basename(self) -> Optional[str]:
+    def scan_basename(self) -> str | None:
         """return basename of the directory containing the acquisition"""
         raise NotImplementedError("Base class")
 
-    def scan_parent_dir_basename(self) -> Optional[str]:
+    def scan_parent_dir_basename(self) -> str | None:
         """return parent basename of the directory containing the acquisition"""
         raise NotImplementedError("Base class")
 
@@ -302,18 +278,7 @@ class TomwerScanBase(TomwerObject):
     @functools.lru_cache(maxsize=3)
     def get_opposite_projections(self, mode) -> tuple:
         """
-        Return the radios for axis calculation and the requested mode.
-
-        :param: angles we want to use for COR calculation. Can be 0-180,
-                 90-180 or manual. If manual will return the 'most' appropriate
-        :type: CorAngleMode
-        :param nearest: if True then, pick the closest angle from the requested
-                        one. If False, return (None, None) if the the angles
-                        does not exists.
-        :type: bool
-        :return: couple of `opposite` radios that can be used for axis
-                 calculation.
-        :rtype: tuple(Optional[AxisResource], Optional[AxisResource])
+        Return the two best opposite projections for the required mode.
         """
         radios_with_angle = self.projections_with_angle()
         angles = numpy.array(
@@ -325,7 +290,7 @@ class TomwerScanBase(TomwerObject):
             )
         )
 
-        from ..process.reconstruction.axis.anglemode import CorAngleMode
+        from tomwer.core.process.reconstruction.axis.anglemode import CorAngleMode
         from ..process.reconstruction.axis.params import (
             AxisResource,
         )  # avoid cyclic import
@@ -356,28 +321,22 @@ class TomwerScanBase(TomwerObject):
         nearest_c1 = find_nearest(angles=angles, angle=couples[0])
         nearest_c2 = find_nearest(angles=angles, angle=couples[1])
         if nearest_c1 is not None and nearest_c2 is not None:
-            radio_0 = AxisResource(radios_with_angle[nearest_c1])
-            radio_1 = AxisResource(radios_with_angle[nearest_c2])
-            return radio_0, radio_1
+            return (
+                AxisResource(radios_with_angle[nearest_c1], angle=nearest_c1),
+                AxisResource(radios_with_angle[nearest_c2], angle=nearest_c2),
+            )
         else:
             return None, None
 
-    def data_flat_field_correction(self, data, index=None):
+    def data_flat_field_correction(
+        self, data: numpy.ndarray, index: int | None = None
+    ) -> numpy.ndarray:
         """Apply flat field correction on the given data
 
-        :param numpy.ndarray data: the data to apply correction on
-        :param Uion[int, None] index: index of the data in the acquisition
+        :param data: the data to apply correction on
+        :param index: index of the data in the acquisition
                                       sequence
         :return: corrected data
-        :rtype: numpy.ndarray
-        """
-        raise NotImplementedError("Base class")
-
-    def getReconsParamList(self):
-        """
-
-        :return: reconstruction parameters
-        :rtype: ReconsParamList
         """
         raise NotImplementedError("Base class")
 
@@ -496,10 +455,10 @@ class TomwerScanBase(TomwerObject):
     def equal(self, other):
         """
 
-        :param :class:`.ScanBase` other: instance to compare with
+        :param other: instance to compare with
         :return: True if instance are equivalent
-        :note: we cannot use the __eq__ function because this object need to be
-               pickable
+
+        :note: we cannot use the __eq__ function because this object need to be picklable
         """
         return (
             isinstance(other, self.__class__)
@@ -509,19 +468,19 @@ class TomwerScanBase(TomwerObject):
             and self.path == other.path  # pylint: disable=E1101
         )
 
-    def get_sinogram(self, line, subsampling=1, norm_method=None, **kwargs):
+    def get_sinogram(
+        self, line: int, subsampling: int = 1, norm_method=None, **kwargs
+    ) -> numpy.ndarray:
         """
         extract the sinogram from projections
 
         :param line: which sinogram we want
-        :type: int
         :param subsampling: subsampling to apply on the sinogram
         :return: sinogram from the radio lines
-        :rtype: numpy.array
         """
         raise NotImplementedError("Base class")
 
-    def get_normed_sinogram(self, line, subsampling=1):
+    def get_normed_sinogram(self, line: int, subsampling: int = 1) -> numpy.ndarray:
         """
         Util to get the sinogram normed with settings currently defined
         on the 'intensity_normalization' property
@@ -564,50 +523,73 @@ class TomwerScanBase(TomwerObject):
         Create the scan that will be generated if this scan is
         copy to the output_dir
 
-        :param str output_dir:
+        :param output_dir:
         """
         raise NotImplementedError("Base class")
 
-    def get_proj_angle_url(self, use_cache: bool = True, *args, **kwargs):
+    def get_proj_angle_url(
+        self, use_cache: bool = True, *args, **kwargs
+    ) -> dict[int | str, DataUrl]:
         """
-        retrieve the url for each projections (including the alignement /
+        retrieve the url for each projections (including the alignment /
         return one) and associate to each (if possible) the angle.
         Alignment angle are set as angle (1) to specify that this is an
         alignment one.
-        :param bool use_cache:
+        :param use_cache:
         :return: dictionary with angle (str or int) as key and url as value
-        :rtype: dict
         """
         raise NotImplementedError("Base class")
 
-    def get_reconstructions_urls(self):
+    def get_reconstructed_slices(self) -> set[str]:
         """
-
-        :return: list of urls that contains reconstruction from nabu
-        :rtype: list
+        Return a set of all the reconstructed **slices** that can be discovered for the scan (it will only look for reconstructed slices and not the volumes!!!!)
+        slices are given as a string representing volume identifier
         """
         from tomwer.core.process.reconstruction.output import (
-            PROCESS_FOLDER_NAME,
+            PROCESS_FOLDER_RECONSTRUCTED_SLICES,
         )  # avoid cyclic import
 
-        all_recons_urls = set()
+        all_recons_ids = set()
         recons_paths = self.reconstruction_paths
+        # extend set reconstruction paths to some 'default' paths.
         if self.working_directory:
-            recons_paths.add(
-                os.path.join(
-                    self.working_directory,
-                    PROCESS_FOLDER_NAME,
-                )
+            # default output folder if using working directory
+            working_dir_output_folder = os.path.join(
+                self.working_directory,
+                PROCESS_FOLDER_RECONSTRUCTED_SLICES,
             )
-        for path in recons_paths:
-            all_recons_urls.update(self.get_reconstructions_urls_from_path(path))
-        return all_recons_urls
+            # add possible output folder: in raw_data (deprecated)
+            raw_data_output_folder = to_raw_data_path(working_dir_output_folder)
+            recons_paths.add(raw_data_output_folder)
+            # add expected output folder: in processed data
+            processed_data_output_folder = to_processed_data_path(
+                working_dir_output_folder
+            )
+            recons_paths.add(processed_data_output_folder)
 
-    def get_reconstructions_urls_from_path(self, path, check_url=False):
-        if path is None or not os.path.isdir(path):
-            return []
-        else:
+        for path in recons_paths:
+            all_recons_ids.update(self.get_reconstructed_slices_from_path(path))
+        return all_recons_ids
 
+    def get_reconstructed_slices_from_path(self, path, check_url=False) -> set[str]:
+        """
+        Look for some reconstructed slices at a specific position
+        slices are given as a string representing volume identifier
+        """
+        if path is None or not os.path.exists(path):
+            return set()
+
+        volumes = guess_volumes(path) or ()
+        # note: guess_volumes will find a volume only if the path fits a volume location
+        # like a hdf5 file containing a volume or a top level EDF volume folder.
+        # In the case path = xxx/reconstructed_slices for example it returns an empty set.
+        if len(volumes) > 0:
+            return set(
+                [volume.get_identifier().to_str() for volume in guess_volumes(path)]
+            )
+        elif os.path.isdir(path):
+            # in the case the location is a folder and doesn't fit any volume
+            # we want to look into sub folders
             from tomwer.core.process.reconstruction.saaxis.saaxis import (
                 DEFAULT_RECONS_FOLDER as MULTI_COR_DEFAULT_FOLDER,
             )
@@ -619,35 +601,26 @@ class TomwerScanBase(TomwerObject):
             )
 
             res = set()
-            for f in os.listdir(path):
+            filtered_name = (
+                "steps_file_basename_nabu_sinogram_save_step",
+                MULTI_COR_DEFAULT_FOLDER,
+                MULTI_DB_DEFAULT_FOLDER,
+                NABU_CFG_FILE_FOLDER,
+            )
+            # filter files that we already know they won't contain any reconstructed volume
+            sub_files = filter(
+                lambda name: name not in filtered_name,
+                os.listdir(path),
+            )
+            for f in sub_files:
                 current_path = os.path.join(path, f)
-                if os.path.isfile(current_path):
-                    volume = _get_reconstructed_single_file_volume(
-                        current_path, scan=self
-                    )
-                    if volume is not None:
-                        res.add(volume)
-                # avoid looking deeper if this doesn't look like a folder that could contain slices
-                elif (
-                    f
-                    in (
-                        "matlab",
-                        "steps_file_basename_nabu_sinogram_save_step",
-                        MULTI_COR_DEFAULT_FOLDER,
-                        MULTI_DB_DEFAULT_FOLDER,
-                        NABU_CFG_FILE_FOLDER,
-                    )
-                    or f.endswith("_vol")
-                    or "slice" not in f
-                ):
-                    pass
-                else:
-                    res.update(
-                        self.get_reconstructions_urls_from_path(
-                            path=current_path, check_url=check_url
-                        )
+                res.update(
+                    self.get_reconstructed_slices_from_path(
+                        path=current_path, check_url=check_url
                     )
+                )
             return res
+        return set()
 
     @property
     def latest_reconstructions(self):
@@ -662,7 +635,7 @@ class TomwerScanBase(TomwerObject):
     def clear_latest_reconstructions(self):
         self._latest_reconstructions = []
 
-    def set_latest_reconstructions(self, urls: typing.Iterable):
+    def set_latest_reconstructions(self, urls: Iterable):
         if urls is None:
             self._latest_reconstructions = None
         else:
@@ -670,7 +643,7 @@ class TomwerScanBase(TomwerObject):
                 [self._process_volume_url(url) for url in urls]
             )
 
-    def add_latest_reconstructions(self, urls: typing.Iterable):
+    def add_latest_reconstructions(self, urls: Iterable):
         self._latest_reconstructions.extend(urls)
 
     def clear_latest_vol_reconstructions(self):
@@ -689,13 +662,11 @@ class TomwerScanBase(TomwerObject):
                 f"url should be a {VolumeIdentifier} or a string reprenseting a {VolumeIdentifier}. {type(url)} provided instead"
             )
 
-    def set_latest_vol_reconstructions(self, volume_identifiers: typing.Iterable):
-        if volume_identifiers is None:
-            self._latest_vol_reconstructions = None
-        else:
-            self._latest_vol_reconstructions = list(
-                [self._process_volume_url(url) for url in volume_identifiers]
-            )
+    def set_latest_vol_reconstructions(self, volume_identifiers: Iterable | None):
+        volume_identifiers = volume_identifiers or tuple()
+        self._latest_vol_reconstructions = list(
+            [self._process_volume_url(url) for url in volume_identifiers]
+        )
 
     def add_latest_vol_reconstructions(self, volume_identifiers: tuple):
         assert isinstance(
@@ -774,11 +745,10 @@ class TomwerScanBase(TomwerObject):
                             f"set process_index from tomwer process file to {self._process_index}"
                         )
 
-    def get_nabu_dataset_info(self, binning=1, binning_z=1, proj_subsampling=1):
+    def get_nabu_dataset_info(self, binning=1, binning_z=1, proj_subsampling=1) -> dict:
         """
 
         :return: nabu dataset descriptor
-        :rtype: dict
         """
         raise NotImplementedError("Base class")
 
@@ -786,7 +756,7 @@ class TomwerScanBase(TomwerObject):
         """Return the equivalent DatasetAnalyzer for nabu"""
         raise NotImplementedError("Base class")
 
-    def get_proposal_name(self) -> Optional[str]:
+    def get_proposal_name(self) -> str | None:
         return self._proposal_name
 
     def set_proposal_name(self, proposal_name: str) -> None:
@@ -811,72 +781,6 @@ def _containsDigits(input_):
     return any(char.isdigit() for char in input_)
 
 
-def _get_reconstructed_single_file_volume(
-    file_, scan: TomwerScanBase, check_url=False
-) -> Optional[VolumeBase]:
-    scan_basename = scan.get_process_file_name
-    scan_basename = scan.get_dataset_basename()
-    if scan_basename is None:
-        logger.error("TODO")
-
-    file_base_name = os.path.basename(file_)
-    if file_base_name.startswith(scan_basename) and "slice_" in file_base_name:
-        if file_.endswith(TomwerScanBase.VALID_RECONS_EXTENSION):
-            local_str = file_
-
-            for extension in TomwerScanBase.VALID_RECONS_EXTENSION:
-                if local_str.endswith(extension):
-                    local_str = local_str.rsplit(extension, 1)[0]
-                    break
-            if "slice_pag_" in local_str:
-                indexStr = local_str.split("slice_pag_")[-1].split("_")[0]
-                volume_basename = local_str.split("slice_pag_")[0] + "slice_pag_"
-            else:
-                indexStr = local_str.split("slice_")[-1].split("_")[0]
-                volume_basename = local_str.split("slice_")[0] + "slice_"
-
-            if _containsDigits(indexStr):
-                if extension == ".edf":
-                    return EDFVolume(
-                        folder=os.path.dirname(file_),
-                        volume_basename=volume_basename,
-                    )
-
-            if extension in (".jp2", ".jp2"):
-                return JP2KVolume(
-                    folder=os.path.dirname(file_),
-                    volume_basename=volume_basename,
-                    data_extension=extension,
-                )
-            elif extension in (".tiff", ".tif"):
-                return TIFFVolume(
-                    folder=os.path.dirname(file_),
-                    volume_basename=volume_basename,
-                    data_extension=extension,
-                )
-            elif extension in (
-                (".h5", ".hdf5", ".nx", ".nxs", ".nexus", ".nx5", ".hdf")
-            ):
-                entry = getattr(scan, "entry", "entry")
-                volume = HDF5Volume(
-                    file_path=os.path.abspath(file_),
-                    data_path="/".join([entry, "reconstruction"]),
-                )
-
-                if check_url is True:
-                    try:
-                        with open_hdf5(os.path.abspath(file_)) as h5f:
-                            if entry not in h5f:
-                                logger.info("{volume} does not exists")
-                                return None
-                    except Exception:
-                        logger.info("unable to check {volume}")
-                        return None
-                    else:
-                        logger.info("{volume} checked")
-                return volume
-
-
 class NormMethod(_Enum):
     MANUAL_ROI = "manual ROI"
     AUTO_ROI = "automatic ROI"

tomwer/core/scan/scanfactory.py

@@ -1,37 +1,8 @@
-# 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.
-#
-#############################################################################*/
-
-
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "27/02/2019"
-
+from __future__ import annotations
 
 import glob
 import logging
 import os
-from typing import Union
 from urllib.parse import urlparse
 
 import h5py
@@ -56,12 +27,12 @@ class ScanFactory(object):
     @docstring(_oScanFactory.create_scan_object)
     @staticmethod
     def create_tomo_object_from_identifier(
-        identifier: Union[str, BaseIdentifier]
+        identifier: str | BaseIdentifier,
     ) -> TomoObject:
         """
         Create an instance of TomoScanBase from his identifier if possible
 
-        :param str identifier: identifier of the TomoScanBase
+        :param identifier: identifier of the TomoScanBase
         :raises: TypeError if identifier is not a str
         :raises: ValueError if identifier cannot be converted back to an instance of TomoScanBase
         """
@@ -118,16 +89,17 @@ class ScanFactory(object):
             raise ValueError(f"Scheme {scheme} not recognized")
 
     @staticmethod
-    def create_scan_object(scan_path, entry=None, accept_bliss_scan=False):
+    def create_scan_object(
+        scan_path: str, entry: str | None = None, accept_bliss_scan: bool = False
+    ) -> TomoScanBase:
         """
 
-        :param TextIOWrapper scan_path: path to the scan directory or file
+        :param scan_path: path to the scan directory or file
         :param entry: entry on the file. Requested for hdf5 files
         :param accept_bliss_scan: if True the factory can return some BlissScan
                                   But this is only compatible with the
                                   Tomomill processing.
         :return: TomwerScanBase instance fitting the scan folder or scan path
-        :rtype: tomwer.core.scan.scanbase.TomwerScanBase
         :raises: ValueError if scan_path is not containing a scan
         """
         if scan_path is None:
@@ -209,23 +181,21 @@ class ScanFactory(object):
             )
 
     @staticmethod
-    def is_tomo_scandir(scan_path):
+    def is_tomo_scandir(scan_path: str) -> bool:
         """
 
-        :param str scan_path: path to the scan directory or file
+        :param scan_path: path to the scan directory or file
         :return: True if the given path / file is a tomo_scandir. For now yes by
                  default
-        :rtype: bool
         """
         return True
 
     @staticmethod
-    def is_edf_tomo(scan_path):
+    def is_edf_tomo(scan_path: str) -> bool:
         """
 
-        :param str scan_path: path to the scan directory or file
+        :param scan_path: path to the scan directory or file
         :return: True if given path define a tomo scan based on .edf file
-        :rtype: bool
         """
         if scan_path and os.path.isdir(scan_path):
             file_basename = os.path.basename(scan_path)

tomwer/core/scan/tests/test_edf.py

@@ -0,0 +1,25 @@
+# coding: utf-8
+from __future__ import annotations
+
+import os
+
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.utils.scanutils import MockEDF
+
+
+def test_scan_dir(tmpdir):
+    full_path = os.path.join(tmpdir, "my", "aquisition", "folder")
+    MockEDF.fastMockAcquisition(full_path)
+    scan = EDFTomoScan(full_path)
+    assert scan.scan_dir_name() == "folder"
+    assert scan.scan_basename() == full_path
+
+
+def test_working_directory():
+    """test behavior of the working directory function"""
+    scan = EDFTomoScan(scan=None)
+    assert scan.working_directory is None
+    scan = EDFTomoScan(scan="my_folder")
+    assert scan.working_directory == os.path.abspath("my_folder")
+    scan = EDFTomoScan(scan="/full/path/to/my/folder")
+    assert scan.working_directory == os.path.abspath("/full/path/to/my/folder")

tomwer/core/scan/tests/test_future_scan.py

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+"""Unit test for the scan defined at the hdf5 format"""
+from __future__ import annotations
+
+import asyncio
+import os
+
+from tomwer.core.futureobject import FutureTomwerObject
+from tomwer.core.utils.scanutils import MockNXtomo
+
+
+def test_simple_future_tomo_obj(tmpdir):
+    """Simple test of the FutureTomwerScan API"""
+    scan = MockNXtomo(
+        scan_path=os.path.join(tmpdir, "scan_test"),
+        n_proj=10,
+        n_ini_proj=10,
+        create_ini_dark=False,
+        create_ini_flat=False,
+        dim=10,
+    ).scan
+    future = asyncio.Future()
+    future.set_result(None)
+
+    future_tomo_obj = FutureTomwerObject(
+        tomo_obj=scan,
+        futures=[
+            future,
+        ],
+    )
+
+    future_tomo_obj.results()
+    assert future_tomo_obj.exceptions() is None
+    assert future_tomo_obj.cancelled() is False