tomwer 0.5.2__tar.gz → 0.5.2b1__tar.gz

users/payno/.local/share/virtualenvs/tomwer_venc/bin/tomwer

@@ -0,0 +1,12 @@
+#!/users/payno/.local/share/virtualenvs/tomwer_venc/bin/python
+# EASY-INSTALL-ENTRY-SCRIPT: 'tomwer==0.5.2b1','console_scripts','tomwer'
+__requires__ = 'tomwer==0.5.2b1'
+import re
+import sys
+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.2b1', 'console_scripts', 'tomwer')()
+    )

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/test/utils.py

@@ -0,0 +1,351 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2017 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", "Orange"]
+__license__ = "MIT"
+__date__ = "03/03/2017"
+
+"""
+Unit test from the Orange canvas main instance
+
+"""
+import os
+import sys
+import gc
+import re
+import logging
+import pickle
+import pkg_resources
+from AnyQt.QtGui import QFont
+from AnyQt.QtCore import Qt, QDir
+import AnyQt.importhooks
+
+if AnyQt.USED_API == "pyqt5":
+    # Use a backport shim to fake leftover PyQt4 imports
+    AnyQt.importhooks.install_backport_hook('pyqt4')
+
+from silx.gui.utils.testutils import TestCaseQt
+
+from Orange import canvas
+from tomwer.gui.qtapplicationmanager import QApplicationManager
+from Orange.canvas.application.canvasmain import CanvasMainWindow
+from Orange.canvas.application.outputview import TextStream
+from Orange.canvas.config import cache_dir
+from Orange.canvas import config
+from Orange.canvas.registry.base import WidgetRegistry
+from Orange.canvas.registry import qt
+from Orange.canvas.registry import set_global_registry
+from Orange.canvas.scheme import SchemeNode, SchemeLink
+from Orange.canvas.registry import cache
+from unittest import TestCase
+try:
+    import graypy
+except:
+    graypy = None
+else:
+    from tomwer.web import config as configweb
+log = logging.getLogger(__name__)
+
+
+class OrangeWorkflowMixIn:
+    """MixIn class for the orange workflows"""
+    @staticmethod
+    def fix_osx_10_9_private_font():
+        # Fix fonts on Os X (QTBUG 47206, 40833, 32789)
+        if sys.platform == "darwin":
+            import platform
+            try:
+                version = platform.mac_ver()[0]
+                version = float(version[:version.rfind(".")])
+                if version >= 10.11:  # El Capitan
+                    QFont.insertSubstitution(".SF NS Text", "Helvetica Neue")
+                elif version >= 10.10:  # Yosemite
+                    QFont.insertSubstitution(".Helvetica Neue DeskInterface",
+                                             "Helvetica Neue")
+                elif version >= 10.9:
+                    QFont.insertSubstitution(".Lucida Grande UI", "Lucida Grande")
+            except AttributeError:
+                pass
+
+    @staticmethod
+    def fix_win_pythonw_std_stream():
+        """
+        On windows when running without a console (using pythonw.exe) the
+        std[err|out] file descriptors are invalid and start throwing exceptions
+        when their buffer is flushed (`http://bugs.python.org/issue706263`_)
+
+        """
+        if sys.platform == "win32" and \
+                os.path.basename(sys.executable) == "pythonw.exe":
+            if sys.stdout is None:
+                sys.stdout = open(os.devnull, "w")
+            if sys.stderr is None:
+                sys.stderr = open(os.devnull, "w")
+
+    def processOrangeEvents(self):
+        self.canvas_window.current_document().scheme().signal_manager.process_queued()
+
+    def processOrangeEventsStack(self):
+        node_update_front = self.canvas_window.current_document().scheme().signal_manager.node_update_front()
+        if node_update_front:
+            self.processOrangeEvents()
+            self.processOrangeEventsStack()
+            self.app.processEvents()
+
+    def init(self):
+        self.app = QApplicationManager()
+
+        # Fix streams before configuring logging (otherwise it will store
+        # and write to the old file descriptors)
+        OrangeWorflowTest.fix_win_pythonw_std_stream()
+
+        # Try to fix fonts on OSX Mavericks
+        OrangeWorflowTest.fix_osx_10_9_private_font()
+
+        # File handler should always be at least INFO level so we need
+        # the application root level to be at least at INFO.
+
+        rootlogger = logging.getLogger(canvas.__name__)
+
+        if graypy is not None and configweb.grayport_host is not None:
+            # graypy > 1.1
+            if hasattr(graypy, 'GELFUDPHandler'):
+                cls = graypy.GELFUDPHandler
+            else:
+                cls = graypy.GELFHandler
+            self.graylogHandler = cls(configweb.grayport_host, configweb.grayport_port)
+            rootlogger.addHandler(self.graylogHandler)
+
+        # Standard output stream handler at the requested level
+        stream_hander = logging.StreamHandler()
+        rootlogger.addHandler(stream_hander)
+
+        log.info("Starting 'Orange Canvas' application.")
+        log.debug("Starting CanvasApplicaiton ")
+        # NOTE: config.init() must be called after the QApplication constructor
+        config.init()
+
+        file_handler = logging.FileHandler(
+            filename=os.path.join(config.log_dir(), "canvas.log"),
+            mode="w"
+        )
+
+        rootlogger.addHandler(file_handler)
+
+        # intercept any QFileOpenEvent requests until the main window is
+        # fully initialized.
+        # NOTE: The QApplication must have the executable ($0) and filename
+        # arguments passed in argv otherwise the FileOpen events are
+        # triggered for them (this is done by Cocoa, but QApplicaiton filters
+        # them out if passed in argv)
+
+        open_requests = []
+        def onrequest(url):
+            log.info("Received an file open request %s", url)
+            open_requests.append(url)
+
+        self.app.fileOpenRequest.connect(onrequest)
+
+        stylesheet = "orange"
+        stylesheet_string = None
+
+        if stylesheet != "none":
+            if os.path.isfile(stylesheet):
+                with open(stylesheet, "r") as f:
+                    stylesheet_string = f.read()
+            else:
+                if not os.path.splitext(stylesheet)[1]:
+                    # no extension
+                    stylesheet = os.path.extsep.join([stylesheet, "qss"])
+
+                pkg_name = canvas.__name__
+                resource = "styles/" + stylesheet
+
+                if pkg_resources.resource_exists(pkg_name, resource):
+                    stylesheet_string = \
+                        pkg_resources.resource_string(pkg_name, resource).decode()
+
+                    base = pkg_resources.resource_filename(pkg_name, "styles")
+
+                    pattern = re.compile(
+                        r"^\s@([a-zA-Z0-9_]+?)\s*:\s*([a-zA-Z0-9_/]+?);\s*$",
+                        flags=re.MULTILINE
+                    )
+
+                    matches = pattern.findall(stylesheet_string)
+
+                    for prefix, search_path in matches:
+                        QDir.addSearchPath(prefix, os.path.join(base, search_path))
+                        log.info("Adding search path %r for prefix, %r",
+                                 search_path, prefix)
+
+                    stylesheet_string = pattern.sub("", stylesheet_string)
+
+                else:
+                    log.info("%r style sheet not found.", stylesheet)
+
+        # Add the default canvas_icons search path
+        dirpath = os.path.abspath(os.path.dirname(canvas.__file__))
+        QDir.addSearchPath("canvas_icons", os.path.join(dirpath, "icons"))
+        self.canvas_window = CanvasMainWindow()
+        self.canvas_window.setWindowIcon(config.application_icon())
+
+        if stylesheet_string is not None:
+            self.canvas_window.setStyleSheet(stylesheet_string)
+
+        reg_cache = None
+        widget_discovery = qt.QtWidgetDiscovery(cached_descriptions=reg_cache)
+
+        self.widget_registry = qt.QtWidgetRegistry()
+
+        widget_discovery.found_category.connect(
+            self.widget_registry.register_category
+        )
+        widget_discovery.found_widget.connect(
+            self.widget_registry.register_widget
+        )
+
+        cache_filename = os.path.join(cache_dir(), "widget-registry.pck")
+        try:
+            widget_discovery.run(config.widgets_entry_points(False))
+        except:
+            widget_discovery.run(config.widgets_entry_points())
+        # Store cached descriptions
+        cache.save_registry_cache(widget_discovery.cached_descriptions)
+        with open(cache_filename, "wb") as f:
+            pickle.dump(WidgetRegistry(self.widget_registry), f)
+
+        set_global_registry(self.widget_registry)
+        self.canvas_window.set_widget_registry(self.widget_registry)
+        self.canvas_window.show()
+
+        # Process events to make sure the self.canvas_window layout has
+        # a chance to activate (the welcome dialog is modal and will
+        # block the event queue, plus we need a chance to receive open file
+        # signals when running without a splash screen)
+        self.app.processEvents()
+        log.info("discovery ended")
+        # Tee stdout and stderr into Output dock
+        log_view = self.canvas_window.log_view()
+
+        stdout = TextStream()
+        stdout.stream.connect(log_view.write)
+        if sys.stdout:
+            stdout.stream.connect(sys.stdout.write)
+            stdout.flushed.connect(sys.stdout.flush)
+        stderr = TextStream()
+        error_writer = log_view.formated(color=Qt.red)
+        stderr.stream.connect(error_writer.write)
+        if sys.stderr:
+            stderr.stream.connect(sys.stderr.write)
+            stderr.flushed.connect(sys.stderr.flush)
+
+        log.info("End initialization")
+
+    def addWidget(self, widgetID):
+        """Create an instanciation of the widgetID
+
+        :return SchemeNode: the node created
+        """
+        assert(type(widgetID) is str)
+        assert(self.widget_registry.has_widget(widgetID))
+        widget_desc = self.widget_registry.widget(widgetID)
+        myItem = SchemeNode(widget_desc)
+        self.canvas_window.current_document().scheme().add_node(myItem)
+        return myItem
+
+    def removeNode(self, widget):
+        self.canvas_window.current_document().scheme().remove_node(widget)
+
+    def link(self, schemeNode1, outNode1, schemeNode2, inputNode2):
+        """Create a link between the node on the given input and output
+
+        :param SchemeNode schemeNode1: the node emitting the output signal
+        :param outNode1: the output chanel to be linked
+        :param SchemeNode schemeNode2: the node receiving the input signal
+        :param inputNode2: the input chanel to be linked
+        :return: the link created between the two nodes
+        """
+        assert(type(schemeNode1) is SchemeNode)
+        assert(type(schemeNode2) is SchemeNode)
+        assert(type(outNode1) is str)
+        assert(type(inputNode2) is str)
+        link = SchemeLink(schemeNode1, outNode1, schemeNode2, inputNode2)
+        self.canvas_window.current_document().scheme().add_link(link)
+        return link
+
+    def getWidgetForNode(self, node):
+        """
+
+        :param SchemeNode node: the node for which we want the corresponding
+            widget
+        :return: the widget instanciated for the given node
+        """
+        assert(type(node) is SchemeNode)
+        return self.canvas_window.current_document().scheme().widget_for_node(node)
+
+    def tearDown(self):
+        signal_manager = self.canvas_window.current_document().scheme().signal_manager
+        self.canvas_window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.canvas_window.closeEvent = self.closeEventMonkeyPatch
+        self.canvas_window.close()
+        self.app.removePostedEvents(signal_manager)
+        del self.canvas_window
+        gc.collect()
+        self.app.quit()
+
+    @classmethod
+    def closeEventMonkeyPatch(cls, event):
+        """monkey patch clsoe event to skip modification saving request..."""
+        event.ignore()
+
+
+class OrangeWorflowTest(OrangeWorkflowMixIn, TestCaseQt):
+    """Define a specific TestCase reltive to OrangeWorkflow"""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.init(cls)
+        super(OrangeWorflowTest, cls).setUpClass()
+
+        TestCaseQt.setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.app.processEvents()
+        # make sure no events are resting
+        super(OrangeWorflowTest, cls).tearDown(cls)
+        TestCaseQt.tearDownClass()
+
+    def tearDown(self):
+        import time
+        while(self.app.hasPendingEvents()):
+            time.sleep(0.1)
+            self.app.processEvents()
+            self.processOrangeEventsStack()
+            time.sleep(0.1)
+            self.app.processEvents()
+
+        TestCase.tearDown(self)

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

