tomwer 0.5.0__tar.gz → 0.5.0b1__tar.gz

home/payno/.local/share/virtualenvs/tomwer_venv/bin/tomwer

@@ -1,6 +1,6 @@
 #!/home/payno/.local/share/virtualenvs/tomwer_venv/bin/python
-# EASY-INSTALL-ENTRY-SCRIPT: 'tomwer==0.5.0','console_scripts','tomwer'
-__requires__ = 'tomwer==0.5.0'
+# EASY-INSTALL-ENTRY-SCRIPT: 'tomwer==0.5.0b1','console_scripts','tomwer'
+__requires__ = 'tomwer==0.5.0b1'
 import re
 import sys
 from pkg_resources import load_entry_point
@@ -8,5 +8,5 @@ from pkg_resources import load_entry_point
 if __name__ == '__main__':
     sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
     sys.exit(
-        load_entry_point('tomwer==0.5.0', 'console_scripts', 'tomwer')()
+        load_entry_point('tomwer==0.5.0b1', 'console_scripts', 'tomwer')()
     )

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/__init__.py

@@ -37,7 +37,6 @@ def widget_discovery(discovery):
         "orangecontrib.tomwer.widgets.control",
         "orangecontrib.tomwer.widgets.reconstruction",
         "orangecontrib.tomwer.widgets.visualization",
-        "orangecontrib.tomwer.widgets.other",
     ]
     for pkg in pkgs:
         discovery.process_category_package(pkg, distribution=dist)
@@ -55,13 +54,14 @@ WIDGET_HELP_PATH = (
     # # before the wheel is created.
     ("{}/help/tomwer/index.html".format(sysconfig.get_path("data")), None),
 
-    ("http://www.silx.org/pub/doc/tomwer/htmlhelp/0.5/", ""),
+    ("http://www.silx.org/pub/doc/tomwer/.htmlhelp/0.4/", ""),
 )
 
 
-import unittest
 
 
+import unittest
+
 def suite():
 
     test_suite = unittest.TestSuite()

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/DataListenerOW.py

@@ -29,7 +29,7 @@ __date__ = "06/03/2020"
 
 
 from silx.gui import qt
-from orangecontrib.tomwer.widgets.utils import WidgetLongProcessing
+from ..utils import WidgetLongProcessing
 from Orange.widgets import widget, gui
 from Orange.widgets.widget import Output
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -40,10 +40,7 @@ from tomwer.gui.control.datalistener import DataListenerWidget
 from tomwer.synctools.datalistener import MockDataListenerQThread
 from tomwer.web.client import OWClient
 from Orange.widgets import settings
-import functools
 import logging
-import signal
-import sys
 
 logger = logging.getLogger(__name__)
 
