Changeset d744767 in sasview


Ignore:
Timestamp:
Mar 16, 2018 2:05:42 PM (7 years ago)
Author:
krzywon
Branches:
ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
47bf906
Parents:
477c473 (diff), e4c475b7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'ESS_GUI' into ESS_GUI_Pr

Files:
32 added
197 edited

Legend:

Unmodified
Added
Removed

  • docs/sphinx-docs/build_sphinx.py

    rdf72475 re90988c  
    220220    print("=== Build HTML Docs from ReST Files ===") 
    221221    subprocess.call(["sphinx-build", 
    222                      "-b", "html", # Builder name. TODO: accept as arg to setup.py. 
     222                     "-b", "qthelp", # Builder name. TODO: accept as arg to setup.py. 
    223223                     "-d", joinpath(SPHINX_BUILD, "doctrees"), 
    224224                     SPHINX_SOURCE, 

  • installers/installer_generator.py

    • Property mode changed from 100644 to 100755

  • run.py

    r856cf59 rd744767  
    118118    # Import the sasview package from root/sasview as sas.sasview.  It would 
    119119    # be better to just store the package in src/sas/sasview. 
    120     import sas 
    121     #sas.sasview = import_package('sas.sasview', joinpath(root, 'sasview')) 
    122     sas.sasview = import_package('sas.sasview', joinpath(root, 'src','sas','sasview')) 
     120    #import sas 
     121    #sas.sasview = import_package('sas.sasview', joinpath(root, 'src','sas','sasview')) 
    123122 
    124123    # Compiled modules need to be pulled from the build directory. 
    … …  
    138137    import sas.sascalc.calculator 
    139138    sas.sascalc.calculator.core = import_package('sas.sascalc.calculator.core', 
    140                                                  joinpath(build_path, 'sas', 'sascalc', 'calculator', 'core')) 
     139                                  joinpath(build_path, 'sas', 'sascalc', 'calculator', 'core')) 
    141140 
    142141    sys.path.append(build_path) 

  • setup.py

    rf4a1433 r14ec91c5  
    5353    if os.path.isfile(f_path): 
    5454        os.remove(f_path) 
    55     f_path = os.path.join(sas_dir, "categories.json") 
    56     if os.path.isfile(f_path): 
    57         os.remove(f_path) 
     55    #f_path = os.path.join(sas_dir, "categories.json") 
     56    #if os.path.isfile(f_path): 
     57    #    os.remove(f_path) 
    5858    f_path = os.path.join(sas_dir, 'config', "custom_config.py") 
    5959    if os.path.isfile(f_path): 
    … …  
    380380    "src", "sas", "qtgui", "Perspectives", "Fitting", "UI") 
    381381packages.extend(["sas.qtgui.Perspectives.Fitting", "sas.qtgui.Perspectives.Fitting.UI"]) 
     382 
     383package_dir["sas.qtgui.Perspectives.Inversion"] = os.path.join( 
     384    "src", "sas", "qtgui", "Perspectives", "Inversion") 
     385package_dir["sas.qtgui.Perspectives.Inversion.UI"] = os.path.join( 
     386    "src", "sas", "qtgui", "Perspectives", "Inversion", "UI") 
     387packages.extend(["sas.qtgui.Perspectives.Inversion", "sas.qtgui.Perspectives.Inversion.UI"]) 
     388 
     389package_dir["sas.qtgui.Perspectives.Corfunc"] = os.path.join( 
     390    "src", "sas", "qtgui", "Perspectives", "Corfunc") 
     391package_dir["sas.qtgui.Perspectives.Corfunc.UI"] = os.path.join( 
     392    "src", "sas", "qtgui", "Perspectives", "Corfunc", "UI") 
     393packages.extend(["sas.qtgui.Perspectives.Corfunc", "sas.qtgui.Perspectives.Corfunc.UI"]) 
    382394 
    383395## Plotting 
    … …  
    451463 
    452464required = [ 
    453     'bumps>=0.7.5.9', 'periodictable>=1.5.0', 'pyparsing<2.0.0', 
    454  
    455     # 'lxml>=2.2.2', 
     465    'bumps>=0.7.5.9', 'periodictable>=1.5.0', 
    456466    'lxml', 'h5py', 
    457467 

  • src/sas/logger_config.py

    rf4a1433 rcee5c78  
    4949        ''' 
    5050        for handler in logger.handlers or logger.parent.handlers: 
    51             handler.setLevel(logging.DEBUG) 
     51            #handler.setLevel(logging.DEBUG) 
     52            handler.setLevel(logging.WARNING) 
    5253        for name, _ in logging.Logger.manager.loggerDict.items(): 
    53             logging.getLogger(name).setLevel(logging.DEBUG) 
     54            #logging.getLogger(name).setLevel(logging.DEBUG) 
     55            logging.getLogger(name).setLevel(logging.WARNING) 
    5456 
    5557    def _find_config_file(self, filename="logging.ini"): 

  • src/sas/qtgui/Calculators/DataOperationUtilityPanel.py

    r7d9c83c re90988c  
    44import copy 
    55 
    6 from PyQt4 import QtGui 
    7 from PyQt4 import QtCore 
     6from PyQt5 import QtCore 
     7from PyQt5 import QtGui 
     8from PyQt5 import QtWidgets 
    89 
    910from sas.qtgui.Plotting.PlotterData import Data1D 
    … …  
    1314import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    1415 
    15 from UI.DataOperationUtilityUI import Ui_DataOperationUtility 
     16from .UI.DataOperationUtilityUI import Ui_DataOperationUtility 
    1617 
    1718BG_WHITE = "background-color: rgb(255, 255, 255);" 
    … …  
    1920 
    2021 
    21 class DataOperationUtilityPanel(QtGui.QDialog, Ui_DataOperationUtility): 
     22class DataOperationUtilityPanel(QtWidgets.QDialog, Ui_DataOperationUtility): 
    2223    def __init__(self, parent=None): 
    2324        super(DataOperationUtilityPanel, self).__init__() 
    … …  
    5556 
    5657        # validator for coefficient 
    57         self.txtNumber.setValidator(QtGui.QDoubleValidator()) 
    58  
    59         self.layoutOutput = QtGui.QHBoxLayout() 
    60         self.layoutData1 = QtGui.QHBoxLayout() 
    61         self.layoutData2 = QtGui.QHBoxLayout() 
     58        self.txtNumber.setValidator(GuiUtils.DoubleValidator()) 
     59 
     60        self.layoutOutput = QtWidgets.QHBoxLayout() 
     61        self.layoutData1 = QtWidgets.QHBoxLayout() 
     62        self.layoutData2 = QtWidgets.QHBoxLayout() 
    6263 
    6364        # Create default layout for initial graphs (when they are still empty) 
    … …  
    7677        self.filenames = filenames 
    7778 
    78         if filenames.keys(): 
     79        if list(filenames.keys()): 
    7980            # clear contents of comboboxes 
    8081            self.cbData1.clear() 
    … …  
    8586            list_datafiles = [] 
    8687 
    87             for key_id in filenames.keys(): 
     88            for key_id in list(filenames.keys()): 
    8889                if filenames[key_id].get_data().title: 
    8990                    # filenames with titles 
    … …  
    109110        documentation tree (after /doc/ ....". 
    110111        """ 
    111         try: 
    112             location = GuiUtils.HELP_DIRECTORY_LOCATION + \ 
    113                        "/user/sasgui/perspectives/calculator/data_operator_help.html" 
    114             self.manager._helpView.load(QtCore.QUrl(location)) 
    115             self.manager._helpView.show() 
    116  
    117         except AttributeError: 
    118             # No manager defined - testing and standalone runs 
    119             pass 
     112        location = "/user/sasgui/perspectives/calculator/data_operator_help.html" 
     113        self.manager.showHelp(location) 
    120114 
    121115    def onClose(self): 
    … …  
    139133            data1 = self.data1 
    140134            data2 = self.data2 
    141             exec "output = data1 %s data2" % operator 
    142         except: 
    143             raise 
     135            output = eval("data1 %s data2" % operator) 
     136        except Exception as ex: 
     137            logging.error(ex) 
     138            return 
    144139 
    145140        self.output = output 
    … …  
    158153        """ Prepare datasets to be added to DataExplorer and DataManager """ 
    159154        new_item = GuiUtils.createModelItemWithPlot( 
    160             QtCore.QVariant(self.output), 
     155            self.output, 
    161156            name=self.txtOutputData.text()) 
    162157 
    … …  
    273268                msg = 'DataOperation: Number requires a float number' 
    274269                logging.warning(msg) 
    275                 self.txtNumber.setStyleSheet(QtCore.QString(BG_RED)) 
     270                self.txtNumber.setStyleSheet(BG_RED) 
    276271 
    277272            elif float(self.txtNumber.text()) == 0.: 
    … …  
    279274                msg = 'DataOperation: Number requires a non zero number' 
    280275                logging.warning(msg) 
    281                 self.txtNumber.setStyleSheet(QtCore.QString(BG_RED)) 
     276                self.txtNumber.setStyleSheet(BG_RED) 
    282277 
    283278            else: 
    284                 self.txtNumber.setStyleSheet(QtCore.QString(BG_WHITE)) 
     279                self.txtNumber.setStyleSheet(BG_WHITE) 
    285280                self.data2 = float(self.txtNumber.text()) 
    286281                self.updatePlot(self.graphData2, self.layoutData2, self.data2) 
    … …  
    293288        else: 
    294289            if self.cbData2.currentText() == 'Number': 
    295                 self.cbData1.setStyleSheet(QtCore.QString(BG_WHITE)) 
    296                 self.cbData2.setStyleSheet(QtCore.QString(BG_WHITE)) 
     290                self.cbData1.setStyleSheet(BG_WHITE) 
     291                self.cbData2.setStyleSheet(BG_WHITE) 
    297292                return True 
    298293 
    299294            elif self.data1.__class__.__name__ != self.data2.__class__.__name__: 
    300                 self.cbData1.setStyleSheet(QtCore.QString(BG_RED)) 
    301                 self.cbData2.setStyleSheet(QtCore.QString(BG_RED)) 
    302                 print self.data1.__class__.__name__ != self.data2.__class__.__name__ 
     295                self.cbData1.setStyleSheet(BG_RED) 
     296                self.cbData2.setStyleSheet(BG_RED) 
     297                print(self.data1.__class__.__name__ != self.data2.__class__.__name__) 
    303298                logging.warning('Cannot compute data of different dimensions') 
    304299                return False 
    … …  
    308303                             not all(i == j for i, j in zip(self.data1.x, self.data2.x))): 
    309304                logging.warning('Cannot compute 1D data of different lengths') 
    310                 self.cbData1.setStyleSheet(QtCore.QString(BG_RED)) 
    311                 self.cbData2.setStyleSheet(QtCore.QString(BG_RED)) 
     305                self.cbData1.setStyleSheet(BG_RED) 
     306                self.cbData2.setStyleSheet(BG_RED) 
    312307                return False 
    313308 
    … …  
    320315                                zip(self.data1.qy_data, self.data2.qy_data)) 
    321316                         ): 
    322                 self.cbData1.setStyleSheet(QtCore.QString(BG_RED)) 
    323                 self.cbData2.setStyleSheet(QtCore.QString(BG_RED)) 
     317                self.cbData1.setStyleSheet(BG_RED) 
     318                self.cbData2.setStyleSheet(BG_RED) 
    324319                logging.warning('Cannot compute 2D data of different lengths') 
    325320                return False 
    326321 
    327322            else: 
    328                 self.cbData1.setStyleSheet(QtCore.QString(BG_WHITE)) 
    329                 self.cbData2.setStyleSheet(QtCore.QString(BG_WHITE)) 
     323                self.cbData1.setStyleSheet(BG_WHITE) 
     324                self.cbData2.setStyleSheet(BG_WHITE) 
    330325                return True 
    331326 
    … …  
    333328        """ Check that name of output does not already exist """ 
    334329        name_to_check = str(self.txtOutputData.text()) 
    335         self.txtOutputData.setStyleSheet(QtCore.QString(BG_WHITE)) 
     330        self.txtOutputData.setStyleSheet(BG_WHITE) 
    336331 
    337332        if name_to_check is None or name_to_check == '': 
    338             self.txtOutputData.setStyleSheet(QtCore.QString(BG_RED)) 
     333            self.txtOutputData.setStyleSheet(BG_RED) 
    339334            logging.warning('No output name') 
    340335            return False 
    341336 
    342337        elif name_to_check in self.list_data_items: 
    343             self.txtOutputData.setStyleSheet(QtCore.QString(BG_RED)) 
     338            self.txtOutputData.setStyleSheet(BG_RED) 
    344339            logging.warning('The Output data name already exists') 
    345340            return False 
    346341 
    347342        else: 
    348             self.txtOutputData.setStyleSheet(QtCore.QString(BG_WHITE)) 
     343            self.txtOutputData.setStyleSheet(BG_WHITE) 
    349344            return True 
    350345 
    … …  
    354349    def _findId(self, name): 
    355350        """ find id of name in list of filenames """ 
    356         isinstance(name, basestring) 
    357  
    358         for key_id in self.filenames.keys(): 
     351        isinstance(name, str) 
     352 
     353        for key_id in list(self.filenames.keys()): 
    359354            # data with title 
    360355            if self.filenames[key_id].get_data().title: 
    … …  
    383378    def newPlot(self, graph, layout): 
    384379        """ Create template for graphs with default '?' layout""" 
    385         assert isinstance(graph, QtGui.QGraphicsView) 
    386         assert isinstance(layout, QtGui.QHBoxLayout) 
     380        assert isinstance(graph, QtWidgets.QGraphicsView) 
     381        assert isinstance(layout, QtWidgets.QHBoxLayout) 
    387382 
    388383        # clear layout 
    … …  
    399394        """ plot data in graph after clearing its layout """ 
    400395 
    401         assert isinstance(graph, QtGui.QGraphicsView) 
    402         assert isinstance(layout, QtGui.QHBoxLayout) 
     396        assert isinstance(graph, QtWidgets.QGraphicsView) 
     397        assert isinstance(layout, QtWidgets.QHBoxLayout) 
    403398 
    404399        # clear layout 
    … …  
    455450    def prepareSubgraphWithData(self, data): 
    456451        """ Create graphics view containing scene with string """ 
    457         scene = QtGui.QGraphicsScene() 
     452        scene = QtWidgets.QGraphicsScene() 
    458453        scene.addText(str(data)) 
    459454 
    460         subgraph = QtGui.QGraphicsView() 
     455        subgraph = QtWidgets.QGraphicsView() 
    461456        subgraph.setScene(scene) 
    462457 

  • src/sas/qtgui/Calculators/DensityPanel.py

    rb0c5e8c re90988c  
    22import logging 
    33import functools 
    4 from PyQt4 import QtGui, QtCore 
     4from PyQt5 import QtCore 
     5from PyQt5 import QtGui 
     6from PyQt5 import QtWidgets 
    57 
    68from periodictable import formula as Formula 
    … …  
    1315from sas.qtgui.Calculators.UI.DensityPanel import Ui_DensityPanel 
    1416 
    15 def enum(*sequential, **named): 
    16     enums = dict(zip(sequential, range(len(sequential))), **named) 
    17     return type('Enum', (), enums) 
     17from sas.qtgui.Utilities.GuiUtils import enum 
    1818 
    1919MODEL = enum( 
    … …  
    3939 
    4040 
    41 class DensityPanel(QtGui.QDialog): 
     41class DensityPanel(QtWidgets.QDialog): 
    4242 
    4343    def __init__(self, parent=None): 
    … …  
    5858 
    5959        # set validators 
    60         self.ui.editMolecularFormula.setValidator(FormulaValidator(self.ui.editMolecularFormula)) 
     60        #self.ui.editMolecularFormula.setValidator(FormulaValidator(self.ui.editMolecularFormula)) 
    6161 
    6262        rx = QtCore.QRegExp("[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?") 
    … …  
    6868        self.ui.editMassDensity.textEdited.connect(functools.partial(self.setMode, MODES.DENSITY_TO_VOLUME)) 
    6969 
    70         self.ui.buttonBox.button(QtGui.QDialogButtonBox.Reset).clicked.connect(self.modelReset) 
    71         self.ui.buttonBox.button(QtGui.QDialogButtonBox.Help).clicked.connect(self.displayHelp) 
     70        self.ui.buttonBox.button(QtWidgets.QDialogButtonBox.Reset).clicked.connect(self.modelReset) 
     71        self.ui.buttonBox.button(QtWidgets.QDialogButtonBox.Help).clicked.connect(self.displayHelp) 
    7272 
    7373    def setupModel(self): 
    … …  
    8383 
    8484    def setupMapper(self): 
    85         self.mapper = QtGui.QDataWidgetMapper(self) 
     85        self.mapper = QtWidgets.QDataWidgetMapper(self) 
    8686        self.mapper.setModel(self.model) 
    8787        self.mapper.setOrientation(QtCore.Qt.Vertical) 
    … …  
    9595 
    9696    def dataChanged(self, top, bottom): 
    97         for index in xrange(top.row(), bottom.row() + 1): 
     97        for index in range(top.row(), bottom.row() + 1): 
    9898            if index == MODEL.MOLECULAR_FORMULA: 
    9999                molarMass = toMolarMass(self.model.item(MODEL.MOLECULAR_FORMULA).text()) 
    … …  
    137137 
    138138    def modelReset(self): 
    139         #self.model.beginResetModel() 
    140139        try: 
    141140            self.setMode(None) 
    … …  
    145144        finally: 
    146145            pass 
    147             #self.model.endResetModel() 
    148146 
    149147    def displayHelp(self): 
    150         try: 
    151             location = HELP_DIRECTORY_LOCATION + \ 
    152                 "/user/sasgui/perspectives/calculator/density_calculator_help.html" 
     148        location =  "/user/sasgui/perspectives/calculator/density_calculator_help.html" 
     149        self.manager.showHelp(location) 
    153150 
    154             self.manager._helpView.load(QtCore.QUrl(location)) 
    155             self.manager._helpView.show() 
    156         except AttributeError: 
    157             # No manager defined - testing and standalone runs 
    158             pass 
     151 

  • src/sas/qtgui/Calculators/GenericScatteringCalculator.py

    rfef38e8 re90988c  
    55import time 
    66 
    7 from PyQt4 import QtGui 
    8 from PyQt4 import QtCore 
     7from PyQt5 import QtCore 
     8from PyQt5 import QtGui 
     9from PyQt5 import QtWidgets 
     10 
    911from twisted.internet import threads 
    1012 
    … …  
    2224 
    2325# Local UI 
    24 from UI.GenericScatteringCalculator import Ui_GenericScatteringCalculator 
     26from .UI.GenericScatteringCalculator import Ui_GenericScatteringCalculator 
    2527 
    2628_Q1D_MIN = 0.001 
    2729 
    2830 
    29 class GenericScatteringCalculator(QtGui.QDialog, Ui_GenericScatteringCalculator): 
     31class GenericScatteringCalculator(QtWidgets.QDialog, Ui_GenericScatteringCalculator): 
    3032 
    3133    trigger_plot_3d = QtCore.pyqtSignal() 
    … …  
    119121        TODO Temporary solution to display information about option 'Ellipsoid' 
    120122        """ 
    121         print "The option Ellipsoid has not been implemented yet." 
     123        print("The option Ellipsoid has not been implemented yet.") 
    122124        self.communicator.statusBarUpdateSignal.emit( 
    123125            "The option Ellipsoid has not been implemented yet.") 
    … …  
    129131        """ 
    130132        try: 
    131             self.datafile = QtGui.QFileDialog.getOpenFileName( 
     133            self.datafile = QtWidgets.QFileDialog.getOpenFileName( 
    132134                self, "Choose a file", "", "All Gen files (*.OMF *.omf) ;;" 
    133135                                          "SLD files (*.SLD *.sld);;PDB files (*.pdb *.PDB);; " 
    134136                                          "OMF files (*.OMF *.omf);; " 
    135                                           "All files (*.*)") 
     137                                          "All files (*.*)")[0] 
    136138            if self.datafile: 
    137139                self.default_shape = str(self.cbShape.currentText()) 
    … …  
    165167                self.reader.queue() 
    166168        except (RuntimeError, IOError): 
    167             log_msg = "Generic SAS Calculator: %s" % sys.exc_value 
     169            log_msg = "Generic SAS Calculator: %s" % sys.exc_info()[1] 
    168170            logging.info(log_msg) 
    169171            raise 
    … …  
    235237        """Check range of text edits for QMax and Number of Qbins """ 
    236238        text_edit = self.sender() 
    237         text_edit.setStyleSheet( 
    238             QtCore.QString.fromUtf8('background-color: rgb(255, 255, 255);')) 
     239        text_edit.setStyleSheet('background-color: rgb(255, 255, 255);') 
    239240        if text_edit.text(): 
    240241            value = float(str(text_edit.text())) 
    241242            if text_edit == self.txtQxMax: 
    242243                if value <= 0 or value > 1000: 
    243                     text_edit.setStyleSheet(QtCore.QString.fromUtf8( 
    244                         'background-color: rgb(255, 182, 193);')) 
     244                    text_edit.setStyleSheet('background-color: rgb(255, 182, 193);') 
    245245                else: 
    246                     text_edit.setStyleSheet(QtCore.QString.fromUtf8( 
    247                         'background-color: rgb(255, 255, 255);')) 
     246                    text_edit.setStyleSheet('background-color: rgb(255, 255, 255);') 
    248247            elif text_edit == self.txtNoQBins: 
    249248                if value < 2 or value > 1000: 
    250                     self.txtNoQBins.setStyleSheet(QtCore.QString.fromUtf8( 
    251                         'background-color: rgb(255, 182, 193);')) 
     249                    self.txtNoQBins.setStyleSheet('background-color: rgb(255, 182, 193);') 
    252250                else: 
    253                     self.txtNoQBins.setStyleSheet(QtCore.QString.fromUtf8( 
    254                         'background-color: rgb(255, 255, 255);')) 
     251                    self.txtNoQBins.setStyleSheet('background-color: rgb(255, 255, 255);') 
    255252 
    256253    def update_gui(self): 
    … …  
    385382        documentation tree (after /doc/ ....". 
    386383        """ 
    387         try: 
    388             location = GuiUtils.HELP_DIRECTORY_LOCATION + \ 
    389                        "/user/sasgui/perspectives/calculator/sas_calculator_help.html" 
    390             self.manager._helpView.load(QtCore.QUrl(location)) 
    391             self.manager._helpView.show() 
    392         except AttributeError: 
    393             # No manager defined - testing and standalone runs 
    394             pass 
     384        location = "/user/sasgui/perspectives/calculator/sas_calculator_help.html" 
     385        self.manager.showHelp(location) 
    395386 
    396387    def onReset(self): 
    … …  
    555546            # Add deferred callback for call return 
    556547            d.addCallback(self.plot_1_2d) 
     548            d.addErrback(self.calculateFailed) 
    557549        except: 
    558             log_msg = "{}. stop".format(sys.exc_value) 
     550            log_msg = "{}. stop".format(sys.exc_info()[1]) 
    559551            logging.info(log_msg) 
    560552        return 
    … …  
    564556        Copied from previous version 
    565557        """ 
     558        pass 
     559 
     560    def calculateFailed(self, reason): 
     561        """ 
     562        """ 
     563        print("Calculate Failed with:\n", reason) 
    566564        pass 
    567565 
    … …  
    605603            'directory': default_name, 
    606604            'filter': 'SLD file (*.sld)', 
    607             'options': QtGui.QFileDialog.DontUseNativeDialog} 
     605            'options': QtWidgets.QFileDialog.DontUseNativeDialog} 
    608606        # Query user for filename. 
    609         filename = str(QtGui.QFileDialog.getSaveFileName(**kwargs)) 
     607        filename_tuple = QtWidgets.QFileDialog.getSaveFileName(**kwargs) 
     608        filename = filename_tuple[0] 
    610609        if filename: 
    611610            try: 
    612                 if os.path.splitext(filename)[1].lower() == '.sld': 
    613                     sas_gen.SLDReader().write(filename, self.sld_data) 
    614                 else: 
    615                     sas_gen.SLDReader().write('.'.join((filename, 'sld')), 
    616                                               self.sld_data) 
     611                _, extension = os.path.splitext(filename) 
     612                if not extension: 
     613                    filename = '.'.join((filename, 'sld')) 
     614                sas_gen.SLDReader().write(filename, self.sld_data) 
    617615            except: 
    618616                raise 
    … …  
    644642            self.graph_num += 1 
    645643            # TODO 
    646             print 'TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED' 
     644            print('TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED') 
    647645            return plot1D 
    648646        else: 
    … …  
    662660            self.graph_num += 1 
    663661            # TODO 
    664             print 'TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED' 
     662            print('TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED') 
    665663            return plot2D 
    666664 
    … …  
    744742        # II. Plot selective points in color 
    745743        other_color = numpy.ones(len(pix_symbol), dtype='bool') 
    746         for key in color_dic.keys(): 
     744        for key in list(color_dic.keys()): 
    747745            chosen_color = pix_symbol == key 
    748746            if numpy.any(chosen_color): 
    … …  
    758756                # Get atom names not in the list 
    759757                a_names = [symb for symb in pix_symbol \ 
    760                            if symb not in color_dic.keys()] 
     758                           if symb not in list(color_dic.keys())] 
    761759                a_name = a_names[0] 
    762760                for name in a_names: 
    … …  
    828826 
    829827 
    830 class Plotter3D(QtGui.QDialog, Plotter3DWidget): 
     828class Plotter3D(QtWidgets.QDialog, Plotter3DWidget): 
    831829    def __init__(self, parent=None, graph_title=''): 
    832830        self.graph_title = graph_title 
    833         QtGui.QDialog.__init__(self) 
     831        QtWidgets.QDialog.__init__(self) 
    834832        Plotter3DWidget.__init__(self, manager=parent) 
    835833        self.setWindowTitle(self.graph_title) 

  • src/sas/qtgui/Calculators/KiessigPanel.py

    rb0c5e8c re90988c  
    1 from PyQt4 import QtGui 
    2 from PyQt4 import QtCore 
     1from PyQt5 import QtCore 
     2from PyQt5 import QtGui 
     3from PyQt5 import QtWidgets 
    34 
    45from sas.qtgui.UI import main_resources_rc 
    5 from UI.KiessigPanel import Ui_KiessigPanel 
     6from .UI.KiessigPanel import Ui_KiessigPanel 
    67import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    78 
    … …  
    1011 
    1112 
    12 class KiessigPanel(QtGui.QDialog, Ui_KiessigPanel): 
     13class KiessigPanel(QtWidgets.QDialog, Ui_KiessigPanel): 
    1314    def __init__(self, parent=None): 
    1415        super(KiessigPanel, self).__init__() 
    … …  
    3738        documentation tree (after /doc/ ....". 
    3839        """ 
    39         try: 
    40             location = GuiUtils.HELP_DIRECTORY_LOCATION + \ 
    41                 "/user/sasgui/perspectives/calculator/kiessig_calculator_help.html" 
    42  
    43             self.manager._helpView.load(QtCore.QUrl(location)) 
    44             self.manager._helpView.show() 
    45         except AttributeError: 
    46             # No manager defined - testing and standalone runs 
    47             pass 
     40        location = "/user/sasgui/perspectives/calculator/kiessig_calculator_help.html" 
     41        self.manager.showHelp(location) 
    4842 
    4943    def onCompute(self): 
    … …  
    5448            self.thickness.set_deltaq(dq=float(self.deltaq_in.text())) 
    5549            kiessing_result = self.thickness.compute_thickness() 
    56             float_as_str = "{:.3f}".format(kiessing_result) 
    57             self.lengthscale_out.setText(float_as_str) 
     50            if kiessing_result: 
     51                float_as_str = "{:.3f}".format(kiessing_result) 
     52                self.lengthscale_out.setText(float_as_str) 
     53            else: 
     54                # error or division by zero 
     55                self.lengthscale_out.setText("") 
     56 
    5857        except (ArithmeticError, ValueError): 
    5958            self.lengthscale_out.setText("") 

  • src/sas/qtgui/Calculators/ResolutionCalculatorPanel.py

    r170e95d re90988c  
    44instrumental parameters. 
    55""" 
    6 from PyQt4 import QtGui 
    7 from PyQt4 import QtCore 
     6from PyQt5 import QtCore 
     7from PyQt5 import QtGui 
     8from PyQt5 import QtWidgets 
    89 
    910from twisted.internet import threads 
    … …  
    2021import re 
    2122 
    22 from UI.ResolutionCalculatorPanelUI import Ui_ResolutionCalculatorPanel 
     23from .UI.ResolutionCalculatorPanelUI import Ui_ResolutionCalculatorPanel 
    2324 
    2425_SOURCE_MASS = {'Alpha': 6.64465620E-24, 
    … …  
    3334 
    3435 
    35 class ResolutionCalculatorPanel(QtGui.QDialog, Ui_ResolutionCalculatorPanel): 
     36class ResolutionCalculatorPanel(QtWidgets.QDialog, Ui_ResolutionCalculatorPanel): 
    3637    """ 
    3738    compute resolution in 2D 
    … …  
    105106 
    106107        # double validator 
    107         self.txtSource2SampleDistance.setValidator(QtGui.QDoubleValidator()) 
    108         self.txtSample2DetectorDistance.setValidator(QtGui.QDoubleValidator()) 
    109         self.txtSampleOffset.setValidator(QtGui.QDoubleValidator()) 
     108        self.txtSource2SampleDistance.setValidator(GuiUtils.DoubleValidator()) 
     109        self.txtSample2DetectorDistance.setValidator(GuiUtils.DoubleValidator()) 
     110        self.txtSampleOffset.setValidator(GuiUtils.DoubleValidator()) 
    110111 
    111112        # call compute to calculate with default values 
    112113        self.createTemplate2DPlot() 
    113         self.onCompute() 
     114        #self.onCompute() 
    114115 
    115116    # ################################# 
    … …  
    123124        text_edit = self.txtWavelength  # self.sender() 
    124125        if text_edit.isModified(): 
    125             text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     126            text_edit.setStyleSheet(BG_WHITE) 
    126127            input_string = str(text_edit.text()) 
    127128            if self.cbWaveColor.currentText() != 'TOF': 
    128129                input_wavelength = re.match('\d+\.?\d*', input_string) 
    129130                if input_wavelength is None: 
    130                     text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     131                    text_edit.setStyleSheet(BG_RED) 
    131132                    self.cmdCompute.setEnabled(False) 
    132133                    logging.info('Wavelength has to be a number.') 
    133134                else: 
    134                     text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     135                    text_edit.setStyleSheet(BG_WHITE) 
    135136                    self.cmdCompute.setEnabled(True) 
    136137            else: 
    … …  
    139140 
    140141                if interval_wavelength is None: 
    141                     text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     142                    text_edit.setStyleSheet(BG_RED) 
    142143                    self.cmdCompute.setEnabled(False) 
    143144                    logging.info("Wavelength's input has to be an interval: " 
    … …  
    149150 
    150151                    if float(wavelength_min) >= float(wavelength_max): 
    151                         text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     152                        text_edit.setStyleSheet(BG_RED) 
    152153                        self.cmdCompute.setEnabled(False) 
    153154                        logging.info("Wavelength: min must be smaller than max.") 
    154155 
    155156                    else: 
    156                         text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     157                        text_edit.setStyleSheet(BG_WHITE) 
    157158                        self.cmdCompute.setEnabled(True) 
    158159 
    … …  
    163164 
    164165        if text_edit.isModified(): 
    165             text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     166            text_edit.setStyleSheet(BG_WHITE) 
    166167            if self.cbWaveColor.currentText() != 'TOF': 
    167168                pattern = '^\d+\.?\d*(|;\s*\d+)$' 
    … …  
    170171 
    171172                if wavelength_spread_input is None: 
    172                     text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     173                    text_edit.setStyleSheet(BG_RED) 
    173174                    self.cmdCompute.setEnabled(False) 
    174175                    logging.info('Wavelength spread has to be specified: ' 
    … …  
    178179                    split_input = wavelength_spread_input.group().split(';') 
    179180                    self.num_wave = split_input[1] if len(split_input) > 1 else 10 
    180                     text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     181                    text_edit.setStyleSheet(BG_WHITE) 
    181182                    self.cmdCompute.setEnabled(True) 
    182183            else: 
    … …  
    186187 
    187188                if wavelength_spread_input is None: 
    188                     text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     189                    text_edit.setStyleSheet(BG_RED) 
    189190                    self.cmdCompute.setEnabled(False) 
    190191                    logging.info("Wavelength spread has to be specified: " 
    … …  
    197198                    self.num_wave = split_input[1] if len( 
    198199                        split_input) > 1 else 10 
    199                     text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     200                    text_edit.setStyleSheet(BG_WHITE) 
    200201                    self.cmdCompute.setEnabled(True) 
    201202 
    … …  
    205206 
    206207        if text_edit.isModified(): 
    207             text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     208            text_edit.setStyleSheet(BG_WHITE) 
    208209            pattern = '^\d+\.?\d*,\s*\d+\.?\d*$' 
    209210            input_string = str(text_edit.text()) 
    … …  
    211212 
    212213            if pixels_input is None: 
    213                 text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     214                text_edit.setStyleSheet(BG_RED) 
    214215                self.cmdCompute.setEnabled(False) 
    215216                logging.info('The input for the detector should contain 2 ' 
    … …  
    217218 
    218219            else: 
    219                 text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     220                text_edit.setStyleSheet(BG_WHITE) 
    220221                self.cmdCompute.setEnabled(True) 
    221222 
    … …  
    229230            q_input = re.match(pattern, input_string) 
    230231            if q_input is None: 
    231                 text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     232                text_edit.setStyleSheet(BG_RED) 
    232233                self.cmdCompute.setEnabled(False) 
    233234                logging.info('Qx and Qy should contain one or more comma-separated numbers.') 
    234235            else: 
    235                 text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     236                text_edit.setStyleSheet(BG_WHITE) 
    236237                self.cmdCompute.setEnabled(True) 
    237238                qx = str(self.txtQx.text()).split(',') 
    … …  
    247248 
    248249                elif len(qx) != len(qy): 
    249                     text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     250                    text_edit.setStyleSheet(BG_RED) 
    250251                    self.cmdCompute.setEnabled(False) 
    251252                    logging.info( 
    … …  
    253254 
    254255                else: 
    255                     text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     256                    text_edit.setStyleSheet(BG_WHITE) 
    256257                    self.cmdCompute.setEnabled(True) 
    257258 
    … …  
    261262 
    262263        if text_edit.isModified(): 
    263             text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     264            text_edit.setStyleSheet(BG_WHITE) 
    264265            input_string = str(text_edit.text()) 
    265266            pattern = '^\d+\.?\d*(|,\s*\d+)$' 
    … …  
    267268 
    268269            if aperture_input is None: 
    269                 text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
     270                text_edit.setStyleSheet(BG_RED) 
    270271                self.cmdCompute.setEnabled(False) 
    271272                logging.info('A circular aperture is defined by a single ' 
    … …  
    274275 
    275276            else: 
    276                 text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     277                text_edit.setStyleSheet(BG_WHITE) 
    277278                self.cmdCompute.setEnabled(True) 
    278279 
    … …  
    315316        """ On Spectrum Combobox event""" 
    316317        if self.cbCustomSpectrum.currentText() == 'Add New': 
    317             datafile = QtGui.QFileDialog.getOpenFileName( 
    318                 self, "Choose a spectral distribution file", "", 
    319                 "All files (*.*)", 
    320                 None, QtGui.QFileDialog.DontUseNativeDialog) 
     318            datafile = QtWidgets.QFileDialog.getOpenFileName( 
     319                self, "Choose a spectral distribution file","", 
     320                "All files (*.*)", None, 
     321                QtWidgets.QFileDialog.DontUseNativeDialog)[0] 
    321322 
    322323            if datafile is None or str(datafile) == '': 
    … …  
    328329            try: 
    329330                basename = os.path.basename(datafile) 
    330                 if basename not in self.spectrum_dic.keys(): 
     331                if basename not in list(self.spectrum_dic.keys()): 
    331332                    self.cbCustomSpectrum.addItem(basename) 
    332333 
    … …  
    365366        documentation tree (after /doc/ ....". 
    366367        """ 
    367         try: 
    368             location = GuiUtils.HELP_DIRECTORY_LOCATION + \ 
    369                        "/user/sasgui/perspectives/calculator/resolution_calculator_help.html" 
    370             self.manager._helpView.load(QtCore.QUrl(location)) 
    371             self.manager._helpView.show() 
    372  
    373         except AttributeError: 
    374             # No manager defined - testing and standalone runs 
    375             pass 
     368        location = "/user/sasgui/perspectives/calculator/resolution_calculator_help.html" 
     369        self.manager.showHelp(location) 
    376370 
    377371    def onReset(self): 
    … …  
    524518 
    525519            cal_res.addCallback(self.complete) 
     520            cal_res.addErrback(self.calculateFailed) 
    526521 
    527522            # logging.info("Computation is in progress...") 
    … …  
    531526            raise 
    532527 
     528    def calculateFailed(self, reason): 
     529        print("calculateFailed Failed with:\n", reason) 
     530        pass 
     531 
    533532    def complete(self, image): 
    534533        """ 
    … …  
    562561        : return: image (numpy array) 
    563562        """ 
    564         image = map(func, qx, qy, 
     563        image = list(map(func, qx, qy, 
    565564                    qx_min, qx_max, 
    566                     qy_min, qy_max)[0] 
     565                    qy_min, qy_max))[0] 
     566 
    567567        return image 
    568568 
    … …  
    604604                msg = "The numbers must be one or two (separated by ',')" 
    605605                logging.info(msg) 
    606                 raise RuntimeError, msg 
     606                raise RuntimeError(msg) 
    607607 
    608608        return new_numbers_list 
    … …  
    618618            new_list = [float(t) for t in string_split] 
    619619        except: 
    620             logging.error(sys.exc_value) 
     620            logging.error(sys.exc_info()[1]) 
    621621        return new_list 
    622622 
    … …  
    658658                        return out 
    659659                except: 
    660                     logging.error(sys.exc_value) 
     660                    logging.error(sys.exc_info()[1]) 
    661661 
    662662    def _validate_q_input(self, qx, qy): 
    … …  
    713713        self.plotter.scale = 'linear' 
    714714        self.plotter.cmap = None 
    715         layout = QtGui.QHBoxLayout() 
     715        layout = QtWidgets.QHBoxLayout() 
    716716        layout.setContentsMargins(0, 0, 0, 0) 
    717717        self.graphicsView.setLayout(layout) 
    … …  
    742742        self.plotter.plot() 
    743743        self.plotter.show() 
     744        self.plotter.update() 
    744745 
    745746    def drawLines(self): 

  • src/sas/qtgui/Calculators/SldPanel.py

    rb0c5e8c re90988c  
    11# global 
    22import logging 
    3 from PyQt4 import QtGui, QtCore 
     3from PyQt5 import QtCore 
     4from PyQt5 import QtGui 
     5from PyQt5 import QtWidgets 
    46 
    57from periodictable import formula as Formula 
    … …  
    1416from sas.qtgui.Calculators.UI.SldPanel import Ui_SldPanel 
    1517 
    16 def enum(*sequential, **named): 
    17     enums = dict(zip(sequential, range(len(sequential))), **named) 
    18     return type('Enum', (), enums) 
     18from sas.qtgui.Utilities.GuiUtils import enum 
    1919 
    2020MODEL = enum( 
    … …  
    6060        if len(formula.atoms) != 1: 
    6161            raise NotImplementedError() 
    62         energy = xray_energy(formula.atoms.keys()[0].K_alpha) 
     62        energy = xray_energy(list(formula.atoms.keys())[0].K_alpha) 
    6363        return xray_sld_from_atoms( 
    6464            sld_formula.atoms, 
    … …  
    9797 
    9898 
    99 class SldPanel(QtGui.QDialog): 
     99class SldPanel(QtWidgets.QDialog): 
    100100 
    101101    def __init__(self, parent=None): 
    … …  
    126126 
    127127        # set validators 
    128         self.ui.editMolecularFormula.setValidator(GuiUtils.FormulaValidator(self.ui.editMolecularFormula)) 
     128        # TODO: GuiUtils.FormulaValidator() crashes with Qt5 - fix 
     129        #self.ui.editMolecularFormula.setValidator(GuiUtils.FormulaValidator(self.ui.editMolecularFormula)) 
    129130 
    130131        rx = QtCore.QRegExp("[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?") 
    … …  
    133134 
    134135        # signals 
    135         self.ui.buttonBox.button(QtGui.QDialogButtonBox.Reset).clicked.connect(self.modelReset) 
    136         self.ui.buttonBox.button(QtGui.QDialogButtonBox.Help).clicked.connect(self.displayHelp) 
     136        self.ui.buttonBox.button(QtWidgets.QDialogButtonBox.Reset).clicked.connect(self.modelReset) 
     137        self.ui.buttonBox.button(QtWidgets.QDialogButtonBox.Help).clicked.connect(self.displayHelp) 
    137138 
    138139    def setupModel(self): 
    … …  
    142143        self.model.setItem(MODEL.WAVELENGTH       , QtGui.QStandardItem()) 
    143144 
    144         for key in self._getOutputs().keys(): 
     145        for key in list(self._getOutputs().keys()): 
    145146            self.model.setItem(key, QtGui.QStandardItem()) 
    146147 
    147         QtCore.QObject.connect( 
    148             self.model, 
    149             QtCore.SIGNAL("dataChanged(QModelIndex,QModelIndex)"), 
    150             self.dataChanged) 
     148        self.model.dataChanged.connect(self.dataChanged) 
    151149 
    152150        self.modelReset() 
    153151 
    154152    def setupMapper(self): 
    155         self.mapper = QtGui.QDataWidgetMapper(self) 
     153        self.mapper = QtWidgets.QDataWidgetMapper(self) 
    156154        self.mapper.setModel(self.model) 
    157155        self.mapper.setOrientation(QtCore.Qt.Vertical) 
    158  
    159156        self.mapper.addMapping(self.ui.editMolecularFormula, MODEL.MOLECULAR_FORMULA) 
    160157        self.mapper.addMapping(self.ui.editMassDensity     , MODEL.MASS_DENSITY) 
    161158        self.mapper.addMapping(self.ui.editWavelength      , MODEL.WAVELENGTH) 
    162159 
    163         for key, edit in self._getOutputs().iteritems(): 
     160        for key, edit in self._getOutputs().items(): 
    164161            self.mapper.addMapping(edit, key) 
    165162 
    … …  
    168165    def dataChanged(self, top, bottom): 
    169166        update = False 
    170         for index in xrange(top.row(), bottom.row() + 1): 
     167        for index in range(top.row(), bottom.row() + 1): 
    171168            if (index == MODEL.MOLECULAR_FORMULA) or (index == MODEL.MASS_DENSITY) or (index == MODEL.WAVELENGTH): 
    172169                update = True 
    … …  
    202199                    pass 
    203200 
    204             for key in self._getOutputs().keys(): 
     201            for key in list(self._getOutputs().keys()): 
    205202                self.model.item(key).setText("") 
    206203 
    … …  
    213210        finally: 
    214211            pass 
    215             #self.model.endResetModel() 
     212        #self.model.endResetModel() 
    216213 
    217214    def displayHelp(self): 
    218         try: 
    219             location = GuiUtils.HELP_DIRECTORY_LOCATION + \ 
    220                 "/user/sasgui/perspectives/calculator/sld_calculator_help.html" 
    221             self.manager._helpView.load(QtCore.QUrl(location)) 
    222             self.manager._helpView.show() 
    223         except AttributeError: 
    224             # No manager defined - testing and standalone runs 
    225             pass 
    226  
     215        location = "/user/sasgui/perspectives/calculator/sld_calculator_help.html" 
     216        self.manager.showHelp(location) 
     217 
     218 

  • src/sas/qtgui/Calculators/SlitSizeCalculator.py

    rf4a1433 re90988c  
    44import os 
    55import sys 
     6import logging 
    67 
    7 from PyQt4 import QtGui 
    8 from PyQt4 import QtCore 
     8from PyQt5 import QtCore 
     9from PyQt5 import QtGui 
     10from PyQt5 import QtWidgets 
    911 
    1012from sas.qtgui.UI import main_resources_rc 
    1113import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    1214 
    13 from UI.SlitSizeCalculator import Ui_SlitSizeCalculator 
     15from .UI.SlitSizeCalculator import Ui_SlitSizeCalculator 
    1416from sas.sascalc.dataloader.loader import Loader 
    1517from sas.sascalc.calculator.slit_length_calculator import SlitlengthCalculator 
    1618 
    1719 
    18 class SlitSizeCalculator(QtGui.QDialog, Ui_SlitSizeCalculator): 
     20class SlitSizeCalculator(QtWidgets.QDialog, Ui_SlitSizeCalculator): 
    1921    """ 
    2022    Provides the slit length calculator GUI. 
    … …  
    4547        documentation tree (after /doc/ ....". 
    4648        """ 
    47         try: 
    48             location = GuiUtils.HELP_DIRECTORY_LOCATION + \ 
    49                 "/user/sasgui/perspectives/calculator/slit_calculator_help.html" 
    50  
    51             self._parent._helpView.load(QtCore.QUrl(location)) 
    52             self._parent._helpView.show() 
    53         except AttributeError: 
    54             # No manager defined - testing and standalone runs 
    55             pass 
     49        location = "/user/sasgui/perspectives/calculator/slit_calculator_help.html" 
     50        self._parent.showHelp(location) 
    5651 
    5752    def onBrowse(self): 
    … …  
    6358            return 
    6459        loader = Loader() 
    65         data = loader.load(path_str)[0] 
     60        try: 
     61            data = loader.load(path_str) 
     62            data = data[0] 
     63        # Can return multiple exceptions - gather them all under one umbrella and complain 
     64        except Exception as ex: 
     65            logging.error(ex) 
     66            return 
    6667 
    6768        self.data_file.setText(os.path.basename(path_str)) 
    … …  
    7576        # Location is automatically saved - no need to keep track of the last dir 
    7677        # But only with Qt built-in dialog (non-platform native) 
    77         path = QtGui.QFileDialog.getOpenFileName(self, "Choose a file", "", 
    78                                                  "SAXSess 1D data (*.txt *.TXT *.dat *.DAT)", None, 
    79                                                  QtGui.QFileDialog.DontUseNativeDialog) 
    80  
    81         if path is None: 
    82             return 
    83  
    84         if isinstance(path, QtCore.QString): 
    85             path = str(path) 
    86  
     78        path = QtWidgets.QFileDialog.getOpenFileName(self, "Choose a file", "", 
     79                                                 "SAXSess 1D data (*.txt *.TXT *.dat *.DAT)", 
     80                                                 None, 
     81                                                 QtWidgets.QFileDialog.DontUseNativeDialog)[0] 
    8782        return path 
    8883 
    … …  
    107102            self.clearResults() 
    108103            msg = "ERROR: Data hasn't been loaded correctly" 
    109             raise RuntimeError, msg 
     104            logging.error(msg) 
     105            return 
    110106 
    111107        if data.__class__.__name__ == 'Data2D': 
    112108            self.clearResults() 
    113109            msg = "Slit Length cannot be computed for 2D Data" 
    114             raise RuntimeError, msg 
     110            logging.error(msg) 
     111            return 
    115112 
    116113        #compute the slit size 
    … …  
    118115            xdata = data.x 
    119116            ydata = data.y 
    120             if xdata == [] or xdata is None or ydata == [] or ydata is None: 
     117            #if xdata == [] or xdata is None or ydata == [] or ydata is None: 
     118            if (not xdata or xdata is None) or (not ydata or ydata is None): 
    121119                msg = "The current data is empty please check x and y" 
    122                 raise ValueError, msg 
     120                logging.error(msg) 
     121                return 
    123122            slit_length_calculator = SlitlengthCalculator() 
    124123            slit_length_calculator.set_data(x=xdata, y=ydata) 
    … …  
    126125        except: 
    127126            self.clearResults() 
    128             msg = "Slit Size Calculator: %s" % (sys.exc_value) 
    129             raise RuntimeError, msg 
     127            msg = "Slit Size Calculator: %s" % (sys.exc_info()[1]) 
     128            logging.error(msg) 
     129            return 
    130130 
    131131        slit_length_str = "{:.5f}".format(slit_length) 

  • src/sas/qtgui/Calculators/UnitTesting/DataOperationUtilityTest.py

    r0c468bf re90988c  
    44import logging 
    55import unittest 
    6 from PyQt4 import QtGui 
    7 from PyQt4 import QtCore 
    8 from PyQt4.QtTest import QTest 
    9 from PyQt4.QtCore import Qt 
    10 from mock import MagicMock 
    11 from mock import patch 
     6import webbrowser 
     7 
     8from PyQt5 import QtGui, QtWidgets 
     9from PyQt5 import QtCore 
     10from PyQt5.QtTest import QTest 
     11from PyQt5.QtCore import Qt 
     12from unittest.mock import MagicMock 
     13from unittest.mock import patch 
    1214 
    1315from twisted.internet import threads 
    … …  
    1921from sas.qtgui.MainWindow.DataState import DataState 
    2022 
    21 if not QtGui.QApplication.instance(): 
    22     app = QtGui.QApplication(sys.argv) 
     23if not QtWidgets.QApplication.instance(): 
     24    app = QtWidgets.QApplication(sys.argv) 
    2325 
    2426BG_COLOR_ERR = 'background-color: rgb(244, 170, 164);' 
    … …  
    4345        """Test the GUI in its default state""" 
    4446 
    45         self.assertIsInstance(self.widget, QtGui.QDialog) 
     47        self.assertIsInstance(self.widget, QtWidgets.QDialog) 
    4648 
    4749        self.assertEqual(self.widget.windowTitle(), "Data Operation") 
    … …  
    98100        self.assertFalse(self.widget.txtNumber.isEnabled()) 
    99101 
    100         self.assertIsInstance(self.widget.layoutOutput,QtGui.QHBoxLayout) 
    101         self.assertIsInstance(self.widget.layoutData1,QtGui.QHBoxLayout) 
    102         self.assertIsInstance(self.widget.layoutData2,QtGui.QHBoxLayout) 
     102        self.assertIsInstance(self.widget.layoutOutput,QtWidgets.QHBoxLayout) 
     103        self.assertIsInstance(self.widget.layoutData1,QtWidgets.QHBoxLayout) 
     104        self.assertIsInstance(self.widget.layoutData2,QtWidgets.QHBoxLayout) 
    103105 
    104106        # To store input datafiles 
    … …  
    119121    def testHelp(self): 
    120122        """ Assure help file is shown """ 
    121         # this should not rise 
     123        self.widget.manager.showHelp = MagicMock() 
    122124        self.widget.onHelp() 
     125        self.assertTrue(self.widget.manager.showHelp.called_once()) 
     126        args = self.widget.manager.showHelp.call_args 
     127        self.assertIn('data_operator_help.html', args[0][0]) 
    123128 
    124129    def testOnReset(self): 

  • src/sas/qtgui/Calculators/UnitTesting/DensityCalculatorTest.py

    r464cd07 re90988c  
    33import webbrowser 
    44 
    5 from PyQt4 import QtGui 
    6 from PyQt4.QtTest import QTest 
    7 from PyQt4 import QtCore 
    8 from mock import MagicMock 
     5from PyQt5 import QtGui, QtWidgets 
     6from PyQt5.QtTest import QTest 
     7from PyQt5 import QtCore 
     8from unittest.mock import MagicMock 
    99 
    1010####### TEMP 
    … …  
    1919import sas.qtgui.Utilities.LocalConfig 
    2020 
    21 if not QtGui.QApplication.instance(): 
    22     app = QtGui.QApplication(sys.argv) 
     21if not QtWidgets.QApplication.instance(): 
     22    app = QtWidgets.QApplication(sys.argv) 
    2323 
    2424class ToMolarMassTest(unittest.TestCase): 
    … …  
    4545        self.widget = DensityPanel(None) 
    4646 
     47        # temporarily set the text here 
     48        self.widget.ui.editMolecularFormula.setText("H2O") 
     49 
    4750    def tearDown(self): 
    4851        '''Destroy the DensityCalculator''' 
    … …  
    5255    def testDefaults(self): 
    5356        '''Test the GUI in its default state''' 
    54         self.assertIsInstance(self.widget, QtGui.QWidget) 
     57        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    5558        self.assertEqual(self.widget.windowTitle(), "Density/Volume Calculator") 
    56         self.assertIsInstance(self.widget.ui.editMolecularFormula.validator(), FormulaValidator) 
     59        # temporarily commented out until FormulaValidator fixed for Qt5 
     60        #self.assertIsInstance(self.widget.ui.editMolecularFormula.validator(), FormulaValidator) 
    5761        self.assertEqual(self.widget.ui.editMolecularFormula.styleSheet(), '') 
    5862        self.assertEqual(self.widget.model.columnCount(), 1) 
    5963        self.assertEqual(self.widget.model.rowCount(), 4) 
    60         self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed) 
     64        self.assertEqual(self.widget.sizePolicy().Policy(), QtWidgets.QSizePolicy.Fixed) 
    6165 
    6266    def testSimpleEntry(self): 
    … …  
    7175        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    7276        QTest.qWait(100) 
     77        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    7378 
    7479        # Assure the mass density field is set 
    … …  
    99104        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    100105        QTest.qWait(100) 
     106        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    101107 
    102108        # Assure the mass density field is set 
    … …  
    115121    def testHelp(self): 
    116122        """ Assure help file is shown """ 
    117  
    118         # this should not rise 
     123        self.widget.manager = QtWidgets.QWidget() 
     124        self.widget.manager.showHelp = MagicMock() 
    119125        self.widget.displayHelp() 
     126        self.assertTrue(self.widget.manager.showHelp.called_once()) 
     127        args = self.widget.manager.showHelp.call_args 
     128        self.assertIn('density_calculator_help.html', args[0][0]) 
    120129 
    121130if __name__ == "__main__": 

  • src/sas/qtgui/Calculators/UnitTesting/GenericScatteringCalculatorTest.py

    rf4a1433 re90988c  
    33import numpy 
    44import unittest 
    5 from PyQt4 import QtGui 
    6 from PyQt4.QtTest import QTest 
    7  
    8 from PyQt4.QtCore import Qt 
    9 from mock import MagicMock 
    10 from mock import patch 
     5from PyQt5 import QtGui, QtWidgets 
     6from PyQt5.QtTest import QTest 
     7 
     8from PyQt5.QtCore import Qt 
     9from unittest.mock import MagicMock 
     10from unittest.mock import patch 
    1111 
    1212# set up import paths 
    … …  
    1515from mpl_toolkits.mplot3d import Axes3D 
    1616from UnitTesting.TestUtils import QtSignalSpy 
    17 from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas 
     17from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas 
    1818from sas.qtgui.Calculators.GenericScatteringCalculator import GenericScatteringCalculator 
    1919from sas.qtgui.Calculators.GenericScatteringCalculator import Plotter3D 
    … …  
    2424from sas.sascalc.calculator import sas_gen 
    2525 
    26 if not QtGui.QApplication.instance(): 
    27     app = QtGui.QApplication(sys.argv) 
    28  
     26if not QtWidgets.QApplication.instance(): 
     27    app = QtWidgets.QApplication(sys.argv) 
    2928 
    3029class GenericScatteringCalculatorTest(unittest.TestCase): 
    … …  
    4645    def testDefaults(self): 
    4746        """Test the GUI in its default state""" 
    48         self.assertIsInstance(self.widget, QtGui.QWidget) 
     47        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    4948        self.assertEqual(self.widget.windowTitle(), "Generic SAS Calculator") 
    5049 
    … …  
    105104    def testHelpButton(self): 
    106105        """ Assure help file is shown """ 
     106        self.widget.manager.showHelp = MagicMock() 
    107107        self.widget.onHelp() 
     108        self.assertTrue(self.widget.manager.showHelp.called_once()) 
     109        args = self.widget.manager.showHelp.call_args 
     110        self.assertIn('sas_calculator_help.html', args[0][0]) 
    108111 
    109112    def testValidator(self): 
    … …  
    175178        """ 
    176179        filename = os.path.join("UnitTesting", "sld_file.sld") 
    177         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     180        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=[filename, '']) 
    178181        self.widget.loadFile() 
    179182 
    … …  
    239242        filename = os.path.join("UnitTesting", "diamdsml.pdb") 
    240243 
    241         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     244        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=[filename, '']) 
    242245        self.widget.loadFile() 
    243246 
    … …  
    302305        filename = os.path.join("UnitTesting", "A_Raw_Example-1.omf") 
    303306 
    304         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     307        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=[filename, '']) 
    305308        self.widget.loadFile() 
    306309        self.assertEqual(self.widget.cmdLoad.text(), 'Loading...') 
    … …  
    369372        filename = os.path.join("UnitTesting", "diamdsml.pdb") 
    370373 
    371         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     374        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=[filename, '']) 
    372375        self.widget.loadFile() 
    373376        time.sleep(1) 
    … …  
    388391        self.assertFalse(self.widget.cmdDraw.isEnabled()) 
    389392        filename = os.path.join("UnitTesting", "diamdsml.pdb") 
    390         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     393        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=[filename,'']) 
    391394        self.widget.loadFile() 
    392395        self.assertEqual(self.widget.cmdLoad.text(), 'Loading...') 
    393396        time.sleep(1) 
     397 
    394398        self.assertTrue(self.widget.cmdDraw.isEnabled()) 
    395399        QTest.mouseClick(self.widget.cmdDraw, Qt.LeftButton) 
    … …  
    408412        filename = os.path.join("UnitTesting", "sld_file.sld") 
    409413 
    410         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     414        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=[filename, '']) 
    411415        self.widget.loadFile() 
    412416 
    … …  
    414418 
    415419        filename1 = "test" 
    416         QtGui.QFileDialog.getSaveFileName = MagicMock(return_value=filename1) 
     420        QtWidgets.QFileDialog.getSaveFileName = MagicMock(return_value=[filename1, '']) 
    417421 
    418422        QTest.mouseClick(self.widget.cmdSave, Qt.LeftButton) 

  • src/sas/qtgui/Calculators/UnitTesting/KiessigCalculatorTest.py

    r464cd07 re90988c  
    11import sys 
    22import unittest 
    3 from PyQt4 import QtGui 
    4 from PyQt4.QtTest import QTest 
    5 from PyQt4.QtCore import Qt 
     3from PyQt5 import QtGui, QtWidgets 
     4from PyQt5.QtTest import QTest 
     5from PyQt5.QtCore import Qt 
    66 
    7 # TEMP 
    8 import sas.qtgui.path_prepare 
    9  
     7import path_prepare 
     8from unittest.mock import MagicMock 
    109 
    1110from sas.qtgui.Calculators.KiessigPanel import KiessigPanel 
    1211 
    13 if not QtGui.QApplication.instance(): 
    14     app = QtGui.QApplication(sys.argv) 
     12if not QtWidgets.QApplication.instance(): 
     13    app = QtWidgets.QApplication(sys.argv) 
    1514 
    1615 
    … …  
    2827    def testDefaults(self): 
    2928        """Test the GUI in its default state""" 
    30         self.assertIsInstance(self.widget, QtGui.QWidget) 
     29        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    3130        self.assertEqual(self.widget.windowTitle(), "Kiessig Thickness Calculator") 
    32         self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed) 
     31        self.assertEqual(self.widget.sizePolicy().Policy(), QtWidgets.QSizePolicy.Fixed) 
    3332 
    3433    def testHelp(self): 
    3534        """ Assure help file is shown """ 
    36  
    37         # this should not rise 
     35        self.widget.manager = QtWidgets.QWidget() 
     36        self.widget.manager.showHelp = MagicMock() 
    3837        self.widget.onHelp() 
     38        self.assertTrue(self.widget.manager.showHelp.called_once()) 
     39        args = self.widget.manager.showHelp.call_args 
     40        self.assertIn('kiessig_calculator_help.html', args[0][0]) 
    3941 
    4042    def testComplexEntryNumbers(self): 

  • src/sas/qtgui/Calculators/UnitTesting/ResolutionCalculatorPanelTest.py

    r170e95d re90988c  
    44import logging 
    55import unittest 
    6 from PyQt4 import QtGui 
    7 from PyQt4 import QtCore 
    8 from PyQt4.QtTest import QTest 
    9 from PyQt4.QtCore import Qt 
    10 from mock import MagicMock 
    11 from mock import patch 
     6from PyQt5 import QtGui, QtWidgets 
     7from PyQt5 import QtCore 
     8from PyQt5.QtTest import QTest 
     9from PyQt5.QtCore import Qt 
     10from unittest.mock import MagicMock 
    1211 
    1312from twisted.internet import threads 
    … …  
    2827 
    2928 
    30 if not QtGui.QApplication.instance(): 
    31     app = QtGui.QApplication(sys.argv) 
     29if not QtWidgets.QApplication.instance(): 
     30    app = QtWidgets.QApplication(sys.argv) 
    3231 
    3332 
    … …  
    4847        """Test the GUI in its default state""" 
    4948 
    50         self.assertIsInstance(self.widget, QtGui.QDialog) 
     49        self.assertIsInstance(self.widget, QtWidgets.QDialog) 
    5150        self.assertEqual(self.widget.windowTitle(), "Q Resolution Estimator") 
    5251        # size 
    … …  
    231230    def testOnSelectCustomSpectrum(self): 
    232231        """ Test Custom Spectrum: load file if 'Add New' """ 
    233         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=None) 
     232        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=("","")) 
    234233        self.widget.cbCustomSpectrum.setCurrentIndex(1) 
    235234 
    236235        # Test the getOpenFileName() dialog called once 
    237         self.assertTrue(QtGui.QFileDialog.getOpenFileName.called) 
    238         QtGui.QFileDialog.getOpenFileName.assert_called_once() 
     236        self.assertTrue(QtWidgets.QFileDialog.getOpenFileName.called) 
     237        QtWidgets.QFileDialog.getOpenFileName.assert_called_once() 
    239238 
    240239    def testHelp(self): 
    241240        """ Assure help file is shown """ 
    242241        # this should not rise 
     242        self.widget.manager = QtWidgets.QWidget() 
     243        self.widget.manager.showHelp = MagicMock() 
    243244        self.widget.onHelp() 
     245        self.assertTrue(self.widget.manager.showHelp.called_once()) 
     246        args = self.widget.manager.showHelp.call_args 
     247        self.assertIn('resolution_calculator_help.html', args[0][0]) 
    244248 
    245249    def testOnReset(self): 

  • src/sas/qtgui/Calculators/UnitTesting/SLDCalculatorTest.py

    rf4a1433 re90988c  
    33import webbrowser 
    44 
    5 from PyQt4 import QtGui 
    6 from PyQt4.QtTest import QTest 
    7 from PyQt4 import QtCore 
    8 from mock import MagicMock 
     5from PyQt5 import QtGui, QtWidgets 
     6from PyQt5.QtTest import QTest 
     7from PyQt5 import QtCore 
     8from unittest.mock import MagicMock 
    99 
    1010####### TEMP 
    … …  
    2020import sas.qtgui.Utilities.LocalConfig 
    2121 
    22 if not QtGui.QApplication.instance(): 
    23     app = QtGui.QApplication(sys.argv) 
     22#if not QtWidgets.QApplication.instance(): 
     23#    app = QtWidgets.QApplication(sys.argv) 
     24app = QtWidgets.QApplication(sys.argv) 
    2425 
    2526class SldResultTest(unittest.TestCase): 
    … …  
    7576    def testDefaults(self): 
    7677        '''Test the GUI in its default state''' 
    77         self.assertIsInstance(self.widget, QtGui.QWidget) 
    78         self.assertEqual(self.widget.windowTitle(), "SLD Calculator") 
    79         self.assertIsInstance(self.widget.ui.editMolecularFormula.validator(), FormulaValidator) 
     78        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
     79        # temporarily commented out until FormulaValidator fixed for Qt5 
     80        # self.assertEqual(self.widget.windowTitle(), "SLD Calculator") 
     81        # self.assertIsInstance(self.widget.ui.editMolecularFormula.validator(), FormulaValidator) 
    8082        self.assertEqual(self.widget.ui.editMolecularFormula.styleSheet(), '') 
    8183        self.assertEqual(self.widget.model.columnCount(), 1) 
    8284        self.assertEqual(self.widget.model.rowCount(), 12) 
    83         self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed) 
     85        self.assertEqual(self.widget.sizePolicy().Policy(), QtWidgets.QSizePolicy.Fixed) 
    8486 
    8587    def testSimpleEntry(self): 
    … …  
    9496        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    9597        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    96         QtGui.qApp.processEvents() 
     98        QtWidgets.qApp.processEvents() 
    9799        QTest.qWait(100) 
    98100 
    … …  
    107109        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    108110        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    109         QtGui.qApp.processEvents() 
     111        QtWidgets.qApp.processEvents() 
    110112        QTest.qWait(100) 
    111113 
    … …  
    126128        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    127129        QTest.qWait(100) 
     130        QTest.keyEvent(QTest.Press, self.widget, key, QtCore.Qt.NoModifier) 
    128131 
    129132        # Assure the mass density field is set 
    … …  
    139142    def testHelp(self): 
    140143        """ Assure help file is shown """ 
    141  
    142         # this should not rise 
     144        self.widget.manager = QtWidgets.QWidget() 
     145        self.widget.manager.showHelp = MagicMock() 
    143146        self.widget.displayHelp() 
     147        self.assertTrue(self.widget.manager.showHelp.called_once()) 
     148        args = self.widget.manager.showHelp.call_args 
     149        self.assertIn('sld_calculator_help.html', args[0][0]) 
    144150 
    145151if __name__ == "__main__": 

  • src/sas/qtgui/Calculators/UnitTesting/SlitSizeCalculatorTest.py

    rf4a1433 re90988c  
    11import sys 
    22import unittest 
    3 from PyQt4 import QtGui 
    4 from PyQt4.QtTest import QTest 
    5 from PyQt4.QtCore import Qt 
    6 from mock import MagicMock 
     3import logging 
     4 
     5from PyQt5 import QtGui, QtWidgets 
     6from PyQt5.QtTest import QTest 
     7from PyQt5.QtCore import Qt 
     8from unittest.mock import MagicMock 
    79 
    810# set up import paths 
    … …  
    1214from sas.sascalc.dataloader.loader import Loader 
    1315 
    14 if not QtGui.QApplication.instance(): 
    15     app = QtGui.QApplication(sys.argv) 
     16if not QtWidgets.QApplication.instance(): 
     17    app = QtWidgets.QApplication(sys.argv) 
    1618 
    1719 
    … …  
    2931    def testDefaults(self): 
    3032        """Test the GUI in its default state""" 
    31         self.assertIsInstance(self.widget, QtGui.QWidget) 
     33        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    3234        self.assertEqual(self.widget.windowTitle(), "Slit Size Calculator") 
    33         self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed) 
     35        self.assertEqual(self.widget.sizePolicy().Policy(), QtWidgets.QSizePolicy.Fixed) 
    3436 
    3537    def testHelp(self): 
    3638        """ Assure help file is shown """ 
    37  
    38         # this should not rise 
     39        self.widget._parent = QtWidgets.QWidget() 
     40        self.widget._parent.showHelp = MagicMock() 
    3941        self.widget.onHelp() 
     42        self.assertTrue(self.widget._parent.showHelp.called_once()) 
     43        args = self.widget._parent.showHelp.call_args 
     44        self.assertIn('slit_calculator_help.html', args[0][0]) 
    4045 
    4146    def testBrowseButton(self): 
    … …  
    4550 
    4651        # Return no files. 
    47         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=None) 
     52        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=('','')) 
    4853 
    4954        # Click on the Browse button 
    … …  
    5156 
    5257        # Test the getOpenFileName() dialog called once 
    53         self.assertTrue(QtGui.QFileDialog.getOpenFileName.called) 
    54         QtGui.QFileDialog.getOpenFileName.assert_called_once() 
     58        self.assertTrue(QtWidgets.QFileDialog.getOpenFileName.called) 
     59        QtWidgets.QFileDialog.getOpenFileName.assert_called_once() 
    5560 
    5661        # Now, return a single file 
    57         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     62        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=(filename,'')) 
    5863 
    5964        # Click on the Load button 
    6065        QTest.mouseClick(browseButton, Qt.LeftButton) 
    61         QtGui.qApp.processEvents() 
     66        QtWidgets.qApp.processEvents() 
    6267 
    6368        # Test the getOpenFileName() dialog called once 
    64         self.assertTrue(QtGui.QFileDialog.getOpenFileName.called) 
    65         QtGui.QFileDialog.getOpenFileName.assert_called_once() 
     69        self.assertTrue(QtWidgets.QFileDialog.getOpenFileName.called) 
     70        QtWidgets.QFileDialog.getOpenFileName.assert_called_once() 
    6671 
    6772 
    … …  
    8186        """ Test on wrong input data """ 
    8287 
    83         filename = "P123_D2O_10_percent.dat" 
     88        filename = "Dec07031.ASC" 
    8489        loader = Loader() 
    8590        data = loader.load(filename)[0] 
    86         self.assertRaisesRegexp(RuntimeError, 
    87                                 "Slit Length cannot be computed for 2D Data", 
    88                                 self.widget.calculateSlitSize, data) 
     91 
     92        logging.error = MagicMock() 
     93 
     94        self.widget.calculateSlitSize(data) 
     95 
     96        self.assertTrue(logging.error.called_once()) 
    8997 
    9098        data = None 
    91         self.assertRaisesRegexp(RuntimeError, 
    92                                 "ERROR: Data hasn't been loaded correctly", 
    93                                 self.widget.calculateSlitSize, data) 
     99        self.widget.calculateSlitSize(data) 
     100        self.assertTrue(logging.error.call_count == 2) 
    94101 
    95102 

  • src/sas/qtgui/GUITests.py

    rf4a1433 rda9a0722  
    11import unittest 
    22import sys 
    3 from PyQt4 import QtGui 
     3from PyQt5 import QtGui 
     4from PyQt5 import QtWidgets 
    45 
    56# Prepare the general QApplication instance 
    6 app = QtGui.QApplication(sys.argv) 
     7app = QtWidgets.QApplication(sys.argv) 
    78 
    89# Main Window 
    … …  
    1415from MainWindow.UnitTesting import MainWindowTest 
    1516 
    16 # Plotting 
     17## Plotting 
    1718from Plotting.UnitTesting import AddTextTest 
    1819from Plotting.UnitTesting import PlotHelperTest 
    19 from Plotting.UnitTesting import PlotterBaseTest 
    20 from Plotting.UnitTesting import PlotterTest 
    21 from Plotting.UnitTesting import Plotter2DTest 
     20from Plotting.UnitTesting import WindowTitleTest 
    2221from Plotting.UnitTesting import ScalePropertiesTest 
    23 from Plotting.UnitTesting import WindowTitleTest 
    2422from Plotting.UnitTesting import SetGraphRangeTest 
    2523from Plotting.UnitTesting import LinearFitTest 
    … …  
    3028from Plotting.UnitTesting import SlicerModelTest 
    3129from Plotting.UnitTesting import SlicerParametersTest 
     30from Plotting.UnitTesting import PlotterBaseTest 
     31from Plotting.UnitTesting import PlotterTest 
     32from Plotting.UnitTesting import Plotter2DTest 
    3233 
    3334# Calculators 
    … …  
    4849 
    4950# Perspectives 
    50 import path_prepare 
     51#  Fitting 
    5152from Perspectives.Fitting.UnitTesting import FittingWidgetTest 
    5253from Perspectives.Fitting.UnitTesting import FittingPerspectiveTest 
    … …  
    5556from Perspectives.Fitting.UnitTesting import FitPageTest 
    5657from Perspectives.Fitting.UnitTesting import FittingOptionsTest 
     58from Perspectives.Fitting.UnitTesting import MultiConstraintTest 
     59from Perspectives.Fitting.UnitTesting import ComplexConstraintTest 
     60from Perspectives.Fitting.UnitTesting import ConstraintWidgetTest 
     61 
     62#  Invariant 
     63from Perspectives.Invariant.UnitTesting import InvariantPerspectiveTest 
     64 
     65#  Inversion 
     66from Perspectives.Inversion.UnitTesting import InversionPerspectiveTest 
    5767 
    5868def suite(): 
    5969    suites = ( 
    6070        # Plotting 
     71        unittest.makeSuite(Plotter2DTest.Plotter2DTest,               'test'), 
    6172        unittest.makeSuite(PlotHelperTest.PlotHelperTest,             'test'), 
    62         unittest.makeSuite(PlotterTest.PlotterTest,                   'test'), 
     73        unittest.makeSuite(AddTextTest.AddTextTest,                   'test'), 
    6374        unittest.makeSuite(WindowTitleTest.WindowTitleTest,           'test'), 
    64         unittest.makeSuite(PlotterBaseTest.PlotterBaseTest,           'test'), 
    65         unittest.makeSuite(Plotter2DTest.Plotter2DTest,               'test'), 
    66         unittest.makeSuite(AddTextTest.AddTextTest,                   'test'), 
    6775        unittest.makeSuite(ScalePropertiesTest.ScalePropertiesTest,   'test'), 
    6876        unittest.makeSuite(SetGraphRangeTest.SetGraphRangeTest,       'test'), 
    … …  
    7482        unittest.makeSuite(SlicerModelTest.SlicerModelTest,           'test'), 
    7583        unittest.makeSuite(SlicerParametersTest.SlicerParametersTest, 'test'), 
     84        unittest.makeSuite(PlotterBaseTest.PlotterBaseTest,           'test'), 
     85        unittest.makeSuite(PlotterTest.PlotterTest,                   'test'), 
    7686 
    7787        # Main window 
    7888        unittest.makeSuite(DataExplorerTest.DataExplorerTest,  'test'), 
     89        unittest.makeSuite(DroppableDataLoadWidgetTest.DroppableDataLoadWidgetTest, 'test'), 
     90        unittest.makeSuite(MainWindowTest.MainWindowTest,      'test'), 
    7991        unittest.makeSuite(GuiManagerTest.GuiManagerTest,      'test'), 
    80         unittest.makeSuite(GuiUtilsTest.GuiUtilsTest,          'test'), 
    8192        unittest.makeSuite(AboutBoxTest.AboutBoxTest,          'test'), 
    8293        unittest.makeSuite(WelcomePanelTest.WelcomePanelTest,  'test'), 
    83         unittest.makeSuite(DroppableDataLoadWidgetTest.DroppableDataLoadWidgetTest, 'test'), 
    84         unittest.makeSuite(MainWindowTest.MainWindowTest,      'test'), 
    8594 
    8695        # Utilities 
    87         unittest.makeSuite(TestUtilsTest.TestUtilsTest,         'test'), 
    88         unittest.makeSuite(SasviewLoggerTest.SasviewLoggerTest, 'test'), 
     96        unittest.makeSuite(TestUtilsTest.TestUtilsTest,           'test'), 
     97        unittest.makeSuite(SasviewLoggerTest.SasviewLoggerTest,   'test'), 
     98        unittest.makeSuite(GuiUtilsTest.GuiUtilsTest,             'test'), 
     99        unittest.makeSuite(GuiUtilsTest.DoubleValidatorTest,      'test'), 
     100        unittest.makeSuite(GuiUtilsTest.HashableStandardItemTest, 'test'), 
    89101 
    90102        # Calculators 
    … …  
    98110 
    99111        # Perspectives 
     112        #  Fitting 
    100113        unittest.makeSuite(FittingPerspectiveTest.FittingPerspectiveTest, 'test'), 
    101114        unittest.makeSuite(FittingWidgetTest.FittingWidgetTest,           'test'), 
    … …  
    104117        unittest.makeSuite(FitPageTest.FitPageTest,                       'test'), 
    105118        unittest.makeSuite(FittingOptionsTest.FittingOptionsTest,         'test'), 
    106      ) 
     119        unittest.makeSuite(MultiConstraintTest.MultiConstraintTest,       'test'), 
     120        unittest.makeSuite(ConstraintWidgetTest.ConstraintWidgetTest,     'test'), 
     121        unittest.makeSuite(ComplexConstraintTest.ComplexConstraintTest,   'test'), 
     122 
     123        #  Invariant 
     124        unittest.makeSuite(InvariantPerspectiveTest.InvariantPerspectiveTest,  'test'), 
     125        #  Inversion 
     126        unittest.makeSuite(InversionPerspectiveTest.InversionTest,  'test'), 
     127        ) 
    107128    return unittest.TestSuite(suites) 
    108129 

  • src/sas/qtgui/MainWindow/AboutBox.py

    rcd2cc745 r4992ff2  
    11import functools 
    2 from PyQt4 import QtGui 
     2from PyQt5 import QtWidgets 
    33 
    44import sas.sasview 
    … …  
    88from sas.qtgui.UI import main_resources_rc 
    99 
    10 from UI.AboutUI import Ui_AboutUI 
     10from .UI.AboutUI import Ui_AboutUI 
    1111 
    12 class AboutBox(QtGui.QDialog, Ui_AboutUI): 
     12class AboutBox(QtWidgets.QDialog, Ui_AboutUI): 
    1313    def __init__(self, parent=None): 
    1414        super(AboutBox, self).__init__(parent) 

  • src/sas/qtgui/MainWindow/DataExplorer.py

    r88e1f57 re90988c  
    55import logging 
    66 
    7 from PyQt4 import QtCore 
    8 from PyQt4 import QtGui 
    9 from PyQt4 import QtWebKit 
    10 from PyQt4.Qt import QMutex 
     7from PyQt5 import QtCore 
     8from PyQt5 import QtGui 
     9from PyQt5 import QtWidgets 
    1110 
    1211from twisted.internet import threads 
    … …  
    3029import sas.qtgui.Perspectives as Perspectives 
    3130 
     31DEFAULT_PERSPECTIVE = "Fitting" 
     32 
    3233class DataExplorerWindow(DroppableDataLoadWidget): 
    3334    # The controller which is responsible for managing signal slots connections 
    … …  
    4849        self.loader = Loader() 
    4950        self.manager = manager if manager is not None else DataManager() 
    50         self.txt_widget = QtGui.QTextEdit(None) 
     51        self.txt_widget = QtWidgets.QTextEdit(None) 
    5152 
    5253        # Be careful with twisted threads. 
    53         self.mutex = QMutex() 
     54        self.mutex = QtCore.QMutex() 
    5455 
    5556        # Active plots 
    … …  
    6869        self.cmdHelp_2.clicked.connect(self.displayHelp) 
    6970 
    70         # Display HTML content 
    71         self._helpView = QtWebKit.QWebView() 
    72  
    7371        # Fill in the perspectives combo 
    7472        self.initPerspectives() 
    … …  
    9896 
    9997        # Proxy model for showing a subset of Data1D/Data2D content 
    100         self.data_proxy = QtGui.QSortFilterProxyModel(self) 
     98        self.data_proxy = QtCore.QSortFilterProxyModel(self) 
    10199        self.data_proxy.setSourceModel(self.model) 
    102100 
    … …  
    108106 
    109107        # Proxy model for showing a subset of Theory content 
    110         self.theory_proxy = QtGui.QSortFilterProxyModel(self) 
     108        self.theory_proxy = QtCore.QSortFilterProxyModel(self) 
    111109        self.theory_proxy.setSourceModel(self.theory_model) 
    112110 
    … …  
    139137        Show the "Loading data" section of help 
    140138        """ 
    141         tree_location = GuiUtils.HELP_DIRECTORY_LOCATION +\ 
    142             "/user/sasgui/guiframe/data_explorer_help.html" 
    143         self._helpView.load(QtCore.QUrl(tree_location)) 
    144         self._helpView.show() 
     139        tree_location = "/user/sasgui/guiframe/data_explorer_help.html" 
     140        self.parent.showHelp(tree_location) 
    145141 
    146142    def enableGraphCombo(self, combo_text): 
    … …  
    155151        Populate the Perspective combobox and define callbacks 
    156152        """ 
    157         available_perspectives = sorted([p for p in Perspectives.PERSPECTIVES.keys()]) 
     153        available_perspectives = sorted([p for p in list(Perspectives.PERSPECTIVES.keys())]) 
    158154        if available_perspectives: 
    159155            self.cbFitting.clear() 
    … …  
    161157        self.cbFitting.currentIndexChanged.connect(self.updatePerspectiveCombo) 
    162158        # Set the index so we see the default (Fitting) 
    163         self.updatePerspectiveCombo(0) 
     159        self.cbFitting.setCurrentIndex(self.cbFitting.findText(DEFAULT_PERSPECTIVE)) 
    164160 
    165161    def _perspective(self): 
    … …  
    175171        load_thread = threads.deferToThread(self.readData, url) 
    176172        load_thread.addCallback(self.loadComplete) 
     173        load_thread.addErrback(self.loadFailed) 
    177174 
    178175    def loadFile(self, event=None): 
    … …  
    191188        Opens the Qt "Open Folder..." dialog 
    192189        """ 
    193         folder = QtGui.QFileDialog.getExistingDirectory(self, "Choose a directory", "", 
    194               QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog) 
     190        folder = QtWidgets.QFileDialog.getExistingDirectory(self, "Choose a directory", "", 
     191              QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog) 
    195192        if folder is None: 
    196193            return 
    … …  
    215212            'caption'   : 'Open Project', 
    216213            'filter'    : 'Project (*.json);;All files (*.*)', 
    217             'options'   : QtGui.QFileDialog.DontUseNativeDialog 
     214            'options'   : QtWidgets.QFileDialog.DontUseNativeDialog 
    218215        } 
    219         filename = str(QtGui.QFileDialog.getOpenFileName(**kwargs)) 
     216        filename = QtWidgets.QFileDialog.getOpenFileName(**kwargs)[0] 
    220217        if filename: 
    221218            load_thread = threads.deferToThread(self.readProject, filename) 
    222219            load_thread.addCallback(self.readProjectComplete) 
     220            load_thread.addErrback(self.readProjectFailed) 
     221 
     222    def loadFailed(self, reason): 
     223        """ 
     224        """ 
     225        print("file load FAILED: ", reason) 
     226        pass 
     227 
     228    def readProjectFailed(self, reason): 
     229        """ 
     230        """ 
     231        print("readProjectFailed FAILED: ", reason) 
     232        pass 
    223233 
    224234    def readProject(self, filename): 
    … …  
    240250 
    241251        self.manager.assign(manager) 
    242         for id, item in self.manager.get_all_data().iteritems(): 
     252        self.model.beginResetModel() 
     253        for id, item in self.manager.get_all_data().items(): 
    243254            self.updateModel(item.data, item.path) 
    244255 
    245         self.model.reset() 
     256        self.model.endResetModel() 
    246257 
    247258    def saveProject(self): 
    … …  
    253264            'caption'   : 'Save Project', 
    254265            'filter'    : 'Project (*.json)', 
    255             'options'   : QtGui.QFileDialog.DontUseNativeDialog 
     266            'options'   : QtWidgets.QFileDialog.DontUseNativeDialog 
    256267        } 
    257         filename = str(QtGui.QFileDialog.getSaveFileName(**kwargs)) 
     268        name_tuple = QtWidgets.QFileDialog.getSaveFileName(**kwargs) 
     269        filename = name_tuple[0] 
    258270        if filename: 
     271            _, extension = os.path.splitext(filename) 
     272            if not extension: 
     273                filename = '.'.join((filename, 'json')) 
    259274            self.communicator.statusBarUpdateSignal.emit("Saving Project... %s\n" % os.path.basename(filename)) 
    260275            with open(filename, 'w') as outfile: 
    … …  
    268283        delete_msg = "This operation will delete the checked data sets and all the dependents." +\ 
    269284                     "\nDo you want to continue?" 
    270         reply = QtGui.QMessageBox.question(self, 
     285        reply = QtWidgets.QMessageBox.question(self, 
    271286                                           'Warning', 
    272287                                           delete_msg, 
    273                                            QtGui.QMessageBox.Yes, 
    274                                            QtGui.QMessageBox.No) 
    275  
    276         if reply == QtGui.QMessageBox.No: 
     288                                           QtWidgets.QMessageBox.Yes, 
     289                                           QtWidgets.QMessageBox.No) 
     290 
     291        if reply == QtWidgets.QMessageBox.No: 
    277292            return 
    278293 
    … …  
    308323        delete_msg = "This operation will delete the checked data sets and all the dependents." +\ 
    309324                     "\nDo you want to continue?" 
    310         reply = QtGui.QMessageBox.question(self, 
     325        reply = QtWidgets.QMessageBox.question(self, 
    311326                                           'Warning', 
    312327                                           delete_msg, 
    313                                            QtGui.QMessageBox.Yes, 
    314                                            QtGui.QMessageBox.No) 
    315  
    316         if reply == QtGui.QMessageBox.No: 
     328                                           QtWidgets.QMessageBox.Yes, 
     329                                           QtWidgets.QMessageBox.No) 
     330 
     331        if reply == QtWidgets.QMessageBox.No: 
    317332            return 
    318333 
    … …  
    345360        # Figure out which rows are checked 
    346361        selected_items = [self.model.item(index) 
    347                           for index in xrange(self.model.rowCount()) 
     362                          for index in range(self.model.rowCount()) 
    348363                          if isItemReady(index)] 
    349364 
    … …  
    354369        if len(selected_items) > 1 and not self._perspective().allowBatch(): 
    355370            msg = self._perspective().title() + " does not allow multiple data." 
    356             msgbox = QtGui.QMessageBox() 
    357             msgbox.setIcon(QtGui.QMessageBox.Critical) 
     371            msgbox = QtWidgets.QMessageBox() 
     372            msgbox.setIcon(QtWidgets.QMessageBox.Critical) 
    358373            msgbox.setText(msg) 
    359             msgbox.setStandardButtons(QtGui.QMessageBox.Ok) 
     374            msgbox.setStandardButtons(QtWidgets.QMessageBox.Ok) 
    360375            retval = msgbox.exec_() 
    361376            return 
    … …  
    382397            if outer_item.isCheckable() and \ 
    383398                   outer_item.checkState() == QtCore.Qt.Checked: 
     399                self.model.beginResetModel() 
    384400                theories_copied += 1 
    385401                new_item = self.recursivelyCloneItem(outer_item) 
    … …  
    389405                new_item.setText(new_name) 
    390406                self.model.appendRow(new_item) 
    391             self.model.reset() 
     407                self.model.endResetModel() 
     408            #self.model.reset() 
    392409 
    393410        freeze_msg = "" 
    … …  
    400417        else: 
    401418            freeze_msg = "Unexpected number of theories copied: %i" % theories_copied 
    402             raise AttributeError, freeze_msg 
     419            raise AttributeError(freeze_msg) 
    403420        self.communicator.statusBarUpdateSignal.emit(freeze_msg) 
    404421        # Actively switch tabs 
    … …  
    411428        new_item = item.clone() 
    412429        # clone doesn't do deepcopy :( 
    413         for child_index in xrange(item.rowCount()): 
     430        for child_index in range(item.rowCount()): 
    414431            child_item = self.recursivelyCloneItem(item.child(child_index)) 
    415432            new_item.setChild(child_index, child_item) 
    … …  
    435452            return 
    436453        new_plots = [PlotHelper.plotById(plot) for plot in graph_list] 
    437         active_plots_copy = self.active_plots.keys() 
     454        active_plots_copy = list(self.active_plots.keys()) 
    438455        for plot in active_plots_copy: 
    439456            if self.active_plots[plot] in new_plots: 
    … …  
    478495        for plot in plots: 
    479496            plot_id = plot.id 
    480             if plot_id in self.active_plots.keys(): 
     497            if plot_id in list(self.active_plots.keys()): 
    481498                self.active_plots[plot_id].replacePlot(plot_id, plot) 
    482499            else: 
    … …  
    530547            else: 
    531548                msg = "Incorrect data type passed to Plotting" 
    532                 raise AttributeError, msg 
     549                raise AttributeError(msg) 
    533550 
    534551        if 'new_plot' in locals() and \ 
    … …  
    561578 
    562579        # Add the plot to the workspace 
    563         self.parent.workspace().addWindow(new_plot) 
     580        self.parent.workspace().addSubWindow(new_plot) 
    564581 
    565582        # Show the plot 
    566583        new_plot.show() 
     584        new_plot.canvas.draw() 
    567585 
    568586        # Update the active chart list 
    … …  
    597615 
    598616        id = data.id 
    599         if data.id in self.active_plots.keys(): 
     617        if data.id in list(self.active_plots.keys()): 
    600618            self.active_plots[id].replacePlot(id, data) 
    601619 
    … …  
    609627        # Location is automatically saved - no need to keep track of the last dir 
    610628        # But only with Qt built-in dialog (non-platform native) 
    611         paths = QtGui.QFileDialog.getOpenFileNames(self, "Choose a file", "", 
    612                 wlist, None, QtGui.QFileDialog.DontUseNativeDialog) 
    613         if paths is None: 
     629        paths = QtWidgets.QFileDialog.getOpenFileNames(self, "Choose a file", "", 
     630                wlist, None, QtWidgets.QFileDialog.DontUseNativeDialog)[0] 
     631        if not paths: 
    614632            return 
    615  
    616         if isinstance(paths, QtCore.QStringList): 
    617             paths = [str(f) for f in paths] 
    618633 
    619634        if not isinstance(paths, list): 
    … …  
    673688                    self.mutex.lock() 
    674689                    self.updateModel(new_data, p_file) 
    675                     self.model.reset() 
    676                     QtGui.qApp.processEvents() 
     690                    #self.model.reset() 
     691                    QtWidgets.QApplication.processEvents() 
    677692                    self.mutex.unlock() 
    678693 
    … …  
    687702 
    688703            except Exception as ex: 
    689                 logging.error(sys.exc_value) 
     704                logging.error(sys.exc_info()[1]) 
    690705 
    691706                any_error = True 
    … …  
    747762        if not isinstance(index, int): 
    748763            msg = "Incorrect type passed to DataExplorer.selectData()" 
    749             raise AttributeError, msg 
     764            raise AttributeError(msg) 
    750765 
    751766        # Respond appropriately 
    … …  
    773788                except AttributeError: 
    774789                    msg = "Bad structure of the data model." 
    775                     raise RuntimeError, msg 
     790                    raise RuntimeError(msg) 
    776791 
    777792                if is1D: 
    … …  
    787802                except AttributeError: 
    788803                    msg = "Bad structure of the data model." 
    789                     raise RuntimeError, msg 
     804                    raise RuntimeError(msg) 
    790805 
    791806                if item.isCheckable() and item.checkState() == QtCore.Qt.Checked and is1D: 
    … …  
    801816                except AttributeError: 
    802817                    msg = "Bad structure of the data model." 
    803                     raise RuntimeError, msg 
     818                    raise RuntimeError(msg) 
    804819 
    805820                if is2D: 
    … …  
    815830                except AttributeError: 
    816831                    msg = "Bad structure of the data model." 
    817                     raise RuntimeError, msg 
     832                    raise RuntimeError(msg) 
    818833 
    819834                if item.isCheckable() and item.checkState() == QtCore.Qt.Checked and is2D: 
    … …  
    823838            msg = "Incorrect value in the Selection Option" 
    824839            # Change this to a proper logging action 
    825             raise Exception, msg 
     840            raise Exception(msg) 
    826841 
    827842    def contextMenu(self): 
    … …  
    830845        """ 
    831846        # Create a custom menu based on actions defined in the UI file 
    832         self.context_menu = QtGui.QMenu(self) 
     847        self.context_menu = QtWidgets.QMenu(self) 
    833848        self.context_menu.addAction(self.actionDataInfo) 
    834849        self.context_menu.addAction(self.actionSaveAs) 
    … …  
    837852        self.context_menu.addAction(self.actionQuick3DPlot) 
    838853        self.context_menu.addAction(self.actionEditMask) 
     854        self.context_menu.addSeparator() 
     855        self.context_menu.addAction(self.actionDelete) 
     856 
    839857 
    840858        # Define the callbacks 
    … …  
    844862        self.actionQuick3DPlot.triggered.connect(self.quickData3DPlot) 
    845863        self.actionEditMask.triggered.connect(self.showEditDataMask) 
     864        self.actionDelete.triggered.connect(self.deleteItem) 
    846865 
    847866    def onCustomContextMenu(self, position): 
    … …  
    894913        # Move the slider all the way up, if present 
    895914        vertical_scroll_bar = self.txt_widget.verticalScrollBar() 
    896         vertical_scroll_bar.triggerAction(QtGui.QScrollBar.SliderToMinimum) 
     915        vertical_scroll_bar.triggerAction(QtWidgets.QScrollBar.SliderToMinimum) 
    897916 
    898917    def saveDataAs(self): 
    … …  
    975994        mask_editor.exec_() 
    976995 
     996    def deleteItem(self): 
     997        """ 
     998        Delete the current item 
     999        """ 
     1000        # Assure this is indeed wanted 
     1001        delete_msg = "This operation will delete the selected data sets." +\ 
     1002                     "\nDo you want to continue?" 
     1003        reply = QtWidgets.QMessageBox.question(self, 
     1004                                           'Warning', 
     1005                                           delete_msg, 
     1006                                           QtWidgets.QMessageBox.Yes, 
     1007                                           QtWidgets.QMessageBox.No) 
     1008 
     1009        if reply == QtWidgets.QMessageBox.No: 
     1010            return 
     1011 
     1012        indices = self.current_view.selectedIndexes() 
     1013        proxy = self.current_view.model() 
     1014        model = proxy.sourceModel() 
     1015 
     1016        for index in indices: 
     1017            row_index = proxy.mapToSource(index) 
     1018            item_to_delete = model.itemFromIndex(row_index) 
     1019            if item_to_delete and item_to_delete.isCheckable(): 
     1020                row = row_index.row() 
     1021                if item_to_delete.parent(): 
     1022                    # We have a child item - delete from it 
     1023                    item_to_delete.parent().removeRow(row) 
     1024                else: 
     1025                    # delete directly from model 
     1026                    model.removeRow(row) 
     1027        pass 
     1028 
    9771029    def loadComplete(self, output): 
    9781030        """ 
    … …  
    9821034 
    9831035        # Reset the model so the view gets updated. 
    984         self.model.reset() 
     1036        #self.model.reset() 
    9851037        self.communicator.progressBarUpdateSignal.emit(-1) 
    9861038 
    … …  
    9911043        self.communicator.fileDataReceivedSignal.emit(output_data) 
    9921044        self.manager.add_data(data_list=output_data) 
     1045 
     1046    def loadFailed(self, reason): 
     1047        print("File Load Failed with:\n", reason) 
     1048        pass 
    9931049 
    9941050    def updateModel(self, data, p_file): 
    … …  
    10091065 
    10101066        # Top-level item: checkbox with label 
    1011         checkbox_item = QtGui.QStandardItem(True) 
     1067        checkbox_item = GuiUtils.HashableStandardItem() 
    10121068        checkbox_item.setCheckable(True) 
    10131069        checkbox_item.setCheckState(QtCore.Qt.Checked) 
    … …  
    10151071 
    10161072        # Add the actual Data1D/Data2D object 
    1017         object_item = QtGui.QStandardItem() 
    1018         object_item.setData(QtCore.QVariant(data)) 
     1073        object_item = GuiUtils.HashableStandardItem() 
     1074        object_item.setData(data) 
    10191075 
    10201076        checkbox_item.setChild(0, object_item) 
    … …  
    10301086 
    10311087        # New row in the model 
     1088        self.model.beginResetModel() 
    10321089        self.model.appendRow(checkbox_item) 
     1090        self.model.endResetModel() 
    10331091 
    10341092    def updateModelFromPerspective(self, model_item): 
    … …  
    10401098        if not isinstance(model_item, QtGui.QStandardItem): 
    10411099            msg = "Wrong data type returned from calculations." 
    1042             raise AttributeError, msg 
     1100            raise AttributeError(msg) 
    10431101 
    10441102        # TODO: Assert other properties 
    10451103 
    10461104        # Reset the view 
    1047         self.model.reset() 
     1105        ##self.model.reset() 
    10481106        # Pass acting as a debugger anchor 
    10491107        pass 
    … …  
    10571115        if not isinstance(model_item, QtGui.QStandardItem): 
    10581116            msg = "Wrong data type returned from calculations." 
    1059             raise AttributeError, msg 
     1117            raise AttributeError(msg) 
    10601118 
    10611119        # Check if there are any other items for this tab 
    10621120        # If so, delete them 
    10631121        # TODO: fix this to resemble GuiUtils.updateModelItemWithPlot 
    1064         #  
    1065         current_tab_name = model_item.text()[:2] 
    1066         for current_index in xrange(self.theory_model.rowCount()): 
    1067             if current_tab_name in self.theory_model.item(current_index).text(): 
    1068                 self.theory_model.removeRow(current_index) 
    1069                 break 
    1070  
    1071         # Reset the view 
    1072         self.model.reset() 
     1122        # 
     1123        ##self.model.beginResetModel() 
     1124        ##current_tab_name = model_item.text()[:2] 
     1125        ##for current_index in range(self.theory_model.rowCount()): 
     1126            #if current_tab_name in self.theory_model.item(current_index).text(): 
     1127            #    return 
     1128        ##        self.theory_model.removeRow(current_index) 
     1129        ##        break 
     1130 
     1131        ### Reset the view 
     1132        ##self.model.endResetModel() 
    10731133 
    10741134        # Reset the view 
    … …  
    10801140 
    10811141if __name__ == "__main__": 
    1082     app = QtGui.QApplication([]) 
     1142    app = QtWidgets.QApplication([]) 
    10831143    dlg = DataExplorerWindow() 
    10841144    dlg.show() 

  • src/sas/qtgui/MainWindow/DataManager.py

    • Property mode changed from 100644 to 100755
    rf4a1433 r0261bc1  
    2424import json 
    2525import time 
    26 from StringIO import StringIO 
     26from io import StringIO 
    2727import numpy as np 
    2828 
    … …  
    6666        _str += "No of states  is %s \n" % str(len(self.stored_data)) 
    6767        n_count = 0 
    68         for  value in self.stored_data.values(): 
     68        for  value in list(self.stored_data.values()): 
    6969            n_count += 1 
    7070            _str += "State No %s \n"  % str(n_count) 
    … …  
    126126        rename data 
    127127        """ 
    128         ## name of the data allow to differentiate data when plotted 
    129         name = GuiUtils.parseName(name=name, expression="_") 
     128        # name of the data allow to differentiate data when plotted 
     129        try: 
     130            name = GuiUtils.parseName(name=name, expression="_") 
     131        except TypeError: 
     132            # bad name sent to rename 
     133            return None 
    130134 
    131135        max_char = name.find("[") 
    … …  
    146150        receive a list of 
    147151        """ 
    148         for id, data in data_list.iteritems(): 
     152        for id, data in data_list.items(): 
    149153            if id  in self.stored_data: 
    150154                msg = "Data manager already stores %s" % str(data.name) 
    … …  
    162166        """ 
    163167        """ 
    164         if prev_data.id not in self.stored_data.keys(): 
     168        if prev_data.id not in list(self.stored_data.keys()): 
    165169            return None, {} 
    166170        data_state = self.stored_data[prev_data.id] 
    167171        self.stored_data[new_data.id]  = data_state.clone() 
    168172        self.stored_data[new_data.id].data = new_data 
    169         if prev_data.id in self.stored_data.keys(): 
     173        if prev_data.id in list(self.stored_data.keys()): 
    170174            del self.stored_data[prev_data.id] 
    171175        return prev_data.id, {new_data.id: self.stored_data[new_data.id]} 
    … …  
    177181        if data_id is None and theory is not None: 
    178182            uid = theory.id 
    179         if uid in self.stored_data.keys(): 
     183        if uid in list(self.stored_data.keys()): 
    180184             data_state = self.stored_data[uid] 
    181185        else: 
    … …  
    207211                if search_id == d_id: 
    208212                    _selected_data[search_id] = data 
    209                 if search_id in theory_list.keys(): 
     213                if search_id in list(theory_list.keys()): 
    210214                     _selected_theory_list[search_id] = theory_list[search_id] 
    211215 
    … …  
    216220        """ 
    217221        """ 
    218         return self.freeze_theory(self.stored_data.keys(), theory_id) 
     222        return self.freeze_theory(list(self.stored_data.keys()), theory_id) 
    219223 
    220224    def freeze_theory(self, data_id, theory_id): 
    … …  
    227231                theory_list = data_state.get_theory() 
    228232                for t_id in theory_id: 
    229                     if t_id in theory_list.keys(): 
     233                    if t_id in list(theory_list.keys()): 
    230234                        theory_data, theory_state = theory_list[t_id] 
    231235                        new_theory = copy.deepcopy(theory_data) 
    … …  
    247251        """ 
    248252        for d_id in data_id: 
    249             if d_id in self.stored_data.keys(): 
     253            if d_id in list(self.stored_data.keys()): 
    250254                data_state = self.stored_data[d_id] 
    251255                if data_state.data.name in self.data_name_dict: 
    … …  
    265269                data_state = self.stored_data[d_id] 
    266270                theory_list = data_state.get_theory() 
    267                 if theory_id in theory_list.keys(): 
     271                if theory_id in list(theory_list.keys()): 
    268272                    del theory_list[theory_id] 
    269273        #del pure theory 
    … …  
    284288        _selected_data = {} 
    285289        for selected_name in name_list: 
    286             for id, data_state in self.stored_data.iteritems(): 
     290            for id, data_state in self.stored_data.items(): 
    287291                if data_state.data.name == selected_name: 
    288292                    _selected_data[id] = data_state.data 
    … …  
    294298        """ 
    295299        for selected_name in name_list: 
    296             for id, data_state in self.stored_data.iteritems(): 
     300            for id, data_state in self.stored_data.items(): 
    297301                if data_state.data.name == selected_name: 
    298302                    del self.stored_data[id] 
    … …  
    303307            # Take the copy of current, possibly shorter stored_data dict 
    304308            stored_data = copy.deepcopy(self.stored_data) 
    305             for idx in stored_data.keys(): 
     309            for idx in list(stored_data.keys()): 
    306310                if str(selected_name) in str(idx): 
    307311                    del self.stored_data[idx] 
    … …  
    313317        _selected_data_state = {} 
    314318        for id in data_id: 
    315             if id in self.stored_data.keys(): 
     319            if id in list(self.stored_data.keys()): 
    316320                _selected_data_state[id] = self.stored_data[id] 
    317321        return _selected_data_state 
    … …  
    396400            class Empty(object): 
    397401                def __init__(self): 
    398                     for key, value in data.iteritems(): 
     402                    for key, value in data.items(): 
    399403                        setattr(self, key, generate(value, level)) 
    400404 
    … …  
    451455                    # if dictionary doesn't have __type__ then it is assumed to be just an ordinary dictionary 
    452456                    o = {} 
    453                     for key, value in data.iteritems(): 
     457                    for key, value in data.items(): 
    454458                        o[key] = generate(value, level) 
    455459                    return o 
    … …  
    463467 
    464468        new_stored_data = {} 
    465         for id, data in json.load(fp).iteritems(): 
     469        for id, data in json.load(fp).items(): 
    466470            try: 
    467471                new_stored_data[id] = generate(data, 0) 

  • src/sas/qtgui/MainWindow/DataState.py

    re7a0b2f rb3e8629  
    3737        _str += "Theories available: %s \n" % len(self.theory_list) 
    3838        if self.theory_list: 
    39             for id, item in self.theory_list.iteritems(): 
     39            for id, item in self.theory_list.items(): 
    4040                theory_data, theory_state = item 
    4141                _str += "Theory name : %s \n" % str(theory_data.name) 
    … …  
    5353        obj.message = self.message 
    5454        obj.id = self.id 
    55         for id, item in self.theory_list.iteritems(): 
     55        for id, item in self.theory_list.items(): 
    5656            theory_data, theory_state = item 
    5757            state = None 
    … …  
    9595        """ 
    9696        self.theory_list[theory_data.id] = [theory_data, theory_state] 
    97         data, state = self.theory_list.values()[0] 
     97        data, state = list(self.theory_list.values())[0] 
    9898        
    9999    def get_theory(self): 

  • src/sas/qtgui/MainWindow/DroppableDataLoadWidget.py

    rcd2cc745 r53c771e  
    11# global 
    2 from PyQt4 import QtGui, QtCore 
     2from PyQt5 import QtCore 
     3from PyQt5 import QtGui 
     4from PyQt5 import QtWidgets 
    35 
    46# UI 
    … …  
    68from sas.qtgui.MainWindow.UI.DataExplorerUI import Ui_DataLoadWidget 
    79 
    8 class DroppableDataLoadWidget(QtGui.QTabWidget, Ui_DataLoadWidget): 
     10class DroppableDataLoadWidget(QtWidgets.QTabWidget, Ui_DataLoadWidget): 
    911    """ 
    1012    Overwrite drag and drop methods in the base class 
    … …  
    5658            filenames=[] 
    5759            for url in event.mimeData().urls(): 
    58                 filenames.append(str(url.toLocalFile())) 
     60                filenames.append(url.toLocalFile()) 
    5961            self.communicator.fileReadSignal.emit(filenames) 
    6062            event.accept() 

  • src/sas/qtgui/MainWindow/GuiManager.py

    ra657de3 r14ec91c5  
    66import webbrowser 
    77 
    8 from PyQt4 import QtCore 
    9 from PyQt4 import QtGui 
    10 from PyQt4 import QtWebKit 
     8from PyQt5.QtWidgets import * 
     9from PyQt5.QtGui import * 
     10from PyQt5.QtCore import Qt, QLocale, QUrl 
    1111 
    1212from twisted.internet import reactor 
    … …  
    3636import sas.qtgui.Perspectives as Perspectives 
    3737from sas.qtgui.Perspectives.Fitting.FittingPerspective import FittingWindow 
    38 from sas.qtgui.MainWindow.DataExplorer import DataExplorerWindow 
    39  
    40 class Acknowledgements(QtGui.QDialog, Ui_Acknowledgements): 
     38from sas.qtgui.MainWindow.DataExplorer import DataExplorerWindow, DEFAULT_PERSPECTIVE 
     39 
     40class Acknowledgements(QDialog, Ui_Acknowledgements): 
    4141    def __init__(self, parent=None): 
    42         QtGui.QDialog.__init__(self, parent) 
     42        QDialog.__init__(self, parent) 
    4343        self.setupUi(self) 
    4444 
    … …  
    5555        self._parent = parent 
    5656 
     57        # Decide on a locale 
     58        QLocale.setDefault(QLocale('en_US')) 
     59 
    5760        # Add signal callbacks 
    5861        self.addCallbacks() 
    … …  
    6568        self.addTriggers() 
    6669 
    67         # Populate menus with dynamic data 
    68         # 
    69         # Analysis/Perspectives - potentially 
    70         # Window/current windows 
    71         # 
    72         # Widgets 
    73         # 
    74         # Current displayed perspective 
     70        # Currently displayed perspective 
    7571        self._current_perspective = None 
    7672 
    77         # Invoke the initial perspective 
    78         self.perspectiveChanged("Fitting") 
    79  
     73        # Populate the main window with stuff 
    8074        self.addWidgets() 
    8175 
    … …  
    9286        self.statusBarSetup() 
    9387 
    94         # Show the Welcome panel 
    95         self.welcomePanel = WelcomePanel() 
    96         self._workspace.workspace.addWindow(self.welcomePanel) 
    97  
    98         # Current help file 
    99         self._helpView = QtWebKit.QWebView() 
    10088        # Needs URL like path, so no path.join() here 
    10189        self._helpLocation = GuiUtils.HELP_DIRECTORY_LOCATION + "/index.html" 
    … …  
    10593                                              "_downloads", 
    10694                                              "Tutorial.pdf")) 
     95 
    10796    def addWidgets(self): 
    10897        """ 
    … …  
    116105        ObjectLibrary.addObject('DataExplorer', self.filesWidget) 
    117106 
    118         self.dockedFilesWidget = QtGui.QDockWidget("Data Explorer", self._workspace) 
     107        self.dockedFilesWidget = QDockWidget("Data Explorer", self._workspace) 
     108        self.dockedFilesWidget.setFloating(False) 
    119109        self.dockedFilesWidget.setWidget(self.filesWidget) 
    120110 
    121111        # Disable maximize/minimize and close buttons 
    122         self.dockedFilesWidget.setFeatures(QtGui.QDockWidget.NoDockWidgetFeatures) 
    123         self._workspace.addDockWidget(QtCore.Qt.LeftDockWidgetArea, 
    124                                       self.dockedFilesWidget) 
     112        self.dockedFilesWidget.setFeatures(QDockWidget.NoDockWidgetFeatures) 
     113 
     114        #self._workspace.workspace.addDockWidget(Qt.LeftDockWidgetArea, self.dockedFilesWidget) 
     115        self._workspace.addDockWidget(Qt.LeftDockWidgetArea, self.dockedFilesWidget) 
    125116 
    126117        # Add the console window as another docked widget 
    127         self.logDockWidget = QtGui.QDockWidget("Log Explorer", self._workspace) 
     118        self.logDockWidget = QDockWidget("Log Explorer", self._workspace) 
    128119        self.logDockWidget.setObjectName("LogDockWidget") 
    129         self.listWidget = QtGui.QTextBrowser() 
     120 
     121        self.listWidget = QTextBrowser() 
    130122        self.logDockWidget.setWidget(self.listWidget) 
    131         self._workspace.addDockWidget(QtCore.Qt.BottomDockWidgetArea, 
    132                                       self.logDockWidget) 
     123        self._workspace.addDockWidget(Qt.BottomDockWidgetArea, self.logDockWidget) 
    133124 
    134125        # Add other, minor widgets 
    135126        self.ackWidget = Acknowledgements() 
    136127        self.aboutWidget = AboutBox() 
     128        self.welcomePanel = WelcomePanel() 
    137129 
    138130        # Add calculators - floating for usability 
    … …  
    152144        Progress bar invisible until explicitly shown 
    153145        """ 
    154         self.progress = QtGui.QProgressBar() 
     146        self.progress = QProgressBar() 
    155147        self._workspace.statusbar.setSizeGripEnabled(False) 
    156148 
    157         self.statusLabel = QtGui.QLabel() 
     149        self.statusLabel = QLabel() 
    158150        self.statusLabel.setText("Welcome to SasView") 
    159151        self._workspace.statusbar.addPermanentWidget(self.statusLabel, 1) 
    … …  
    170162        pass 
    171163 
     164    def showHelp(self, url): 
     165        """ 
     166        Open a local url in the default browser 
     167        """ 
     168        location = GuiUtils.HELP_DIRECTORY_LOCATION + url 
     169        try: 
     170            webbrowser.open('file://' + os.path.realpath(location)) 
     171        except webbrowser.Error as ex: 
     172            logging.warning("Cannot display help. %s" % ex) 
     173 
    172174    def workspace(self): 
    173175        """ 
    … …  
    180182        Respond to change of the perspective signal 
    181183        """ 
     184 
     185        # Save users from themselves... 
     186        #if isinstance(self._current_perspective, Perspectives.PERSPECTIVES[str(perspective_name)]): 
     187        self.setupPerspectiveMenubarOptions(self._current_perspective) 
     188        #    return 
     189 
    182190        # Close the previous perspective 
    183         if self._current_perspective is not None: 
     191        self.clearPerspectiveMenubarOptions(self._current_perspective) 
     192        if self._current_perspective: 
    184193            self._current_perspective.setClosable() 
     194            #self._workspace.workspace.removeSubWindow(self._current_perspective) 
    185195            self._current_perspective.close() 
     196            self._workspace.workspace.removeSubWindow(self._current_perspective) 
    186197        # Default perspective 
    187198        self._current_perspective = Perspectives.PERSPECTIVES[str(perspective_name)](parent=self) 
    188199 
    189         self._workspace.workspace.addWindow(self._current_perspective) 
     200        subwindow = self._workspace.workspace.addSubWindow(self._current_perspective) 
     201 
    190202        # Resize to the workspace height 
    191203        workspace_height = self._workspace.workspace.sizeHint().height() 
    192204        perspective_size = self._current_perspective.sizeHint() 
    193         if workspace_height < perspective_size.height: 
    194             perspective_width = perspective_size.width() 
    195             self._current_perspective.resize(perspective_width, workspace_height-10) 
     205        perspective_width = perspective_size.width() 
     206        self._current_perspective.resize(perspective_width, workspace_height-10) 
     207        # Resize the mdi area to match the widget within 
     208        subwindow.resize(subwindow.minimumSizeHint()) 
     209 
    196210        self._current_perspective.show() 
    197211 
    … …  
    202216        assert isinstance(data, list) 
    203217        if self._current_perspective is not None: 
    204             self._current_perspective.setData(data.values()) 
     218            self._current_perspective.setData(list(data.values())) 
    205219        else: 
    206220            msg = "No perspective is currently active." 
    … …  
    246260        """ 
    247261        if self._current_perspective is not None: 
    248             self._current_perspective.setData(data.values()) 
     262            self._current_perspective.setData(list(data.values())) 
    249263        else: 
    250264            msg = "Guiframe does not have a current perspective" 
    … …  
    257271        # Display confirmation messagebox 
    258272        quit_msg = "Are you sure you want to exit the application?" 
    259         reply = QtGui.QMessageBox.question( 
     273        reply = QMessageBox.question( 
    260274            self._parent, 
    261275            'Information', 
    262276            quit_msg, 
    263             QtGui.QMessageBox.Yes, 
    264             QtGui.QMessageBox.No) 
     277            QMessageBox.Yes, 
     278            QMessageBox.No) 
    265279 
    266280        # Exit if yes 
    267         if reply == QtGui.QMessageBox.Yes: 
     281        if reply == QMessageBox.Yes: 
    268282            reactor.callFromThread(reactor.stop) 
    269283            return True 
    … …  
    289303            version_info = json.loads(content) 
    290304            self.processVersion(version_info) 
    291         except ValueError, ex: 
     305        except ValueError as ex: 
    292306            logging.info("Failed to connect to www.sasview.org:", ex) 
    293307 
    … …  
    308322                self.communicate.statusBarUpdateSignal.emit(msg) 
    309323 
    310             elif cmp(version, LocalConfig.__version__) > 0: 
     324            elif version.__gt__(LocalConfig.__version__): 
    311325                msg = "Version %s is available! " % str(version) 
    312326                if "download_url" in version_info: 
    … …  
    321335        except: 
    322336            msg = "guiframe: could not get latest application" 
    323             msg += " version number\n  %s" % sys.exc_value 
     337            msg += " version number\n  %s" % sys.exc_info()[1] 
    324338            logging.error(msg) 
    325339            msg = "Could not connect to the application server." 
    326340            msg += " Please try again later." 
    327341            self.communicate.statusBarUpdateSignal.emit(msg) 
     342 
     343    def showWelcomeMessage(self): 
     344        """ Show the Welcome panel """ 
     345        self._workspace.workspace.addSubWindow(self.welcomePanel) 
     346        self.welcomePanel.show() 
    328347 
    329348    def addCallbacks(self): 
    … …  
    384403        self._workspace.actionCombine_Batch_Fit.triggered.connect(self.actionCombine_Batch_Fit) 
    385404        self._workspace.actionFit_Options.triggered.connect(self.actionFit_Options) 
     405        self._workspace.actionGPU_Options.triggered.connect(self.actionGPU_Options) 
    386406        self._workspace.actionFit_Results.triggered.connect(self.actionFit_Results) 
    387407        self._workspace.actionChain_Fitting.triggered.connect(self.actionChain_Fitting) 
    … …  
    578598 
    579599        # Add the console window as another docked widget 
    580         self.ipDockWidget = QtGui.QDockWidget("IPython", self._workspace) 
     600        self.ipDockWidget = QDockWidget("IPython", self._workspace) 
    581601        self.ipDockWidget.setObjectName("IPythonDockWidget") 
    582602        self.ipDockWidget.setWidget(terminal) 
    583         self._workspace.addDockWidget(QtCore.Qt.RightDockWidgetArea, 
    584                                       self.ipDockWidget) 
     603        self._workspace.addDockWidget(Qt.RightDockWidgetArea, self.ipDockWidget) 
    585604 
    586605    def actionImage_Viewer(self): 
    … …  
    603622    def actionConstrained_Fit(self): 
    604623        """ 
    605         """ 
    606         print("actionConstrained_Fit TRIGGERED") 
    607         pass 
     624        Add a new Constrained and Simult. Fit page in the fitting perspective. 
     625        """ 
     626        per = self.perspective() 
     627        if not isinstance(per, FittingWindow): 
     628            return 
     629        per.addConstraintTab() 
    608630 
    609631    def actionCombine_Batch_Fit(self): 
    … …  
    620642        pass 
    621643 
     644    def actionGPU_Options(self): 
     645        """ 
     646        Load the OpenCL selection dialog if the fitting perspective is active 
     647        """ 
     648        if hasattr(self._current_perspective, "gpu_options_widget"): 
     649            self._current_perspective.gpu_options_widget.show() 
     650        pass 
     651 
    622652    def actionFit_Results(self): 
    623653        """ 
    … …  
    641671    def actionFitting(self): 
    642672        """ 
    643         """ 
    644         print("actionFitting TRIGGERED") 
    645         pass 
     673        Change to the Fitting perspective 
     674        """ 
     675        self.perspectiveChanged("Fitting") 
    646676 
    647677    def actionInversion(self): 
    648678        """ 
    649         """ 
     679        Change to the Inversion perspective 
     680        """ 
     681        # For now we'll just update the analysis menu status but when the inversion is implemented delete from here 
     682        self.checkAnalysisOption(self._workspace.actionInversion) 
     683        # to here and uncomment the following line 
    650684        self.perspectiveChanged("Inversion") 
    651         pass 
    652685 
    653686    def actionInvariant(self): 
    654687        """ 
    655         """ 
    656         print("actionInvariant TRIGGERED") 
    657         pass 
     688        Change to the Invariant perspective 
     689        """ 
     690        self.perspectiveChanged("Invariant") 
    658691 
    659692    #============ WINDOW ================= 
    … …  
    695728        TODO: use QNetworkAccessManager to assure _helpLocation is valid 
    696729        """ 
    697         self._helpView.load(QtCore.QUrl(self._helpLocation)) 
    698         self._helpView.show() 
     730        self.showHelp(self._helpLocation) 
    699731 
    700732    def actionTutorial(self): 
    … …  
    740772        :param new_datalist_item: 
    741773        """ 
    742         if not isinstance(new_item, QtGui.QStandardItem) or \ 
     774        if not isinstance(new_item, QStandardItem) or \ 
    743775                not isinstance(new_datalist_item, dict): 
    744776            msg = "Wrong data type returned from calculations." 
    745             raise AttributeError, msg 
     777            raise AttributeError(msg) 
    746778 
    747779        self.filesWidget.model.appendRow(new_item) 
    … …  
    754786        if hasattr(self, "filesWidget"): 
    755787            self.filesWidget.displayData(plot) 
     788 
     789    def uncheckAllMenuItems(self, menuObject): 
     790        """ 
     791        Uncheck all options in a given menu 
     792        """ 
     793        menuObjects = menuObject.actions() 
     794 
     795        for menuItem in menuObjects: 
     796            menuItem.setChecked(False) 
     797 
     798    def checkAnalysisOption(self, analysisMenuOption): 
     799        """ 
     800        Unchecks all the items in the analysis menu and checks the item passed 
     801        """ 
     802        self.uncheckAllMenuItems(self._workspace.menuAnalysis) 
     803        analysisMenuOption.setChecked(True) 
     804 
     805    def clearPerspectiveMenubarOptions(self, perspective): 
     806        """ 
     807        When closing a perspective, clears the menu bar 
     808        """ 
     809        for menuItem in self._workspace.menuAnalysis.actions(): 
     810            menuItem.setChecked(False) 
     811 
     812        if isinstance(self._current_perspective, Perspectives.PERSPECTIVES["Fitting"]): 
     813            self._workspace.menubar.removeAction(self._workspace.menuFitting.menuAction()) 
     814 
     815    def setupPerspectiveMenubarOptions(self, perspective): 
     816        """ 
     817        When setting a perspective, sets up the menu bar 
     818        """ 
     819        if isinstance(perspective, Perspectives.PERSPECTIVES["Fitting"]): 
     820            self.checkAnalysisOption(self._workspace.actionFitting) 
     821            # Put the fitting menu back in 
     822            # This is a bit involved but it is needed to preserve the menu ordering 
     823            self._workspace.menubar.removeAction(self._workspace.menuWindow.menuAction()) 
     824            self._workspace.menubar.removeAction(self._workspace.menuHelp.menuAction()) 
     825            self._workspace.menubar.addAction(self._workspace.menuFitting.menuAction()) 
     826            self._workspace.menubar.addAction(self._workspace.menuWindow.menuAction()) 
     827            self._workspace.menubar.addAction(self._workspace.menuHelp.menuAction()) 
     828        elif isinstance(perspective, Perspectives.PERSPECTIVES["Invariant"]): 
     829            self.checkAnalysisOption(self._workspace.actionInvariant) 
     830        # elif isinstance(perspective, Perspectives.PERSPECTIVES["Inversion"]): 
     831        #     self.checkAnalysisOption(self._workspace.actionInversion) 

  • src/sas/qtgui/MainWindow/MainWindow.py

    r2a8bd705 r8353d90  
    11# UNLESS EXEPTIONALLY REQUIRED TRY TO AVOID IMPORTING ANY MODULES HERE 
    22# ESPECIALLY ANYTHING IN SAS, SASMODELS NAMESPACE 
    3 from PyQt4 import QtGui 
     3from PyQt5.QtWidgets import QMainWindow 
     4from PyQt5.QtWidgets import QMdiArea 
     5from PyQt5.QtWidgets import QSplashScreen 
     6from PyQt5.QtWidgets import QApplication 
     7from PyQt5.QtGui import QPixmap 
    48 
    59# Local UI 
    610from sas.qtgui.UI import main_resources_rc 
    7 from UI.MainWindowUI import Ui_MainWindow 
     11from .UI.MainWindowUI import Ui_MainWindow 
    812 
    913# Initialize logging 
    1014import sas.qtgui.Utilities.SasviewLogger 
    1115 
    12 class MainSasViewWindow(QtGui.QMainWindow, Ui_MainWindow): 
     16class MainSasViewWindow(QMainWindow, Ui_MainWindow): 
    1317    # Main window of the application 
    1418    def __init__(self, parent=None): 
    … …  
    1721 
    1822        # define workspace for dialogs. 
    19         self.workspace = QtGui.QWorkspace(self) 
     23        self.workspace = QMdiArea(self) 
    2024        self.setCentralWidget(self.workspace) 
    2125 
    2226        # Create the gui manager 
    23         from GuiManager import GuiManager 
    24         self.guiManager = GuiManager(self) 
     27        from .GuiManager import GuiManager 
     28        try: 
     29            self.guiManager = GuiManager(self) 
     30        except Exception as ex: 
     31            import logging 
     32            logging.error("Application failed with: ", ex) 
     33            print("Application failed with: ", ex) 
    2534 
    2635    def closeEvent(self, event): 
    … …  
    3746    """ 
    3847    # TODO: standardize path to images 
    39     pixmap = QtGui.QPixmap("src/sas/qtgui/images/SVwelcome_mini.png") 
    40     splashScreen = QtGui.QSplashScreen(pixmap) 
     48    pixmap = QPixmap("src/sas/qtgui/images/SVwelcome_mini.png") 
     49    splashScreen = QSplashScreen(pixmap) 
    4150    return splashScreen 
    4251 
    4352def run(): 
    44     app = QtGui.QApplication([]) 
     53    app = QApplication([]) 
    4554 
    4655    # Main must have reference to the splash screen, so making it explicit 
    … …  
    5564    # DO NOT move the following import to the top! 
    5665    # (unless you know what you're doing) 
    57     import qt4reactor 
    58     # Using the Qt4 reactor wrapper from https://github.com/ghtdak/qtreactor 
    59     qt4reactor.install() 
     66    import qt5reactor 
     67    # Using the Qt5 reactor wrapper from https://github.com/ghtdak/qtreactor 
     68    qt5reactor.install() 
    6069 
    6170    # DO NOT move the following import to the top! 
    … …  
    6978    splash.finish(mainwindow) 
    7079 
     80    # Time for the welcome window 
     81    mainwindow.guiManager.showWelcomeMessage() 
     82 
    7183    # No need to .exec_ - the reactor takes care of it. 
    7284    reactor.run() 

  • src/sas/qtgui/MainWindow/UI/DataExplorerUI.ui

    r61a92d4 rc6fb57c  
    499499   </property> 
    500500  </action> 
     501  <action name="actionDelete"> 
     502   <property name="text"> 
     503    <string>Delete</string> 
     504   </property> 
     505  </action> 
    501506 </widget> 
    502507 <resources/> 

  • src/sas/qtgui/MainWindow/UI/MainWindowUI.ui

    rb00414d r1543f0c  
    103103    <addaction name="separator"/> 
    104104    <addaction name="actionFit_Options"/> 
     105    <addaction name="actionGPU_Options"/> 
    105106    <addaction name="actionFit_Results"/> 
    106107    <addaction name="separator"/> 
    … …  
    499500   </property> 
    500501  </action> 
     502  <action name="actionGPU_Options"> 
     503   <property name="text"> 
     504    <string>GPU Options</string> 
     505   </property> 
     506  </action> 
    501507 </widget> 
    502508 <resources/> 

  • src/sas/qtgui/MainWindow/UnitTesting/AboutBoxTest.py

    r464cd07 r53c771e  
    33import webbrowser 
    44 
    5 from PyQt4 import QtGui 
    6 from PyQt4.QtTest import QTest 
    7 from PyQt4 import QtCore 
    8 from mock import MagicMock 
     5from PyQt5 import QtGui, QtWidgets 
     6from PyQt5.QtTest import QTest 
     7from PyQt5 import QtCore 
     8from unittest.mock import MagicMock 
    99 
    1010# set up import paths 
    … …  
    1515import sas.qtgui.Utilities.LocalConfig as LocalConfig 
    1616 
    17 if not QtGui.QApplication.instance(): 
    18     app = QtGui.QApplication(sys.argv) 
     17if not QtWidgets.QApplication.instance(): 
     18    app = QtWidgets.QApplication(sys.argv) 
    1919 
    2020class AboutBoxTest(unittest.TestCase): 
    … …  
    3131    def testDefaults(self): 
    3232        '''Test the GUI in its default state''' 
    33         self.assertIsInstance(self.widget, QtGui.QWidget) 
     33        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    3434        self.assertEqual(self.widget.windowTitle(), "About") 
    3535        self.assertEqual(self.widget.cmdOK.text(), "OK") 
    … …  
    4545        """ 
    4646        version = self.widget.lblVersion 
    47         self.assertIsInstance(version, QtGui.QLabel) 
     47        self.assertIsInstance(version, QtWidgets.QLabel) 
    4848        self.assertEqual(str(version.text()), str(LocalConfig.__version__)) 
    4949 
    … …  
    5353        """ 
    5454        about = self.widget.lblAbout 
    55         self.assertIsInstance(about, QtGui.QLabel) 
     55        self.assertIsInstance(about, QtWidgets.QLabel) 
    5656        # build version 
    5757        self.assertIn(str(LocalConfig.__build__), about.text()) 
    … …  
    8383 
    8484        # Press the buttons 
    85         buttonList = self.widget.findChildren(QtGui.QPushButton) 
     85        buttonList = self.widget.findChildren(QtWidgets.QPushButton) 
    8686        for button in buttonList: 
    8787            QTest.mouseClick(button, QtCore.Qt.LeftButton) 

  • src/sas/qtgui/MainWindow/UnitTesting/DataExplorerTest.py

    rf7d14a1 rc6fb57c  
    22import unittest 
    33 
    4 from PyQt4.QtGui import * 
    5 from PyQt4.QtTest import QTest 
    6 from PyQt4.QtCore import * 
    7 from mock import MagicMock 
    8 from mock import patch 
     4from PyQt5.QtGui import * 
     5from PyQt5.QtWidgets import * 
     6from PyQt5.QtTest import QTest 
     7from PyQt5.QtCore import * 
     8from unittest.mock import MagicMock 
     9from unittest.mock import patch 
    910from mpl_toolkits.mplot3d import Axes3D 
    1011 
    … …  
    2526import sas.qtgui.Plotting.PlotHelper as PlotHelper 
    2627 
    27 if not QApplication.instance(): 
    28     app = QApplication(sys.argv) 
     28#if not QApplication.instance(): 
     29app = QApplication(sys.argv) 
    2930 
    3031class DataExplorerTest(unittest.TestCase): 
    … …  
    3637                return Communicate() 
    3738            def allowBatch(self): 
    38                 return False 
     39                return True 
    3940            def setData(self, data_item=None, is_batch=False): 
    4041                return None 
    … …  
    114115 
    115116        # Return no files. 
    116         QtGui.QFileDialog.getOpenFileNames = MagicMock(return_value=None) 
     117        QFileDialog.getOpenFileNames = MagicMock(return_value=('','')) 
    117118 
    118119        # Click on the Load button 
    … …  
    120121 
    121122        # Test the getOpenFileName() dialog called once 
    122         self.assertTrue(QtGui.QFileDialog.getOpenFileNames.called) 
    123         QtGui.QFileDialog.getOpenFileNames.assert_called_once() 
     123        self.assertTrue(QFileDialog.getOpenFileNames.called) 
     124        QFileDialog.getOpenFileNames.assert_called_once() 
    124125 
    125126        # Make sure the signal has not been emitted 
    … …  
    127128 
    128129        # Now, return a single file 
    129         QtGui.QFileDialog.getOpenFileNames = MagicMock(return_value=filename) 
     130        QFileDialog.getOpenFileNames = MagicMock(return_value=(filename,'')) 
    130131 
    131132        # Click on the Load button 
    132133        QTest.mouseClick(loadButton, Qt.LeftButton) 
    133         QtGui.qApp.processEvents() 
     134        qApp.processEvents() 
    134135 
    135136        # Test the getOpenFileName() dialog called once 
    136         self.assertTrue(QtGui.QFileDialog.getOpenFileNames.called) 
    137         QtGui.QFileDialog.getOpenFileNames.assert_called_once() 
     137        self.assertTrue(QFileDialog.getOpenFileNames.called) 
     138        QFileDialog.getOpenFileNames.assert_called_once() 
    138139 
    139140        # Expected one spy instance 
    … …  
    157158 
    158159        expected_list = [0, 0, 33, 66, -1] 
    159         spied_list = [spy_progress_bar_update.called()[i]['args'][0] for i in xrange(5)] 
     160        spied_list = [spy_progress_bar_update.called()[i]['args'][0] for i in range(5)] 
    160161        self.assertEqual(expected_list, spied_list) 
    161162         
    … …  
    167168 
    168169        # Mock the confirmation dialog with return=No 
    169         QtGui.QMessageBox.question = MagicMock(return_value=QtGui.QMessageBox.No) 
     170        QMessageBox.question = MagicMock(return_value=QMessageBox.No) 
    170171 
    171172        # Populate the model 
    … …  
    180181        item2 = self.form.model.item(1) 
    181182        item3 = self.form.model.item(2) 
    182         self.assertTrue(item1.checkState() == QtCore.Qt.Checked) 
    183         self.assertTrue(item2.checkState() == QtCore.Qt.Checked) 
    184         self.assertTrue(item3.checkState() == QtCore.Qt.Checked) 
     183        self.assertTrue(item1.checkState() == Qt.Checked) 
     184        self.assertTrue(item2.checkState() == Qt.Checked) 
     185        self.assertTrue(item3.checkState() == Qt.Checked) 
    185186 
    186187        # Click on the delete  button 
    … …  
    188189 
    189190        # Test the warning dialog called once 
    190         self.assertTrue(QtGui.QMessageBox.question.called) 
     191        self.assertTrue(QMessageBox.question.called) 
    191192 
    192193        # Assure the model still contains the items 
    … …  
    194195 
    195196        # Now, mock the confirmation dialog with return=Yes 
    196         QtGui.QMessageBox.question = MagicMock(return_value=QtGui.QMessageBox.Yes) 
     197        QMessageBox.question = MagicMock(return_value=QMessageBox.Yes) 
    197198 
    198199        # Click on the delete  button 
    … …  
    200201 
    201202        # Test the warning dialog called once 
    202         self.assertTrue(QtGui.QMessageBox.question.called) 
     203        self.assertTrue(QMessageBox.question.called) 
    203204 
    204205        # Assure the model contains no items 
    … …  
    215216 
    216217        # Mock the confirmation dialog with return=No 
    217         QtGui.QMessageBox.question = MagicMock(return_value=QtGui.QMessageBox.No) 
     218        QMessageBox.question = MagicMock(return_value=QMessageBox.No) 
    218219 
    219220        # Populate the model 
    220         item1 = QtGui.QStandardItem(True) 
     221        item1 = QStandardItem(True) 
    221222        item1.setCheckable(True) 
    222         item1.setCheckState(QtCore.Qt.Checked) 
     223        item1.setCheckState(Qt.Checked) 
    223224        item1.setText("item 1") 
    224225        self.form.theory_model.appendRow(item1) 
    225         item2 = QtGui.QStandardItem(True) 
     226        item2 = QStandardItem(True) 
    226227        item2.setCheckable(True) 
    227         item2.setCheckState(QtCore.Qt.Unchecked) 
     228        item2.setCheckState(Qt.Unchecked) 
    228229        item2.setText("item 2") 
    229230        self.form.theory_model.appendRow(item2) 
    … …  
    233234 
    234235        # Assure the checkboxes are on 
    235         self.assertTrue(item1.checkState() == QtCore.Qt.Checked) 
    236         self.assertTrue(item2.checkState() == QtCore.Qt.Unchecked) 
     236        self.assertTrue(item1.checkState() == Qt.Checked) 
     237        self.assertTrue(item2.checkState() == Qt.Unchecked) 
    237238 
    238239        # Click on the delete  button 
    … …  
    240241 
    241242        # Test the warning dialog called once 
    242         self.assertTrue(QtGui.QMessageBox.question.called) 
     243        self.assertTrue(QMessageBox.question.called) 
    243244 
    244245        # Assure the model still contains the items 
    … …  
    246247 
    247248        # Now, mock the confirmation dialog with return=Yes 
    248         QtGui.QMessageBox.question = MagicMock(return_value=QtGui.QMessageBox.Yes) 
     249        QMessageBox.question = MagicMock(return_value=QMessageBox.Yes) 
    249250 
    250251        # Click on the delete  button 
    … …  
    252253 
    253254        # Test the warning dialog called once 
    254         self.assertTrue(QtGui.QMessageBox.question.called) 
     255        self.assertTrue(QMessageBox.question.called) 
    255256 
    256257        # Assure the model contains 1 item 
    … …  
    258259 
    259260        # Set the remaining item to checked 
    260         self.form.theory_model.item(0).setCheckState(QtCore.Qt.Checked) 
     261        self.form.theory_model.item(0).setCheckState(Qt.Checked) 
    261262 
    262263        # Click on the delete button again 
    … …  
    306307 
    307308        # Mock the warning message 
    308         QtGui.QMessageBox = MagicMock() 
     309        QMessageBox = MagicMock() 
    309310 
    310311        # Click on the button 
    … …  
    312313 
    313314        # Assure the message box popped up 
    314         QtGui.QMessageBox.assert_called_once() 
     315        QMessageBox.assert_called_once() 
    315316 
    316317    def testDataSelection(self): 
    … …  
    328329        item1D = self.form.model.item(0) 
    329330        item2D = self.form.model.item(1) 
    330         self.assertTrue(item1D.checkState() == QtCore.Qt.Unchecked) 
    331         self.assertTrue(item2D.checkState() == QtCore.Qt.Unchecked)         
     331        self.assertTrue(item1D.checkState() == Qt.Unchecked) 
     332        self.assertTrue(item2D.checkState() == Qt.Unchecked)         
    332333 
    333334        # Select all data 
    … …  
    335336 
    336337        # Test the current selection 
    337         self.assertTrue(item1D.checkState() == QtCore.Qt.Checked) 
    338         self.assertTrue(item2D.checkState() == QtCore.Qt.Checked)         
     338        self.assertTrue(item1D.checkState() == Qt.Checked) 
     339        self.assertTrue(item2D.checkState() == Qt.Checked)         
    339340 
    340341        # select 1d data 
    … …  
    342343 
    343344        # Test the current selection 
    344         self.assertTrue(item1D.checkState() == QtCore.Qt.Checked) 
    345         self.assertTrue(item2D.checkState() == QtCore.Qt.Unchecked)         
     345        self.assertTrue(item1D.checkState() == Qt.Checked) 
     346        self.assertTrue(item2D.checkState() == Qt.Unchecked)         
    346347 
    347348        # unselect 1d data 
    … …  
    349350 
    350351        # Test the current selection 
    351         self.assertTrue(item1D.checkState() == QtCore.Qt.Unchecked) 
    352         self.assertTrue(item2D.checkState() == QtCore.Qt.Unchecked)         
     352        self.assertTrue(item1D.checkState() == Qt.Unchecked) 
     353        self.assertTrue(item2D.checkState() == Qt.Unchecked)         
    353354 
    354355        # select 2d data 
    … …  
    356357 
    357358        # Test the current selection 
    358         self.assertTrue(item1D.checkState() == QtCore.Qt.Unchecked) 
    359         self.assertTrue(item2D.checkState() == QtCore.Qt.Checked)         
     359        self.assertTrue(item1D.checkState() == Qt.Unchecked) 
     360        self.assertTrue(item2D.checkState() == Qt.Checked)         
    360361 
    361362        # unselect 2d data 
    … …  
    363364 
    364365        # Test the current selection 
    365         self.assertTrue(item1D.checkState() == QtCore.Qt.Unchecked) 
    366         self.assertTrue(item2D.checkState() == QtCore.Qt.Unchecked)         
     366        self.assertTrue(item1D.checkState() == Qt.Unchecked) 
     367        self.assertTrue(item2D.checkState() == Qt.Unchecked)         
    367368 
    368369        # choose impossible index and assure the code raises 
    … …  
    382383        """ 
    383384        # Create an item with several branches 
    384         item1 = QtGui.QStandardItem() 
    385         item2 = QtGui.QStandardItem() 
    386         item3 = QtGui.QStandardItem() 
    387         item4 = QtGui.QStandardItem() 
    388         item5 = QtGui.QStandardItem() 
    389         item6 = QtGui.QStandardItem() 
     385        item1 = QStandardItem() 
     386        item2 = QStandardItem() 
     387        item3 = QStandardItem() 
     388        item4 = QStandardItem() 
     389        item5 = QStandardItem() 
     390        item6 = QStandardItem() 
    390391 
    391392        item4.appendRow(item5) 
    … …  
    429430        # The 0th item header should be the name of the file 
    430431        model_item = self.form.model.index(0,0) 
    431         model_name = str(self.form.model.data(model_item).toString()) 
     432        model_name = self.form.model.data(model_item) 
    432433        self.assertEqual(model_name, filename[0]) 
    433434 
    … …  
    442443        # Click on the Help button 
    443444        QTest.mouseClick(button1, Qt.LeftButton) 
    444         QtGui.qApp.processEvents() 
     445        qApp.processEvents() 
    445446 
    446447        # Check the browser 
    … …  
    451452        # Click on the Help_2 button 
    452453        QTest.mouseClick(button2, Qt.LeftButton) 
    453         QtGui.qApp.processEvents() 
     454        qApp.processEvents() 
    454455        # Check the browser 
    455456        self.assertIn(partial_url, str(self.form._helpView.url())) 
    … …  
    503504        # We don't know the data ID, so need to iterate over dict 
    504505        data_dict = spy_data_received.called()[0]['args'][0] 
    505         for data_key, data_value in data_dict.iteritems(): 
     506        for data_key, data_value in data_dict.items(): 
    506507            self.assertIsInstance(data_value, Data1D) 
    507508 
    … …  
    593594        p_file="cyl_400_20.txt" 
    594595        output_object = loader.load(p_file) 
    595         output_item = QtGui.QStandardItem() 
     596        output_item = QStandardItem() 
    596597        new_data = [(output_item, manager.create_gui_data(output_object[0], p_file))] 
    597598 
    … …  
    641642        Assure the model update is correct 
    642643        """ 
    643         good_item = QtGui.QStandardItem() 
     644        good_item = QStandardItem() 
    644645        bad_item = "I'm so bad" 
    645646 
    … …  
    666667 
    667668        # Pick up the treeview index corresponding to that file 
    668         index = self.form.treeView.indexAt(QtCore.QPoint(5,5)) 
     669        index = self.form.treeView.indexAt(QPoint(5,5)) 
    669670        self.form.show() 
    670671 
    … …  
    682683        # Instead, send the signal directly 
    683684        self.form.treeView.customContextMenuRequested.emit(rect) 
    684  
    685         # app.exec_() # debug 
    686685 
    687686        # See that the menu has been shown 
    … …  
    804803        pass 
    805804 
     805    def notestDeleteItem(self): 
     806        """ 
     807        Delete selected item from data explorer 
     808        """ 
     809 
     810        # Mock the confirmation dialog with return=No 
     811        QMessageBox.question = MagicMock(return_value=QMessageBox.No) 
     812 
     813        # Populate the model 
     814        filename = ["cyl_400_20.txt", "cyl_400_20.txt", "cyl_400_20.txt"] 
     815        self.form.readData(filename) 
     816 
     817        # Assure the model contains three items 
     818        self.assertEqual(self.form.model.rowCount(), 3) 
     819 
     820        # Add an item to first file item 
     821        item1 = QtGui.QStandardItem("test") 
     822        item1.setCheckable(True) 
     823        self.form.model.item(0).appendRow(item1) 
     824 
     825        # Check the new item is in 
     826 
     827        self.assertTrue(self.form.model.item(0).hasChildren()) 
     828 
     829        #select_item = self.form.model.item(0).child(3) 
     830        select_item = self.form.model.item(0) 
     831        select_index = self.form.model.indexFromItem(select_item) 
     832 
     833        # Open up items 
     834        self.form.current_view.expandAll() 
     835 
     836        # Select the newly created item 
     837        self.form.current_view.selectionModel().select(select_index, QtCore.QItemSelectionModel.Rows) 
     838 
     839        # Attempt at deleting 
     840        self.form.deleteItem() 
     841 
     842        # Test the warning dialog called once 
     843        self.assertTrue(QMessageBox.question.called) 
     844 
     845        # Assure the model still contains the items 
     846        self.assertEqual(self.form.model.rowCount(), 3) 
     847 
     848        # Now, mock the confirmation dialog with return=Yes 
     849        QMessageBox.question = MagicMock(return_value=QMessageBox.Yes) 
     850 
     851        # Select the newly created item 
     852        self.form.current_view.selectionModel().select(select_index, QtCore.QItemSelectionModel.Rows) 
     853        # delete it. now for good 
     854        self.form.deleteItem() 
     855 
     856        # Test the warning dialog called once 
     857        self.assertTrue(QMessageBox.question.called) 
     858 
     859        # Assure the model contains no items 
     860        self.assertEqual(self.form.model.rowCount(), 3) 
     861 
    806862 
    807863if __name__ == "__main__": 

  • src/sas/qtgui/MainWindow/UnitTesting/DroppableDataLoadWidgetTest.py

    r464cd07 r53c771e  
    22import unittest 
    33 
    4 from PyQt4.QtGui import QApplication 
    5 from PyQt4.QtTest import QTest 
    6 from PyQt4 import QtCore 
     4from PyQt5.QtWidgets import QApplication 
     5from PyQt5.QtTest import QTest 
     6from PyQt5 import QtCore 
    77 
    88# set up import paths 
    … …  
    6262 
    6363        drop_event = QtGui.QDropEvent(QtCore.QPoint(0,0), 
    64                                            QtCore.Qt.CopyAction, 
    65                                            self.mime_data, 
    66                                            QtCore.Qt.LeftButton, 
    67                                            QtCore.Qt.NoModifier) 
     64                                    QtCore.Qt.CopyAction, 
     65                                    self.mime_data, 
     66                                    QtCore.Qt.LeftButton, 
     67                                    QtCore.Qt.NoModifier) 
    6868 
    6969        self.form.dropEvent(drop_event) 
    70         QtGui.qApp.processEvents() 
     70        QApplication.processEvents() 
    7171        self.assertEqual(spy_file_read.count(), 1) 
    7272        self.assertIn(self.testfile, str(spy_file_read.signal(index=0))) 

  • src/sas/qtgui/MainWindow/UnitTesting/GuiManagerTest.py

    r8222f171 r725d9c06  
    55import logging 
    66 
    7 from PyQt4.QtGui import * 
    8 from PyQt4.QtTest import QTest 
    9 from PyQt4.QtCore import * 
    10 from PyQt4.QtWebKit import * 
    11 from mock import MagicMock 
     7from PyQt5.QtGui import * 
     8from PyQt5.QtWidgets import * 
     9from PyQt5.QtTest import QTest 
     10from PyQt5.QtCore import * 
     11from unittest.mock import MagicMock 
    1212 
    1313# set up import paths 
    … …  
    3737         
    3838                # define workspace for dialogs. 
    39                 self.workspace = QWorkspace(self) 
     39                self.workspace = QMdiArea(self) 
    4040                self.setCentralWidget(self.workspace) 
    4141 
    … …  
    7474        # We are in the MainWindow scope, so simple 'print' will work 
    7575        message = "from stdout" 
    76         print message 
     76        print(message) 
    7777        self.assertIn(message, self.manager.logDockWidget.widget().toPlainText()) 
    7878 
    … …  
    162162        """ 
    163163        # 1. version = 0.0.0 
    164         version_info = {u'version' : u'0.0.0'} 
     164        version_info = {'version' : '0.0.0'} 
    165165        spy_status_update = QtSignalSpy(self.manager, self.manager.communicate.statusBarUpdateSignal) 
    166166 
    … …  
    172172 
    173173        # 2. version < LocalConfig.__version__ 
    174         version_info = {u'version' : u'0.0.1'} 
     174        version_info = {'version' : '0.0.1'} 
    175175        spy_status_update = QtSignalSpy(self.manager, self.manager.communicate.statusBarUpdateSignal) 
    176176 
    … …  
    182182 
    183183        # 3. version > LocalConfig.__version__ 
    184         version_info = {u'version' : u'999.0.0'} 
     184        version_info = {'version' : '999.0.0'} 
    185185        spy_status_update = QtSignalSpy(self.manager, self.manager.communicate.statusBarUpdateSignal) 
    186186        webbrowser.open = MagicMock() 
    … …  
    221221        """ 
    222222        # Mock the system file open method 
    223         QFileDialog.getOpenFileNames = MagicMock(return_value=None) 
     223        QFileDialog.getOpenFileNames = MagicMock(return_value=('','')) 
    224224 
    225225        # invoke the action 
    … …  
    234234        """ 
    235235        # Mock the system file open method 
    236         QFileDialog.getExistingDirectory = MagicMock(return_value=None) 
     236        QFileDialog.getExistingDirectory = MagicMock(return_value=('','')) 
    237237 
    238238        # invoke the action 
    … …  
    270270 
    271271    #### HELP #### 
     272    # test when PyQt5 works with html 
    272273    def testActionDocumentation(self): 
    273274        """ 
    274275        Menu Help/Documentation 
    275276        """ 
    276         #Mock the QWebView method 
    277         QWebView.show = MagicMock() 
    278  
    279         # Assure the filename is correct 
    280         self.assertIn("index.html", self.manager._helpLocation) 
     277        webbrowser.open = MagicMock() 
    281278 
    282279        # Invoke the action 
    283280        self.manager.actionDocumentation() 
    284281 
    285         # Check if show() got called 
    286         self.assertTrue(QWebView.show.called) 
     282        # see that webbrowser open was attempted 
     283        webbrowser.open.assert_called_once() 
     284 
    287285 
    288286    def skip_testActionTutorial(self): 

  • src/sas/qtgui/MainWindow/UnitTesting/MainWindowTest.py

    r464cd07 r8353d90  
    11import sys 
    22import unittest 
     3import logging 
    34 
    4 from PyQt4 import QtGui 
    5 from PyQt4 import QtTest 
    6 from PyQt4 import QtCore 
    7 from mock import MagicMock 
     5from PyQt5 import QtGui, QtWidgets 
     6from PyQt5 import QtTest 
     7from PyQt5 import QtCore 
     8from unittest.mock import MagicMock 
    89 
    910# set up import paths 
    … …  
    1314from sas.qtgui.MainWindow.MainWindow import MainSasViewWindow 
    1415from sas.qtgui.MainWindow.MainWindow import SplashScreen 
     16from sas.qtgui.MainWindow.GuiManager import GuiManager 
     17from sas.qtgui.Perspectives.Fitting import FittingPerspective 
    1518 
    16 if not QtGui.QApplication.instance(): 
    17     app = QtGui.QApplication(sys.argv) 
     19if not QtWidgets.QApplication.instance(): 
     20    app = QtWidgets.QApplication(sys.argv) 
    1821 
    1922class MainWindowTest(unittest.TestCase): 
    … …  
    3033    def testDefaults(self): 
    3134        """Test the GUI in its default state""" 
    32         self.assertIsInstance(self.widget, QtGui.QMainWindow) 
    33         self.assertIsInstance(self.widget.centralWidget(), QtGui.QWorkspace) 
     35        self.assertIsInstance(self.widget, QtWidgets.QMainWindow) 
     36        self.assertIsInstance(self.widget.centralWidget(), QtWidgets.QMdiArea) 
    3437         
    3538    def testSplashScreen(self): 
    3639        """ Test the splash screen """ 
    3740        splash = SplashScreen() 
    38         self.assertIsInstance(splash, QtGui.QSplashScreen) 
     41        self.assertIsInstance(splash, QtWidgets.QSplashScreen) 
     42 
     43    def testWidgets(self): 
     44        """ Test enablement/disablement of widgets """ 
     45        # Open the main window 
     46        tmp_main = MainSasViewWindow(None) 
     47        tmp_main.showMaximized() 
     48        # See that only one subwindow is up 
     49        self.assertEqual(len(tmp_main.workspace.subWindowList()), 1) 
     50        # and that the subwindow is the fitting perspective 
     51        self.assertIsInstance(tmp_main.workspace.subWindowList()[0].widget(), 
     52                              FittingPerspective.FittingWindow) 
     53        # Show the message widget 
     54        tmp_main.guiManager.showWelcomeMessage() 
     55        # Assure it is visible and a part of the MdiArea 
     56        self.assertTrue(tmp_main.guiManager.welcomePanel.isVisible()) 
     57        self.assertEqual(len(tmp_main.workspace.subWindowList()), 2) 
     58 
     59        tmp_main.close() 
    3960 
    4061    def testExit(self): 
    … …  
    4465        # Must mask sys.exit, otherwise the whole testing process stops. 
    4566        sys.exit = MagicMock() 
    46         QtGui.QMessageBox.question = MagicMock(return_value=QtGui.QMessageBox.Yes) 
     67        QtWidgets.QMessageBox.question = MagicMock(return_value=QtWidgets.QMessageBox.Yes) 
    4768 
    4869        # Open, then close the main window 
    … …  
    5172 
    5273        # See that the MessageBox method got called 
    53         self.assertTrue(QtGui.QMessageBox.question.called) 
     74        self.assertTrue(QtWidgets.QMessageBox.question.called) 
    5475        
    5576if __name__ == "__main__": 

  • src/sas/qtgui/MainWindow/UnitTesting/WelcomePanelTest.py

    r464cd07 r53c771e  
    22import unittest 
    33 
    4 from PyQt4 import QtGui 
     4from PyQt5 import QtGui, QtWidgets 
    55 
    66# set up import paths 
    … …  
    1010from sas.qtgui.MainWindow.WelcomePanel import WelcomePanel 
    1111 
    12 if not QtGui.QApplication.instance(): 
    13     app = QtGui.QApplication(sys.argv) 
     12if not QtWidgets.QApplication.instance(): 
     13    app = QtWidgets.QApplication(sys.argv) 
    1414 
    1515class WelcomePanelTest(unittest.TestCase): 
    … …  
    2727    def testDefaults(self): 
    2828        '''Test the GUI in its default state''' 
    29         self.assertIsInstance(self.widget, QtGui.QDialog) 
     29        self.assertIsInstance(self.widget, QtWidgets.QDialog) 
    3030        self.assertEqual(self.widget.windowTitle(), "Welcome") 
    3131         
    … …  
    3333        '''Test the version string''' 
    3434        version = self.widget.lblVersion 
    35         self.assertIsInstance(version, QtGui.QLabel) 
     35        self.assertIsInstance(version, QtWidgets.QLabel) 
    3636 
    3737        self.assertIn("SasView", version.text()) 

  • src/sas/qtgui/MainWindow/WelcomePanel.py

    rcd2cc745 r4992ff2  
    22import sys 
    33import os 
    4 from PyQt4 import QtCore 
    5 from PyQt4 import QtGui 
    6 from PyQt4 import QtWebKit 
     4 
     5from PyQt5 import QtWidgets 
    76 
    87import sas.sasview 
    … …  
    1312from sas.qtgui.MainWindow.UI.WelcomePanelUI import Ui_WelcomePanelUI 
    1413 
    15 class WelcomePanel(QtGui.QDialog, Ui_WelcomePanelUI): 
     14class WelcomePanel(QtWidgets.QDialog, Ui_WelcomePanelUI): 
    1615    def __init__(self, parent=None): 
    1716        super(WelcomePanel, self).__init__(parent) 

  • src/sas/qtgui/Perspectives/Fitting/FitThread.py

    • Property mode changed from 100755 to 100644
    ree18d33 r235d766  
    1414 
    1515def map_apply(arguments): 
    16     return apply(arguments[0], arguments[1:]) 
     16    return arguments[0](*arguments[1:]) 
    1717 
    1818class FitThread(CalcThread): 
    … …  
    5555        except KeyboardInterrupt: 
    5656            msg = "Fitting: terminated by the user." 
    57             raise KeyboardInterrupt, msg 
     57            raise KeyboardInterrupt(msg) 
    5858 
    5959    def compute(self): 
    … …  
    7171            list_q = [None]*fitter_size 
    7272 
    73             inputs = zip(list_map_get_attr, self.fitter, list_fit_function, 
     73            inputs = list(zip(list_map_get_attr, self.fitter, list_fit_function, 
    7474                         list_q, list_q, list_handler, list_curr_thread, 
    75                          list_reset_flag) 
    76             result = map(map_apply, inputs) 
     75                         list_reset_flag)) 
     76            result = list(map(map_apply, inputs)) 
    7777            results = (result, time.time()-self.starttime) 
    7878            if self.handler: 
    … …  
    8181                return (results) 
    8282 
    83         except KeyboardInterrupt, msg: 
     83        except KeyboardInterrupt as msg: 
    8484            # Thread was interrupted, just proceed and re-raise. 
    8585            # Real code should not print, but this is an example... 
    … …  
    9595            # print "ERROR IN FIT THREAD: ", traceback.format_exc() 
    9696            if self.handler is not None: 
    97                 self.handler.error(msg=traceback.format_exc()) 
     97                self.handler.error(msg=str(ex)) 
     98                self.completefn(None) 
     99            else: 
     100                return(None) 
    98101 
    99102 

  • src/sas/qtgui/Perspectives/Fitting/FittingLogic.py

    ree18d33 rb3e8629  
    196196                msg = "Unable to find min/max/length of \n data named %s" % \ 
    197197                            self.data.filename 
    198                 raise ValueError, msg 
     198                raise ValueError(msg) 
    199199 
    200200        else: 
    … …  
    206206                msg = "Unable to find min/max of \n data named %s" % \ 
    207207                            self.data.filename 
    208                 raise ValueError, msg 
     208                raise ValueError(msg) 
    209209            qmax = np.sqrt(x * x + y * y) 
    210210            npts = len(data.data) 

  • src/sas/qtgui/Perspectives/Fitting/FittingOptions.py

    • Property mode changed from 100755 to 100644
    r377ade1 re90988c  
    33import os 
    44import types 
    5  
    6 from PyQt4 import QtCore 
    7 from PyQt4 import QtGui 
    8 from PyQt4 import QtWebKit 
     5import webbrowser 
     6 
     7from PyQt5 import QtCore 
     8from PyQt5 import QtGui 
     9from PyQt5 import QtWidgets 
    910 
    1011from sas.qtgui.UI import images_rc 
    … …  
    2122 
    2223 
    23 class FittingOptions(QtGui.QDialog, Ui_FittingOptions): 
     24class FittingOptions(QtWidgets.QDialog, Ui_FittingOptions): 
    2425    """ 
    2526    Hard-coded version of the fit options dialog available from BUMPS. 
    … …  
    5253 
    5354        # Handle the Apply button click 
    54         self.buttonBox.button(QtGui.QDialogButtonBox.Ok).clicked.connect(self.onApply) 
     55        self.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).clicked.connect(self.onApply) 
    5556        # handle the Help button click 
    56         self.buttonBox.button(QtGui.QDialogButtonBox.Help).clicked.connect(self.onHelp) 
     57        self.buttonBox.button(QtWidgets.QDialogButtonBox.Help).clicked.connect(self.onHelp) 
    5758 
    5859        # Handle the combo box changes 
    … …  
    7172 
    7273        # OK has to be initialized to True, after initial validator setup 
    73         self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(True) 
    74  
    75         # Display HTML content 
    76         self.helpView = QtWebKit.QWebView() 
     74        self.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).setEnabled(True) 
    7775 
    7876    def assignValidators(self): 
    … …  
    8078        Use options.FIT_FIELDS to assert which line edit gets what validator 
    8179        """ 
    82         for option in bumps.options.FIT_FIELDS.iterkeys(): 
     80        for option in bumps.options.FIT_FIELDS.keys(): 
    8381            (f_name, f_type) = bumps.options.FIT_FIELDS[option] 
    8482            validator = None 
    … …  
    8684                validator = QtGui.QIntValidator() 
    8785                validator.setBottom(0) 
    88             elif f_type == types.FloatType: 
    89                 validator = QtGui.QDoubleValidator() 
     86            elif f_type == float: 
     87                validator = GuiUtils.DoubleValidator() 
    9088                validator.setBottom(0) 
    9189            else: 
    … …  
    104102        if state == QtGui.QValidator.Acceptable: 
    105103            color = '' # default 
    106             self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(True) 
     104            self.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).setEnabled(True) 
    107105        else: 
    108106            color = '#fff79a' # yellow 
    109             self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(False) 
     107            self.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).setEnabled(False) 
    110108 
    111109        sender.setStyleSheet('QLineEdit { background-color: %s }' % color) 
    … …  
    134132 
    135133        # OK has to be reinitialized to True 
    136         self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(True) 
     134        self.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).setEnabled(True) 
    137135 
    138136    def onApply(self): 
    … …  
    148146            """ 
    149147            widget = self.widgetFromOption(option) 
    150             new_value = widget.currentText() if isinstance(widget, QtGui.QComboBox) \ 
     148            new_value = widget.currentText() if isinstance(widget, QtWidgets.QComboBox) \ 
    151149                else float(widget.text()) 
    152150            self.config.values[self.current_fitter_id][option] = new_value 
    153151 
    154152        # Update the BUMPS singleton 
    155         [bumpsUpdate(o) for o in self.config.values[self.current_fitter_id].iterkeys()] 
     153        [bumpsUpdate(o) for o in self.config.values[self.current_fitter_id].keys()] 
    156154 
    157155    def onHelp(self): 
    … …  
    159157        Show the "Fitting options" section of help 
    160158        """ 
    161         tree_location = GuiUtils.HELP_DIRECTORY_LOCATION + "/user/sasgui/perspectives/fitting/" 
     159        tree_location = GuiUtils.HELP_DIRECTORY_LOCATION 
     160        tree_location += "/user/sasgui/perspectives/fitting/" 
    162161 
    163162        # Actual file anchor will depend on the combo box index 
    … …  
    166165        helpfile = "optimizer.html#fit-" + self.current_fitter_id  
    167166        help_location = tree_location + helpfile 
    168         self.helpView.load(QtCore.QUrl(help_location)) 
    169         self.helpView.show() 
     167        webbrowser.open('file://' + os.path.realpath(help_location)) 
    170168 
    171169    def widgetFromOption(self, option_id, current_fitter=None): 
    … …  
    175173        if current_fitter is None: 
    176174            current_fitter = self.current_fitter_id 
    177         if option_id not in bumps.options.FIT_FIELDS.keys(): return None 
     175        if option_id not in list(bumps.options.FIT_FIELDS.keys()): return None 
    178176        option = option_id + '_' + current_fitter 
    179177        if not hasattr(self, option): return None 
    … …  
    193191        """ 
    194192        options = self.config.values[fitter_id] 
    195         for option in options.iterkeys(): 
     193        for option in options.keys(): 
    196194            # Find the widget name of the option 
    197195            # e.g. 'samples' for 'dream' is 'self.samples_dream' 

  • src/sas/qtgui/Perspectives/Fitting/FittingPerspective.py

    r377ade1 r14ec91c5  
    11import numpy 
    22 
    3 from PyQt4 import QtCore 
    4 from PyQt4 import QtGui 
     3from PyQt5 import QtCore 
     4from PyQt5 import QtGui 
     5from PyQt5 import QtWidgets 
    56 
    67from bumps import options 
    … …  
    1011 
    1112from sas.qtgui.Perspectives.Fitting.FittingWidget import FittingWidget 
     13from sas.qtgui.Perspectives.Fitting.ConstraintWidget import ConstraintWidget 
    1214from sas.qtgui.Perspectives.Fitting.FittingOptions import FittingOptions 
    13 from sas.qtgui.Perspectives.Fitting import ModelUtilities 
    14  
    15 class FittingWindow(QtGui.QTabWidget): 
     15from sas.qtgui.Perspectives.Fitting.GPUOptions import GPUOptions 
     16 
     17class FittingWindow(QtWidgets.QTabWidget): 
    1618    """ 
    1719    """ 
     20    tabsModifiedSignal = QtCore.pyqtSignal() 
     21    fittingStartedSignal = QtCore.pyqtSignal(list) 
     22    fittingStoppedSignal = QtCore.pyqtSignal(list) 
     23 
    1824    name = "Fitting" # For displaying in the combo box in DataExplorer 
    1925    def __init__(self, parent=None, data=None): 
     26 
    2027        super(FittingWindow, self).__init__() 
    2128 
    … …  
    3542        self.optimizer = 'Levenberg-Marquardt' 
    3643 
    37         # Dataset inde -> Fitting tab mapping 
     44        # Dataset index -> Fitting tab mapping 
    3845        self.dataToFitTab = {} 
    3946 
    4047        # The tabs need to be closeable 
    4148        self.setTabsClosable(True) 
     49 
     50        # The tabs need to be movabe 
     51        self.setMovable(True) 
    4252 
    4353        self.communicate = self.parent.communicator() 
    … …  
    4959        self.tabCloseRequested.connect(self.tabCloses) 
    5060        self.communicate.dataDeletedSignal.connect(self.dataDeleted) 
     61        self.fittingStartedSignal.connect(self.onFittingStarted) 
     62        self.fittingStoppedSignal.connect(self.onFittingStopped) 
    5163 
    5264        # Perspective window not allowed to close by default 
    … …  
    6173        self.fit_options_widget.fit_option_changed.connect(self.onFittingOptionsChange) 
    6274 
    63         self.menu_manager = ModelUtilities.ModelManager() 
    64         # TODO: reuse these in FittingWidget properly 
    65         self.model_list_box = self.menu_manager.get_model_list() 
    66         self.model_dictionary = self.menu_manager.get_model_dictionary() 
    67  
    68         #self.setWindowTitle('Fit panel - Active Fitting Optimizer: %s' % self.optimizer) 
     75        # GPU Options 
     76        self.gpu_options_widget = GPUOptions(self) 
     77 
    6978        self.updateWindowTitle() 
    7079 
    … …  
    7988    def setClosable(self, value=True): 
    8089        """ 
    81         Allow outsiders close this widget 
     90        Allow outsiders to close this widget 
    8291        """ 
    8392        assert isinstance(value, bool) 
    … …  
    9099        """ 
    91100        # Invoke fit page events 
    92         for tab in self.tabs: 
    93             tab.close() 
    94101        if self._allow_close: 
    95102            # reset the closability flag 
    96103            self.setClosable(value=False) 
     104            # Tell the MdiArea to close the container 
     105            self.parentWidget().close() 
    97106            event.accept() 
    98107        else: 
    … …  
    108117        tab.is_batch_fitting = is_batch 
    109118        # Add this tab to the object library so it can be retrieved by scripting/jupyter 
    110         tab_name = self.tabName(is_batch=is_batch) 
     119        tab_name = self.getTabName(is_batch=is_batch) 
    111120        ObjectLibrary.addObject(tab_name, tab) 
    112121        self.tabs.append(tab) 
    … …  
    115124        self.maxIndex += 1 
    116125        self.addTab(tab, tab_name) 
     126        self.tabsModifiedSignal.emit() 
     127 
     128    def addConstraintTab(self): 
     129        """ 
     130        Add a new C&S fitting tab 
     131        """ 
     132        tabs = [isinstance(tab, ConstraintWidget) for tab in self.tabs] 
     133        if any(tabs): 
     134            # We already have a C&S tab: show it 
     135            self.setCurrentIndex(tabs.index(True)) 
     136            return 
     137        tab     = ConstraintWidget(parent=self) 
     138        # Add this tab to the object library so it can be retrieved by scripting/jupyter 
     139        tab_name = self.getCSTabName() # TODO update the tab name scheme 
     140        ObjectLibrary.addObject(tab_name, tab) 
     141        self.tabs.append(tab) 
     142        self.addTab(tab, tab_name) 
    117143 
    118144    def updateFitDict(self, item_key, tab_name): 
    … …  
    120146        Create a list if none exists and append if there's already a list 
    121147        """ 
    122         if item_key in self.dataToFitTab.keys(): 
    123             self.dataToFitTab[item_key].append(tab_name) 
     148        item_key_str = str(item_key) 
     149        if item_key_str in list(self.dataToFitTab.keys()): 
     150            self.dataToFitTab[item_key_str].append(tab_name) 
    124151        else: 
    125             self.dataToFitTab[item_key] = [tab_name] 
    126  
    127         #print "CURRENT dict: ", self.dataToFitTab 
    128  
    129     def tabName(self, is_batch=False): 
     152            self.dataToFitTab[item_key_str] = [tab_name] 
     153 
     154    def getTabName(self, is_batch=False): 
    130155        """ 
    131156        Get the new tab name, based on the number of fitting tabs so far 
    … …  
    133158        page_name = "BatchPage" if is_batch else "FitPage" 
    134159        page_name = page_name + str(self.maxIndex) 
     160        return page_name 
     161 
     162    def getCSTabName(self): 
     163        """ 
     164        Get the new tab name, based on the number of fitting tabs so far 
     165        """ 
     166        page_name = "Const. & Simul. Fit" 
    135167        return page_name 
    136168 
    … …  
    161193            self.removeTab(index) 
    162194            del self.tabs[index] 
     195            self.tabsModifiedSignal.emit() 
    163196        except IndexError: 
    164197            # The tab might have already been deleted previously 
    … …  
    169202        Given name of the fitting tab - close it 
    170203        """ 
    171         for tab_index in xrange(len(self.tabs)): 
     204        for tab_index in range(len(self.tabs)): 
    172205            if self.tabText(tab_index) == tab_name: 
    173206                self.tabCloses(tab_index) 
    … …  
    181214            return 
    182215        for index_to_delete in index_list: 
    183             if index_to_delete in self.dataToFitTab.keys(): 
    184                 for tab_name in self.dataToFitTab[index_to_delete]: 
     216            index_to_delete_str = str(index_to_delete) 
     217            if index_to_delete_str in list(self.dataToFitTab.keys()): 
     218                for tab_name in self.dataToFitTab[index_to_delete_str]: 
    185219                    # delete tab #index after corresponding data got removed 
    186220                    self.closeTabByName(tab_name) 
    187                 self.dataToFitTab.pop(index_to_delete) 
    188  
    189         #print "CURRENT dict: ", self.dataToFitTab 
     221                self.dataToFitTab.pop(index_to_delete_str) 
    190222 
    191223    def allowBatch(self): 
    … …  
    205237        if not isinstance(data_item, list): 
    206238            msg = "Incorrect type passed to the Fitting Perspective" 
    207             raise AttributeError, msg 
     239            raise AttributeError(msg) 
    208240 
    209241        if not isinstance(data_item[0], QtGui.QStandardItem): 
    210242            msg = "Incorrect type passed to the Fitting Perspective" 
    211             raise AttributeError, msg 
     243            raise AttributeError(msg) 
     244 
     245        if is_batch: 
     246            # Just create a new fit tab. No empty batchFit tabs 
     247            self.addFit(data_item, is_batch=is_batch) 
     248            return 
    212249 
    213250        items = [data_item] if is_batch else data_item 
    214  
    215251        for data in items: 
    216252            # Find the first unassigned tab. 
    217253            # If none, open a new tab. 
    218             available_tabs = list(map(lambda tab: tab.acceptsData(), self.tabs)) 
     254            available_tabs = [tab.acceptsData() for tab in self.tabs] 
    219255 
    220256            if numpy.any(available_tabs): 
    … …  
    236272        self.updateWindowTitle() 
    237273 
     274    def onFittingStarted(self, tabs_for_fitting=None): 
     275        """ 
     276        Notify tabs listed in tabs_for_fitting 
     277        that the fitting thread started 
     278        """ 
     279        assert(isinstance(tabs_for_fitting, list)) 
     280        assert(len(tabs_for_fitting)>0) 
     281 
     282        for tab_object in self.tabs: 
     283            if not isinstance(tab_object, FittingWidget): 
     284                continue 
     285            page_name = "Page%s"%tab_object.tab_id 
     286            if any([page_name in tab for tab in tabs_for_fitting]): 
     287                tab_object.setFittingStarted() 
     288 
    238289        pass 
     290 
     291    def onFittingStopped(self, tabs_for_fitting=None): 
     292        """ 
     293        Notify tabs listed in tabs_for_fitting 
     294        that the fitting thread stopped 
     295        """ 
     296        assert(isinstance(tabs_for_fitting, list)) 
     297        assert(len(tabs_for_fitting)>0) 
     298 
     299        for tab_object in self.tabs: 
     300            if not isinstance(tab_object, FittingWidget): 
     301                continue 
     302            page_name = "Page%s"%tab_object.tab_id 
     303            if any([page_name in tab for tab in tabs_for_fitting]): 
     304                tab_object.setFittingStopped() 
     305 
     306        pass 

  • src/sas/qtgui/Perspectives/Fitting/FittingUtilities.py

    rd0dfcb2 rfde5bcd  
    1 from copy import deepcopy 
    2  
    3 from PyQt4 import QtGui 
    4 from PyQt4 import QtCore 
     1import copy 
     2 
     3from PyQt5 import QtCore 
     4from PyQt5 import QtGui 
     5from PyQt5 import QtWidgets 
    56 
    67import numpy 
    … …  
    4445    Returns a list of all multi-shell parameters in 'model' 
    4546    """ 
    46     return list(filter(lambda par: "[" in par.name, model.iq_parameters)) 
     47    return list([par for par in model.iq_parameters if "[" in par.name]) 
    4748 
    4849def getMultiplicity(model): 
    … …  
    156157    """ 
    157158    for i, item in enumerate(model_header_captions): 
    158         model.setHeaderData(i, QtCore.Qt.Horizontal, QtCore.QVariant(item)) 
    159  
    160     model.header_tooltips = model_header_tooltips 
     159        model.setHeaderData(i, QtCore.Qt.Horizontal, item) 
     160 
     161    model.header_tooltips = copy.copy(model_header_tooltips) 
    161162 
    162163def addErrorHeadersToModel(model): 
    … …  
    164165    Adds predefined headers to the model 
    165166    """ 
    166     model_header_error_captions = model_header_captions 
     167    model_header_error_captions = copy.copy(model_header_captions) 
    167168    model_header_error_captions.insert(2, header_error_caption) 
    168169    for i, item in enumerate(model_header_error_captions): 
    169         model.setHeaderData(i, QtCore.Qt.Horizontal, QtCore.QVariant(item)) 
    170  
    171     model_header_error_tooltips = model_header_tooltips 
     170        model.setHeaderData(i, QtCore.Qt.Horizontal, item) 
     171 
     172    model_header_error_tooltips = copy.copy(model_header_tooltips) 
    172173    model_header_error_tooltips.insert(2, error_tooltip) 
    173     model.header_tooltips = model_header_error_tooltips 
     174    model.header_tooltips = copy.copy(model_header_error_tooltips) 
    174175 
    175176def addPolyHeadersToModel(model): 
    … …  
    178179    """ 
    179180    for i, item in enumerate(poly_header_captions): 
    180         model.setHeaderData(i, QtCore.Qt.Horizontal, QtCore.QVariant(item)) 
    181  
    182     model.header_tooltips = poly_header_tooltip