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

tomwer/app/canvas_launcher/mainwindow.py

@@ -16,6 +16,7 @@ from orangecanvas.application.outputview import (
     ExceptHook,
     TerminalTextDocument,
 )
+from xml.sax.saxutils import escape
 import logging
 import os
 import shutil
@@ -26,6 +27,19 @@ from .config import TomwerConfig, TomwerSplashScreen
 import tomwer.version
 from urllib.request import urlopen
 
+try:
+    import nabu
+except ImportError:
+    has_nabu = False
+else:
+    has_nabu = True
+try:
+    import nxtomomill.version
+except ImportError:
+    has_nxtomomill = False
+else:
+    has_nxtomomill = True
+
 _logger = logging.getLogger(__file__)
 
 MAX_LOG_FILE = 10
@@ -68,20 +82,27 @@ class MainWindow(_MainWindow):
         super().setup_menu()
         self.view_menu.addAction(self.show_processes_manager_action)
 
+    def open_about(self):
+        # type: () -> None
+        """Open the about dialog."""
+        dlg = AboutDialog(self)
+        dlg.setAttribute(qt.Qt.WA_DeleteOnClose)
+        dlg.exec()
+
 
 log = logging.getLogger(__name__)
 
 
-def check_for_updates():
-    pass
+def check_for_updates() -> bool:
+    return False
 
 
-def send_usage_statistics():
-    pass
+def send_usage_statistics() -> bool:
+    return False
 
 
-def pull_notifications():
-    pass
+def pull_notifications() -> bool:
+    return False
 
 
 def make_sql_logger(level=logging.INFO):
@@ -175,6 +196,47 @@ def widget_settings_dir():
     return os.path.join(data_dir(), "widgets")
 
 
+ABOUT_TEMPLATE = """\
+<center>
+<h4>{name}</h4>
+<p>tomwer version: {tomwer_version}</p>
+<p>nabu version: {nabu_version}</p>
+<p>nxtomomill version: {nxtomomill_version}</p>
+</center>
+"""
+
+
+class AboutDialog(qt.QDialog):
+    def __init__(self, parent=None, **kwargs) -> None:
+        super().__init__(parent, **kwargs)
+        layout = qt.QVBoxLayout()
+        label = qt.QLabel(self)
+
+        pixmap, _ = TomwerConfig.splash_screen()
+        pixmap = pixmap.scaled(150, 150)
+
+        label.setPixmap(pixmap)
+
+        layout.addWidget(label, qt.Qt.AlignCenter)
+
+        text = ABOUT_TEMPLATE.format(
+            name=escape("tomwer"),
+            tomwer_version=escape(tomwer.version.version),
+            nabu_version=escape(nabu.version if has_nabu else "not installed"),
+            nxtomomill_version=escape(
+                nxtomomill.version.version if has_nxtomomill else "not installed"
+            ),
+        )
+        text_label = qt.QLabel(text)
+        layout.addWidget(text_label, qt.Qt.AlignCenter)
+
+        buttons = qt.QDialogButtonBox(qt.QDialogButtonBox.Close, qt.Qt.Horizontal, self)
+        layout.addWidget(buttons)
+        buttons.rejected.connect(self.accept)
+        layout.setSizeConstraint(qt.QVBoxLayout.SetFixedSize)
+        self.setLayout(layout)
+
+
 class OMain(_OMain):
     config: TomwerConfig
     DefaultConfig = "tomwer.app.canvas_launcher.config.TomwerConfig"

tomwer/app/canvas_launcher/widgetsscheme.py

@@ -50,9 +50,7 @@ class WidgetsScheme(Scheme):
         return changed
 
     def show_report_view(self):