@@ -53,13 +50,13 @@ class DataListenerOW(widget.OWWidget, OWClient, WidgetLongProcessing,
     """
     This widget is used to listen to a server notifying the widget when an
     acquisition is finished.
-    Then the bliss file will be converted to .nx file, NXtomo compliant.
+    Then the tango file will be converted to .nx file, NXtomo compliant.
     """
     name = "data listener"
     id = "orangecontrib.widgets.tomwer.control.DataListenerOW.DataListenerOW"
-    description = "The widget will receive information from bliss acquisition " \
-                  "and wait for acquisition to be finished. Once finished it " \
-                  "will call nxtomomill to convert from bliss .hdf5 to " \
+    description = "The widget will listen to (hdf5) tango acquisition and " \
+                  "wait for acquisition to be finished. Once finished it " \
+                  "will call nxtomomill to convert from tango .hdf5 to " \
                   "NXtomo compliant .nx file"
     icon = "icons/datalistener.svg"
     priority = 2
@@ -95,27 +92,18 @@ class DataListenerOW(widget.OWWidget, OWClient, WidgetLongProcessing,
         # signal / slot connection
         self._widget.sigActivate.connect(self._activated)
         self._widget.sigDeactivate.connect(self._deactivated)
-        self._widget.sigConfigurationChanged.connect(self._jsonRPCConfigChanged)
+        self._widget.sigConfigurationChanged.connect(self._tangoDeviceChanged)
         self._widget.sigAcquisitionEnded.connect(self._process_bliss_file_frm_tuple)
 
-        # manange server stop when delete directly the widget or stop by Ctr+C
-        signal.signal(signal.SIGINT, self.handleSigTerm)
-        onDestroy = functools.partial(self._stopServerBeforeclosing)
-        self.destroyed.connect(onDestroy)
-
         # set up
         if self._blissConfiguration != {}:
             self._widget.setBlissServerConfiguation(self._blissConfiguration)
 
     def _process_bliss_file_frm_tuple(self, t):
-        master_file, entry, proposal_file, saving_file = t
-        try:
-            self.process_sample_file(sample_file=master_file,
-                                     entry=str(entry) + '.1',
-                                     proposal_file=proposal_file,
-                                     master_sample_file=saving_file)
-        except Exception as e:
-            logger.error(e)
+        master_file, entry, proposal_file = t
+        return self.process_bliss_file(bliss_file=master_file,
+                                       entry=entry,
+                                       proposal_file=proposal_file)
 
     def _activated(self):
         self.activate(True)
@@ -146,7 +134,7 @@ class DataListenerOW(widget.OWWidget, OWClient, WidgetLongProcessing,
         msg.setText(text)
         return msg.exec_() == qt.QMessageBox.Ok
 
-    def _jsonRPCConfigChanged(self):
+    def _tangoDeviceChanged(self):
         self._blissConfiguration = self._widget.getBlissServerConfiguration()
         if self.is_active():
             self.activate(False)
@@ -156,32 +144,18 @@ class DataListenerOW(widget.OWWidget, OWClient, WidgetLongProcessing,
         self._mock = mock
         self._mock_acquisitions = acquisitions
 
-    @docstring(DataListenerWidget.getHost)
-    def getHost(self):
-        return self._widget.getHost()
-
-    @docstring(DataListenerWidget.getPort)
-    def getPort(self):
-        return self._widget.getPort()
-
     @docstring(DataListener.create_listening_thread)
     def create_listening_thread(self):
         if self._mock is True:
-            thread = MockDataListenerQThread(host=self.getHost(),
-                                             port=self.getPort(),
-                                             acquisitions=None,
+            thread = MockDataListenerQThread(acquisitions=None,
                                              mock_acquisitions=self._mock_acquisitions)
         else:
-            thread = DataListenerQThread(host=self.getHost(),
-                                         port=self.getPort(),
+            thread = DataListenerQThread(device=self.session_name,
                                          acquisitions=None)
         # connect thread
-        thread.sigAcquisitionStarted.connect(self._widget._acquisitionStarted,
-                                             qt.Qt.DirectConnection)
-        thread.sigAcquisitionEnded.connect(self._widget._acquisitionEnded,
-                                           qt.Qt.DirectConnection)
-        thread.sigScanAdded.connect(self._widget._acquisitionUpdated,
-                                    qt.Qt.DirectConnection)
+        thread.sigAcquisitionStarted.connect(self._widget._acquisitionStarted)
+        thread.sigAcquisitionEnded.connect(self._widget._acquisitionEnded)
+        thread.sigScanAdded.connect(self._widget._acquisitionUpdated)
         return thread
 
     @docstring(DataListener.delete_listening_thread)
@@ -191,28 +165,12 @@ class DataListenerOW(widget.OWWidget, OWClient, WidgetLongProcessing,
         self._listening_thread.sigScanAdded.disconnect(self._widget._acquisitionUpdated)
         DataListener.delete_listening_thread(self)
 
-    def _stopServerBeforeclosing(self):
+    def close(self):
         self.activate(False)
-
-    def handleSigTerm(self, signo, *args, **kwargs):
-        if signo == signal.SIGINT:
-            self._stopServerBeforeclosing()
-            sys.exit()
+        widget.OWWidget.close(self)
 
     def _get_n_scan_observe(self):
         return self._widget._observationWidget.observationTable.model().rowCount()
 
     def _get_n_scan_finished(self):
         return self._widget._historyWindow.scanHistory.model().rowCount()
-def start_app():
-    listener = DataListenerOW()
-    listener.activate()
-    listener.show()
-
-
-if __name__ == '__main__':
-    app = qt.QApplication([])
-
-    start_app()
-
-    exit(app.exec_())

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/DataTransfertOW.py

@@ -128,7 +128,5 @@ class DataTransfertOW(widget.OWWidget, FolderTransfert, OWClient):
 
     @Inputs.data_in
     def process(self, scan, move=False, force=True, noRsync=False):
-        if scan is None:
-            return
         FolderTransfert.process(self, scan=scan, move=move, force=force,
                                 noRsync=noRsync)

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/FilterOW.py

@@ -81,8 +81,6 @@ class NameFilterOW(widget.OWWidget, OWClient):
 
     @Inputs.data_in
     def applyfilter(self, scan):
-        if scan is None:
-            return
         assert isinstance(scan, TomwerScanBase)
         if not self.widget.isFiltered(scan.path):
             self._signalScanReady(scan)

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/NXTomomillOW.py

@@ -62,12 +62,12 @@ def _nxtomomill_input_callback(entry, desc):
 
 class NXTomomillOW(widget.OWWidget, OWClient):
     """
-    Widget to allow user to pick some bliss files and that will convert them
-    to HDF5scan.
+    Widget to allow user to pick some tango files and that will
+    convert them to HDF5scan
     """
     name = "nxtomomill"
     id = "orange.widgets.tomwer.control.NXTomomillOW.NXTomomillOW"
-    description = "Read a bliss .h5 file and extract from it all possible" \
+    description = "Read a tango .h5 file and extract from it all possible" \
                   "NxTomo. When validated create a TomwerBaseScan for each " \
                   "file and entry"
     icon = "icons/nxtomomill.svg"
@@ -132,30 +132,29 @@ class NXTomomillOW(widget.OWWidget, OWClient):
                 if not self._userAgreeForOverwrite(output_file_path):
                     continue
             try:
-                conv = nxtomomill_converter.h5_to_nx(input_file_path=file_path,
-                                                     output_file=output_file_path,
-                                                     entries=(entry,),
-                                                     single_file=True,
-                                                     ask_before_overwrite=False,
-                                                     request_input=self.request_input,
-                                                     file_extension='.nx',
-                                                     input_callback=_nxtomomill_input_callback)
+                nxtomomill_converter.h5_to_nx(input_file_path=file_path,
+                                              output_file=output_file_path,
+                                              entries=(entry,),
+                                              single_file=True,
+                                              ask_before_overwrite=False,
+                                              request_input=self.request_input,
+                                              file_extension='.nx',
+                                              input_callback=_nxtomomill_input_callback)
             except Exception as e:
                 logger.error(
-                    'Fail to convert from bliss file: %s to NXTomo.'
+                    'Fail to convert from tango file: %s to NXTomo.'
                     'Conversion error is: %s' % (bliss_url, e))
             else:
-                if len(conv) != 1:
-                    logger.error(
-                        'Something went wrong during file conversion. Unable to process the file.')
-                else:
-                    conv_file, conv_entry = conv[0]
-                    scan_converted = HDF5TomoScan(scan=conv_file, entry=conv_entry)
-                    mess = "sending one scan %s" % bliss_url
-                    logger.debug(mess,
-                                 extra={logconfig.DOC_TITLE: self.widget._scheme_title,
-                                        logconfig.SCAN_ID: bliss_url})
-                    self.Outputs.data_out.send(scan_converted)
+                if not os.path.isfile(output_file_path):
+                    raise ValueError(output_file_path + ' is not a file path')
+                entries = HDF5TomoScan.get_valid_entries(output_file_path)
+                assert len(entries) == 1
+                scan_converted = HDF5TomoScan(scan=output_file_path, entry=entries[0])
+                mess = "sending one scan %s" % bliss_url
+                logger.debug(mess,
+                             extra={logconfig.DOC_TITLE: self.widget._scheme_title,
+                                    logconfig.SCAN_ID: bliss_url})
+                self.Outputs.data_out.send(scan_converted)
 
     def _userAgreeForOverwrite(self, file_path):
         msg = qt.QMessageBox(self)

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/test/test_datalistener.py

@@ -38,7 +38,7 @@ from silx.gui.utils.testutils import TestCaseQt
 from tomwer.test.utils import skip_gui_test
 from tomwer.core.utils.scanutils import MockHDF5
 from orangecontrib.tomwer.widgets.control.DataListenerOW import DataListenerOW
-from tomwer.core.process.datalistener.rpcserver import BlissAcquisition
+from tomwer.core.process.datalistener.tangosyncclient import TangoAcquisition
 from tomwer.core import settings
 
 
@@ -79,9 +79,9 @@ class TestDataListenerSynchronization(TestCaseQt):
         data dir when receive it"""
         self.assertEqual(len(os.listdir(self._dst_dir)), 0)
         self.widget.activate(True)
-        tango_acquisition = BlissAcquisition(self.scan.master_file,
+        tango_acquisition = TangoAcquisition(self.scan.master_file,
                                              'entry', start_time=time.ctime())
-        self.widget.get_listening_thread()._rpc_sequence_started(tango_acquisition)
+        self.widget.get_listening_thread().sequence_started(tango_acquisition)
         time.sleep(1.0)
         self.assertEqual(self.widget._get_n_scan_observe(), 1)
         self.assertEqual(len(os.listdir(self._dst_dir)), 1)

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/reconstruction/AxisOW.py

@@ -42,7 +42,6 @@ from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from silx.gui import qt
 from tomwer.core import settings
 from tomwer.core import utils
-import functools
 
 import logging
 
@@ -111,9 +110,6 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
         self.__scan = None
         self.__skip_exec = False
         self._n_skip = 0
-        self._patches = []
-        """patches for processing"""
-
         if self._rpSetting != dict():
             try:
                 self._axis_params.load_from_dict(self._rpSetting)
@@ -142,11 +138,11 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
         self._processingStack.sigComputationEnded.connect(self._scanProcessed)
 
         # connect sinogram calculation signal
-        self._widget._axisWidget._sinogramAxis.sigSinoLoadStarted.connect(self._processingStart)
-        self._widget._axisWidget._sinogramAxis.sigSinoLoadEnded.connect(self._endProcessing)
+        self._widget._sinogramAxis.sigSinoLoadStarted.connect(self._processingStart)
+        self._widget._sinogramAxis.sigSinoLoadEnded.connect(self._endProcessing)
 
         # expose API
-        #self.setLockValue = self._widget.setLocked
+        self.setLockValue = self._widget.setLocked
         self.getAxis = self._widget.getAxis
         self.setModeLock = self._widget.setModeLock
 
@@ -158,7 +154,7 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
         assert isinstance(scan, TomwerScanBase)
         WidgetLongProcessing._endProcessing(self, scan)
         self._widget._enableForProcessing()
-        if self.isValueLock() or self.isModeLocked():
+        if self.isValueLocked() or self.isModeLocked():
             self.__scan = scan
             self.__validate()
         else:
@@ -170,10 +166,9 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
     def __compute(self):
         if self.__scan:
             self.__lastAxisProcessParamsCache = self._axis_params.to_dict(), str(self.__scan)
-            callback = functools.partial(self._updatePosition, self.__scan)
             self._processingStack.add(scan=self.__scan,
                                       configuration=self._axis_params.to_dict(),
-                                      callback=callback)
+                                      callback=None)
 
     def __validate(self):
         """Validate the current scan and move the scan to the next process.
@@ -224,12 +219,12 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
         """
         self._widget.setLocked(lock)
 
-    def isValueLock(self):
+    def isValueLocked(self):
         """
         Check if the cor value has been lock. If so we simply copy the cor
         value and move to the next scan
         """
-        return self._widget.isValueLock()
+        return self._widget.isValueLocked()
 
     def isModeLocked(self):
         """
@@ -239,27 +234,18 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
         return self._widget.isModeLock()
 
     @Inputs.data_in
-    def new_data_in(self, scan):
-        if scan is None:
-            return
-        if not (settings.isOnLbsram() and utils.isLowOnMemory(
-           settings.get_lbsram_path())):
-            self._widget.setScan(scan=scan)
-        elif scan.axis_params is None:
-            scan.axis_params = QAxisRP()
-        self.process(scan=scan)
-
     def process(self, scan):
         if scan is None:
             return
         self.__scan = scan
+        self._widget.setScan(scan=self.__scan)
+
         if settings.isOnLbsram() and utils.isLowOnMemory(
                 settings.get_lbsram_path()) is True:
-            self._updatePosition(scan=scan)
             self.scan_ready(scan=scan)
         elif self.__skip_exec:
             self._n_skip += 1
-            if self.isValueLock():
+            if self.isValueLocked():
                 scan._axis_params.value = self._axis_params.value
                 cor = scan._axis_params.value
                 if isinstance(scan, HDF5TomoScan):
@@ -276,36 +262,21 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
                                                   process_index=scan.pop_process_index(),
                                                   overwrite=True)
             else:
-                processing_class = AxisProcess(axis_params=self._axis_params)
-                for patch in self._patches:
-                    mode, function = patch
-                    processing_class.RADIO_CALCULATIONS_METHODS[mode] = function
-                processing_class.process(scan=self.__scan)
-            self._updatePosition(scan=self.__scan)
-            if self.isModeLocked() or self.isValueLock():
+                AxisProcess(axis_params=self._axis_params).process(scan=self.__scan)
+            if self.isModeLocked() or self.isValueLocked():
                 self.scan_ready(scan=scan)
 
-        elif self.isModeLocked() or self.isValueLock():
+        elif self.isModeLocked() or self.isValueLocked():
             self.__lastAxisProcessParamsCache = self._axis_params.to_dict(), str(self.__scan)
-            callback = functools.partial(self._updatePosition, scan)
             self._processingStack.add(scan=scan,
                                       configuration=self._axis_params.to_dict(),
-                                      callback=callback)
+                                      callback=None)
         else:
-            callback = functools.partial(self._updatePosition, self.__scan)
-            self._processingStack.add(scan=self.__scan, callback=callback)
+            self._processingStack.add(scan=self.__scan)
             self.activateWindow()
             self.raise_()
             self.show()
 
-    def _updatePosition(self, scan):
-        if scan.axis_params is not None:
-            self._widget.setPosition(frm=None, value=scan.axis_params.value)
-        # if scan.axis_params.use_sinogram:
-        #     sinogram = scan.get_sinogram(line=scan.axis_params.sinogram_line,
-        #                                  subsampling=scan.axis_params.sinogram_subsampling)
-        #     self._widget.setSinogram(sinogram)
-
     @Inputs.data_recompute_axis
     def reprocess(self, scan):
         """Recompute the axis for scan"""
@@ -316,6 +287,3 @@ class AxisOW(widget.OWWidget, WidgetLongProcessing):
         self._processingStack.stop()
         self._processingStack.wait_computation_finished()
         super(AxisOW, self).close()
-
-    def patch_calc_method(self, mode, function):
-        self._patches.append((mode, function))

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/reconstruction/DarkRefAndCopyOW.py

@@ -125,8 +125,6 @@ class DarkRefAndCopyOW(widget.OWWidget, OWClient, WidgetLongProcessing):
 
     @Inputs.data_in
     def process(self, scanID):
-        if scanID is None:
-            return
         assert isinstance(scanID, TomwerScanBase)
         return self.widget.process(scanID)