@@ -0,0 +1,72 @@
+# 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.
+#
+#############################################################################
+
+import pkg_resources
+import sysconfig
+
+
+ICON = "../widgets/icons/tomwer.png"
+
+BACKGROUND = "#C0CCFF"
+
+# Entry point for main Orange categories/widgets discovery
+def widget_discovery(discovery):
+    dist = pkg_resources.get_distribution("tomwer")
+    pkgs = [
+        "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)
+
+
+WIDGET_HELP_PATH = (
+    # Used for development.
+    # You still need to build help pages using
+    # make htmlhelp
+    # inside doc folder
+    ("{}/build/sphinx/htmlhelp/index.html", None),
+    #
+    # Documentation included in wheel
+    # Correct DATA_FILES entry is needed in setup.py and documentation has to be built
+    # # 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/", ""),
+)
+
+
+import unittest
+
+
+def suite():
+
+    test_suite = unittest.TestSuite()
+
+    from .test import suite as widgets_suite
+
+    test_suite.addTest(widgets_suite())
+    return test_suite

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/DataListOW.py

@@ -0,0 +1,131 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2017 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__ = ["C. Nemoz", "H. Payno"]
+__license__ = "MIT"
+__date__ = "01/12/2016"
+
+from Orange.widgets import widget, gui
+from silx.gui import qt
+from tomwer.core.utils import logconfig
+from tomwer.gui.control.datalist import GenericDataListDialog
+from tomwer.core.process.scanlist import _ScanList
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.web.client import OWClient
+from tomwer.core.scan.scanbase import TomwerScanBase
+from Orange.widgets.settings import Setting
+from Orange.widgets.widget import Output, Input
+import logging
+logger = logging.getLogger(__name__)
+
+
+class DataListOW(widget.OWWidget, OWClient):
+    name = "data list"
+    id = "orange.widgets.tomwer.scanlist"
+    description = "List path to reconstructions/scans. Those path will be send to the next box once validated."
+    icon = "icons/scanlist.svg"
+    priority = 50
+    category = "esrfWidgets"
+    keywords = ["tomography", "file", "tomwer", 'folder']
+
+    want_main_area = True
+    resizing_enabled = True
+    compress_signal = False
+
+    _scanIDs = Setting(list())
+
+    assert len(_ScanList.outputs) == 1
+    class Outputs:
+        data_out = Output(name=_ScanList.outputs[0].name,
+                          type=_ScanList.outputs[0].type,
+                          doc=_ScanList.outputs[0].doc)
+
+    class Inputs:
+        data_in = Input(name='data', type=TomwerScanBase)
+
+    def __init__(self, parent=None):
+        """A simple annuary which register all folder containing completed scan
+
+        .. warning: the widget won't check for scan validity and will only
+            emit the path to folders to the next widgets
+
+        :param parent: the parent widget
+        """
+        widget.OWWidget.__init__(self, parent)
+        OWClient.__init__(self, logger)
+        self.widget = GenericDataListDialog(parent=self)
+        self.widget.setScanIDs(self._scanIDs)
+        layout = gui.vBox(self.mainArea, self.name).layout()
+        layout.addWidget(self.widget)
+        self.widget._sendButton.clicked.connect(self._sendList)
+
+        # expose API
+        self.size = self.widget.size
+
+        # alias used for the 'simple workflow' for now
+        self.start = self._sendList
+        self.clear = self.widget.clear
+
+    def _sendList(self):
+        """Send a signal for each list to the next widget"""
+        def send(scan_):
+            mess = "sending one scan %s" % d
+            logger.debug(mess,
+                         extra={logconfig.DOC_TITLE: self.widget._scheme_title,
+                                logconfig.SCAN_ID: str(scan_)})
+            self.Outputs.data_out.send(scan_)
+
+        for d in self.widget.datalist.items:
+            if '@' in d:
+                entry, scan_file_or_dir = d.split('@')
+            else:
+                entry = None,
+                scan_file_or_dir = d
+            try:
+                scan = ScanFactory.create_scan_object(scan_file_or_dir,
+                                                      entry=entry)
+            except Exception as e:
+                logger.error("Fail to create an instance of TomoBase from %s." \
+                             " Reason is %s" % (d, str(e)))
+            else:
+                send(scan_=scan)
+
+    @Inputs.data_in
+    def add(self, scan):
+        if scan is None:
+            return
+
+        self.widget.add(scan)
+
+
+def main():
+    app = qt.QApplication([])
+    s = DataListOW()
+    s.show()
+    app.exec_()
+
+
+if __name__ == "__main__":
+    main()