-        inst = self.report_view()
-        inst.show()
-        inst.raise_()
+        return
 
     def has_report(self):
         """

tomwer/app/darkref.py

@@ -6,7 +6,7 @@ import logging
 import signal
 import sys
 from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.core.process.reconstruction.darkref.params import Method
+from tomwer.core.process.reconstruction.darkref.params import ReduceMethod
 from tomwer.core.process.reconstruction.darkref.params import DKRFRP
 from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefs
 from tomwer.core.utils.resource import increase_max_number_file
@@ -24,11 +24,15 @@ def _exec_without_interaction(scan, dark_method, flat_method, overwrite):
     recons_params.overwrite_dark = overwrite
     recons_params.overwrite_ref = overwrite
     recons_params.dark_calc_method = dark_method
-    recons_params.ref_calc_method = flat_method
-    dark_ref = DarkRefs()
-    dark_ref.set_recons_params(recons_params)
+    recons_params.flat_calc_method = flat_method
+    dark_ref = DarkRefs(
+        inputs={
+            "data": scan,
+            "dark_ref_params": recons_params,
+        }
+    )
     _logger.info("Start processing of {}".format(str(scan)))
-    dark_ref.process(scan)
+    dark_ref.run()
     _logger.info("End processing of {}".format(str(scan)))
     return 0
 
@@ -37,7 +41,7 @@ def _exec_with_interaction(scan, dark_method, flat_method, overwrite):
     from silx.gui import qt
     from tomwer.gui import icons
     from tomwer.gui.reconstruction.darkref.darkrefwidget import DarkRefWidget
-    from tomwer.synctools.ftseries import _QDKRFRP
+    from tomwer.synctools.darkref import QDKRFRP
     from tomwer.gui.utils.splashscreen import getMainSplashScreen
 
     class _DarkRefWidgetRunnable(DarkRefWidget):
@@ -45,7 +49,7 @@ def _exec_with_interaction(scan, dark_method, flat_method, overwrite):
 
         def __init__(self, scan, parent=None):
             self.__scan = scan
-            self.__darkref_rp = _QDKRFRP()
+            self.__darkref_rp = QDKRFRP()
             DarkRefWidget.__init__(self, parent=parent, reconsparams=self.__darkref_rp)
             buttonExec = qt.QPushButton("execute", parent=self)
             buttonExec.setAutoDefault(True)
@@ -91,7 +95,7 @@ def _exec_with_interaction(scan, dark_method, flat_method, overwrite):
     widget.recons_params.overwrite_dark = overwrite
     widget.recons_params.overwrite_ref = overwrite
     widget.recons_params.dark_calc_method = dark_method
-    widget.recons_params.ref_calc_method = flat_method
+    widget.recons_params.flat_calc_method = flat_method
     splash.finish(widget)
     widget.show()
     return app.exec_()
@@ -110,12 +114,12 @@ def main(argv):
     parser.add_argument(
         "--dark-method",
         help="Define the method to be used for computing dark",
-        default=Method.average,
+        default=ReduceMethod.MEAN,
     )
     parser.add_argument(
         "--flat-method",
         help="Define the method to be used for computing flat",
-        default=Method.median,
+        default=ReduceMethod.MEDIAN,
     )
     parser.add_argument(
         "--no-gui",
@@ -149,8 +153,8 @@ def main(argv):
     scan = ScanFactory.create_scan_object(options.scan_path, entry=options.entry)
     scan.set_process_index_frm_tomwer_process_file()
 
-    dark_method = Method.from_value(options.dark_method)
-    flat_method = Method.from_value(options.flat_method)
+    dark_method = ReduceMethod.from_value(options.dark_method)
+    flat_method = ReduceMethod.from_value(options.flat_method)
 
     if options.run:
         exit(

tomwer/app/imagekeyeditor.py

@@ -8,7 +8,7 @@ import argparse
 from tomwer.gui import icons
 from tomwer.gui.utils.splashscreen import getMainSplashScreen
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomoscan.esrf.hdf5scan import ImageKey
+from tomoscan.esrf.scan.hdf5scan import ImageKey
 from tomwer.gui.edit.imagekeyeditor import ImageKeyDialog as _ImageKeyDialog
 from nxtomomill.utils import change_image_key_control
 from tomwer.core.utils.resource import increase_max_number_file
@@ -56,7 +56,7 @@ class ImageKeyDialog(_ImageKeyDialog):
 
 
 def getinputinfo():
-    return "tomwer nabu [scan_path]"
+    return "tomwer image-key-editor [scan_path] [entry]"
 
 
 def sigintHandler(*args):

tomwer/app/imagekeyupgrader.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import logging
+import sys
+from silx.gui import qt
+import argparse
+from tomwer.gui import icons
+from tomwer.gui.utils.splashscreen import getMainSplashScreen
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.gui.edit.imagekeyeditor import (
+    ImageKeyUpgraderWidget as _ImageKeyUpgraderWidget,
+)
+from tomwer.core.process.edit.imagekeyeditor import ImageKeyUpgraderTask
+from tomwer.core.utils.resource import increase_max_number_file
+import signal
+
+logging.basicConfig(level=logging.WARNING)
+_logger = logging.getLogger(__name__)
+
+
+class ImageKeyUpgraderDialog(qt.QDialog):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._scan = None
+
+        self.setLayout(qt.QVBoxLayout())
+        self._widget = _ImageKeyUpgraderWidget(self)
+        self.layout().addWidget(self._widget)
+
+        types = qt.QDialogButtonBox.Ok | qt.QDialogButtonBox.Cancel
+        self._buttons = qt.QDialogButtonBox(self)
+        self._buttons.setStandardButtons(types)
+        self.layout().addWidget(self._buttons)
+
+        # signal / slot connection
+        self._buttons.button(qt.QDialogButtonBox.Ok).released.connect(self.validate)
+        self._buttons.button(qt.QDialogButtonBox.Cancel).released.connect(self.close)
+
+    def setScan(self, scan):
+        if not isinstance(scan, HDF5TomoScan):
+            raise TypeError("This only manage HDF5TomoScan")
+        self._scan = scan
+
+    def validate(self):
+        operations = self._widget.getOperations()
+        task = ImageKeyUpgraderTask(
+            inputs={
+                "data": self._scan,
+                "operations": operations,
+            },
+        )
+        task.run()
+        print("edition finished")
+        self.close()
+
+
+def getinputinfo():
+    return "tomwer image-key-upgrader [scan_path] [entry]"
+
+
+def sigintHandler(*args):
+    """Handler for the SIGINT signal."""
+    qt.QApplication.quit()
+
+
+def main(argv):
+    import os
+
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("scan_path", help="NXtomo to edit")
+    parser.add_argument("entry", default=None, help="Entry to treat")
+    options = parser.parse_args(argv[1:])
+
+    # image key can only handle HDF5Tomoscan for now
+    scan = HDF5TomoScan(scan=options.scan_path, entry=options.entry)
+    increase_max_number_file()
+
+    app = qt.QApplication.instance() or qt.QApplication([])
+
+    qt.QLocale.setDefault(qt.QLocale(qt.QLocale.English))
+    qt.QLocale.setDefault(qt.QLocale.c())
+    signal.signal(signal.SIGINT, sigintHandler)
+    sys.excepthook = qt.exceptionHandler
+    timer = qt.QTimer()
+    timer.start(500)
+    # Application have to wake up Python interpreter, else SIGINT is not
+    # catch
+    timer.timeout.connect(lambda: None)
+
+    splash = getMainSplashScreen()
+    options.scan_path = options.scan_path.rstrip(os.path.sep)
+
+    widget = ImageKeyUpgraderDialog(parent=None)
+    widget.setScan(scan)
+    widget.setWindowTitle("Image key upgrader")
+    widget.setWindowIcon(icons.getQIcon("tomwer"))
+    splash.finish(widget)
+    widget.show()
+    app.exec_()
+
+
+if __name__ == "__main__":
+    main(sys.argv)

tomwer/app/intensitynormalization.py

@@ -46,7 +46,6 @@ class IntensityNormalizationThread(qt.QThread):
         self._result = None
 
     def run(self) -> None:
-
         process = SinoNormalizationTask(
             process_id=None,
             inputs={

tomwer/app/nxtomoeditor.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+import argparse
+from silx.gui import qt
+import signal
+from tomwer.gui.utils.splashscreen import getMainSplashScreen
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.gui.edit.nxtomoeditor import NXtomoEditorDialog as _NXtomoEditorDialog
+import logging
+
+
+logging.basicConfig(level=logging.WARNING)
+_logger = logging.getLogger(__name__)
+
+
+class NXtomoEditorDialog(_NXtomoEditorDialog):
+    def __init__(self) -> None:
+        super().__init__()
+
+        # connect signal / slot
+        self._buttons.button(qt.QDialogButtonBox.Ok).released.connect(
+            self._overwriteNXtomo
+        )
+
+    def _overwriteNXtomo(self, *args, **kwargs):
+        print("start overwrite")
+        try:
+            self.overwriteNXtomo()
+        except Exception as e:
+            print(f"write failed with error {e}")
+        else:
+            print("overwrite succeded")
+
+
+def main(argv):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("scan_path", help="nexus file (HDF5 file) to edit.")
+    parser.add_argument(
+        "entry",
+        help="path to the file where starts the NXtomo. Usually named 'entry', or 'entryXXXX'",
+    )
+    parser.add_argument(
+        "--debug",
+        dest="debug",
+        action="store_true",
+        default=False,
+        help="Set logging system in debug mode",
+    )
+
+    options = parser.parse_args(argv[1:])
+
+    if options.debug:
+        logging.root.setLevel(logging.DEBUG)
+
+    global app  # QApplication must be global to avoid seg fault on quit
+    app = qt.QApplication.instance() or qt.QApplication([])
+    splash = getMainSplashScreen()
+    qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
+    app.processEvents()
+
+    qt.QLocale.setDefault(qt.QLocale(qt.QLocale.English))
+    qt.QLocale.setDefault(qt.QLocale.c())
+    signal.signal(signal.SIGINT, sigintHandler)
+    sys.excepthook = qt.exceptionHandler
+
+    timer = qt.QTimer()
+    timer.start(500)
+    # Application have to wake up Python interpreter, else SIGINT is not
+    # catch
+    timer.timeout.connect(lambda: None)
+
+    try:
+        scan = ScanFactory.create_scan_object(
+            scan_path=options.scan_path, entry=options.entry
+        )
+    except Exception as e:
+        _logger.error(
+            f"Fail to find an NXtomo from {options.scan_path} at {options.entry}. Error is {e}"
+        )
+        return
+
+    dialog = NXtomoEditorDialog()
+    dialog.setScan(scan)
+    dialog.show()
+    splash.finish(dialog)
+
+    qt.QApplication.restoreOverrideCursor()
+    app.exec_()
+
+
+def getinputinfo():
+    return "tomwer nxtomo-editor [scanDir]"
+
+
+def sigintHandler(*args):
+    """Handler for the SIGINT signal."""
+    qt.QApplication.quit()
+
+
+if __name__ == "__main__":
+    main(sys.argv)

tomwer/app/rsync.py

@@ -92,7 +92,7 @@ def main(argv):
 
         # fresh option treatment
         def refresh_dir(dir_):
-            logger.info("recreate", dir_)
+            logger.info(f"recreate {dir_}")
             shutil.rmtree(dir_)
             os.makedirs(dir_)
 

tomwer/core/cluster/cluster.py

@@ -42,7 +42,7 @@ class SlurmClusterConfiguration:
         n_cpu_per_task=_SlurmSettings.N_CORES_PER_TASK,
         n_tasks=_SlurmSettings.N_TASKS,
         memory=_SlurmSettings.MEMORY_PER_WORKER,
-        queue=_SlurmSettings.PARTIION,
+        queue=_SlurmSettings.PARTITION,
         n_gpus=_SlurmSettings.N_GPUS_PER_WORKER,
         project_name=_SlurmSettings.PROJECT_NAME,
         walltime=_SlurmSettings.DEFAULT_WALLTIME,

tomwer/core/futureobject.py

@@ -67,6 +67,7 @@ class FutureTomwerObject:
             raise TypeError(
                 f"scan is expected to be an instance of {TomwerObject} not {type(tomo_obj)}"
             )
+        self._job_id = None
         self._tomo_obj = tomo_obj
         self._start_time = (
             start_time if start_time is not None else datetime.datetime.now()

tomwer/core/process/control/datalistener/datalistener.py

@@ -40,6 +40,7 @@ from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomoscan.io import HDF5File
 from silx.io.utils import h5py_read_dataset
 from ewokscore.task import Task as EwoksTask
+from tomwer.core.scan.blissscan import BlissScan
 import typing
 import time
 
@@ -469,7 +470,12 @@ class DataListener(BaseProcessInfo):
         configuration = HDF5Config.from_dict(conf)
         if configuration.output_file is None:
             output_file_path = NxTomomillProcess.deduce_output_file_path(
-                bliss_file, entry=entry, outputdir=None
+                bliss_file,
+                entry=entry,
+                outputdir=None,
+                scan=BlissScan(
+                    master_file=bliss_file, entry=entry, proposal_file=bliss_file
+                ),
             )
         else:
             output_file_path = configuration.output_file

tomwer/core/process/control/datalistener/rpcserver.py

@@ -68,7 +68,7 @@ class BlissAcquisition:
         self.proposal_file = proposal_file
         self.sample_file = sample_file
         self.scan_numbers = []
-        self.status = BlissAcquisition
+        self.status = TangoAcquisitionStatus.STARTED
         self._start_time = start_time
         self._end_time = None
         self._error = None
@@ -151,7 +151,6 @@ class _BaseDataListenerThread:
     def _rpc_sequence_started(
         self, saving_file, scan_title, sequence_scan_number, proposal_file, sample_file
     ):
-
         self._current_sequence = BlissAcquisition(
             file_path=saving_file,
             entry_name=sequence_scan_number,
@@ -187,7 +186,7 @@ class _BaseDataListenerThread:
     def scan_ended(self, acquisition: BlissAcquisition, scan_number):
         print("scan {} ended".format(scan_number))
 
-    def _rpc_sequence_ended(self, saving_file, sequence_scan_number, success):
+    def _rpc_sequence_ended(self, saving_file, sequence_scan_number, success: bool):
         if success is False:
             _logger.warning(
                 "sequence {}@{} failed".format(sequence_scan_number, saving_file)
@@ -196,7 +195,7 @@ class _BaseDataListenerThread:
                 try:
                     self.sequence_failed(self._current_sequence)
                 except Exception as e:
-                    _logger.warning("Fail to catch cancel scan. error is", e)
+                    _logger.warning(f"Fail to catch cancel scan. error is {e}")
 
             return
 

tomwer/core/process/control/datawatcher/datawatcher.py

@@ -53,8 +53,16 @@ from ewokscore.task import Task as EwoksTask
 logger = logging.getLogger(__name__)
 
 
-class _DataWatchertaskPlaceHolder(EwoksTask, output_names=("data",)):
-    pass
+class DataWatcherEwoksTask(EwoksTask, input_names=["data"], output_names=["data"]):
+    """
+    For now the data watcher is a 'special case'. Because it will trigger downstream workflows / prcessing each time it discover
+    a new scan.
+    To move to 'default' ewoks workflows. Like launching it from the command line the simpler for now is to
+    simply pass the `data` input that user can fill manually.
+    """
+
+    def run(self):
+        self.outputs.data = self.inputs.data
 
 
 class _DataWatcher(BaseProcessInfo):
@@ -93,6 +101,10 @@ class _DataWatcher(BaseProcessInfo):
         self._launchObservation()
         self._checkThread = None
 
+    def _launchObservation(self):
+        """Main function of the widget"""
+        raise NotImplementedError("Base class")
+
     def _initClass(self):
         self.srcPattern = get_lbsram_path()
         self.destPattern = get_dest_path()
@@ -188,15 +200,6 @@ class _DataWatcher(BaseProcessInfo):
 
             return True
 
-    def isObserving(self):
-        """
-
-        :return bool: True if the widget is actually observing the root
-                      directory
-
-        """
-        return self.isObserving
-
     def _setIsObserving(self, b):
         self.isObserving = b
 
@@ -316,10 +319,7 @@ class _DataWatcher(BaseProcessInfo):
                                 _scan = ScanFactory.create_scan_object(scan_path=scanID)
                             except Exception as e:
                                 logger.error(
-                                    "Fail to create TomoBase from",
-                                    scanID,
-                                    "Error is",
-                                    e,
+                                    f"Fail to create TomoBase from {scanID}. Error is {e}"
                                 )
                             else:
                                 self._signalScanReady(scan=_scan)
@@ -369,14 +369,14 @@ class _DataWatcher(BaseProcessInfo):
             try:
                 scan = ScanFactory.create_scan_object(scan_path=info)
             except Exception as e:
-                logger.warning("Fail to create scan object from", info, "Reason is", e)
+                logger.warning(f"Fail to create scan object from {info}. Reason is {e}")
             else:
                 self._signalScanReady(scan=scan)
 
     def _signalScanReady(self, scan):
         assert isinstance(scan, (TomwerScanBase, BlissScan))
         self.lastFoundScans.add(scan)
-        self.sigScanReady.emit(scan)
+        self.sigScanReady.emit(scan)  # pylint: disable=E1101
 
     def mockObservation(self, folder):
         # simple mocking emitting a signal to say that the given folder is valid
@@ -446,7 +446,7 @@ class DataWatcher(_DataWatcher):
         # manage data watcher observation
         if self.observationThread is None or not self._observation_thread_running():
             if self._initObservation() is False:
-                self.currentStatus = self._setCurrentStatus("failure")
+                self._setCurrentStatus("failure")
                 logger.info(
                     "failed on observation",
                     extra={logconfig.DOC_TITLE: self._scheme_title},

tomwer/core/process/control/datawatcher/datawatcherobserver.py

@@ -39,7 +39,6 @@ import threading
 from collections import OrderedDict
 from typing import Optional
 from tomwer.core.process.control.datawatcher import status as datawatcherstatus
-from tomwer.web.client import OWClient
 from .edfdwprocess import (
     _DataWatcherProcessParseInfo,
     _DataWatcherProcessUserFilePattern,
@@ -56,7 +55,7 @@ import h5py
 logger = logging.getLogger(__name__)
 
 
-class _DataWatcherStaticObserverMixIn(OWClient):
+class _DataWatcherStaticObserverMixIn:
     def __init__(
         self,
         scanID,
@@ -75,7 +74,6 @@ class _DataWatcherStaticObserverMixIn(OWClient):
         :param Union[str,None] patternObs:
         :param observationRegistry: what registry the observation should update
         """
-        OWClient.__init__(self)
         self.obsMethod = obsMethod
         self.srcPattern = srcPattern
         self.destPattern = destPattern
@@ -271,7 +269,7 @@ class _DataWatcherStaticObserver(_DataWatcherStaticObserverMixIn, threading.Thre
         )
 
 
-class _DataWatcherObserver_MixIn(OWClient):
+class _DataWatcherObserver_MixIn:
     """Thread launching the data watcher process (observation of acquisition)
 
     :param str headDir: the root dir to make to fin dacquisition
@@ -302,7 +300,6 @@ class _DataWatcherObserver_MixIn(OWClient):
         ignoredFolders=None,
         file_name_pattern=None,
     ):
-        OWClient.__init__(self)
         self.observations = observationClass()
         self.observations.ignoredFolders = (
             [] if ignoredFolders is None else ignoredFolders
@@ -385,11 +382,11 @@ class _DataWatcherObserver_MixIn(OWClient):
             if not os.path.isdir(self.headDir):
                 logger.warning("can't observe %s, not a directory" % self.headDir)
                 return
-            self._check_scans_ready()
+            self._check_scans_ready()  # pylint: disable=E1101
             self.dataWatcherProcess = self._getDataWatcherProcess()
             process_observations(self.headDir)
             self._processObservation()
-            self._check_scans_ready()
+            self._check_scans_ready()  # pylint: disable=E1101
         else:
             time.sleep(0.5)
 
@@ -473,7 +470,7 @@ class _DataWatcherObserver_MixIn(OWClient):
             thread.setSourceToDestinationPatterns(self.srcPattern, self.destPattern)
 
     def observe(self, scanID):
-        self.observations.add(self._getObserver(scanID))
+        self.observations.add(self._getObserver(scanID))  # pylint: disable=E1101
 
     def cancelObservation(self, scanID):
         if self.observations.isObserving(scanID) is False: