Changeset b0b09b9 in sasview for src/sas


Ignore:
Timestamp:
Oct 26, 2017 3:13:05 AM (7 years ago)
Author:
Piotr Rozyczko <rozyczko@…>
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:
895e7359
Parents:
def64a0
Message:

Initial changes to make SasView? run with python3

Location:
src/sas
Files:
56 edited

Legend:

Unmodified
Added
Removed

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

    • Property mode changed from 100644 to 100755
    r7d9c83c rb0b09b9  
    1313import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    1414 
    15 from UI.DataOperationUtilityUI import Ui_DataOperationUtility 
     15from .UI.DataOperationUtilityUI import Ui_DataOperationUtility 
    1616 
    1717BG_WHITE = "background-color: rgb(255, 255, 255);" 
    … …  
    7676        self.filenames = filenames 
    7777 
    78         if filenames.keys(): 
     78        if list(filenames.keys()): 
    7979            # clear contents of comboboxes 
    8080            self.cbData1.clear() 
    … …  
    8585            list_datafiles = [] 
    8686 
    87             for key_id in filenames.keys(): 
     87            for key_id in list(filenames.keys()): 
    8888                if filenames[key_id].get_data().title: 
    8989                    # filenames with titles 
    … …  
    139139            data1 = self.data1 
    140140            data2 = self.data2 
    141             exec "output = data1 %s data2" % operator 
     141            exec("output = data1 %s data2" % operator) 
    142142        except: 
    143143            raise 
    … …  
    300300                self.cbData1.setStyleSheet(QtCore.QString(BG_RED)) 
    301301                self.cbData2.setStyleSheet(QtCore.QString(BG_RED)) 
    302                 print self.data1.__class__.__name__ != self.data2.__class__.__name__ 
     302                print(self.data1.__class__.__name__ != self.data2.__class__.__name__) 
    303303                logging.warning('Cannot compute data of different dimensions') 
    304304                return False 
    … …  
    354354    def _findId(self, name): 
    355355        """ find id of name in list of filenames """ 
    356         isinstance(name, basestring) 
    357  
    358         for key_id in self.filenames.keys(): 
     356        isinstance(name, str) 
     357 
     358        for key_id in list(self.filenames.keys()): 
    359359            # data with title 
    360360            if self.filenames[key_id].get_data().title: 

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

    • Property mode changed from 100644 to 100755
    rb0c5e8c rb0b09b9  
    1414 
    1515def enum(*sequential, **named): 
    16     enums = dict(zip(sequential, range(len(sequential))), **named) 
     16    enums = dict(list(zip(sequential, list(range(len(sequential))))), **named) 
    1717    return type('Enum', (), enums) 
    1818 
    … …  
    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()) 

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

    • Property mode changed from 100644 to 100755
    rfef38e8 rb0b09b9  
    2222 
    2323# Local UI 
    24 from UI.GenericScatteringCalculator import Ui_GenericScatteringCalculator 
     24from .UI.GenericScatteringCalculator import Ui_GenericScatteringCalculator 
    2525 
    2626_Q1D_MIN = 0.001 
    … …  
    119119        TODO Temporary solution to display information about option 'Ellipsoid' 
    120120        """ 
    121         print "The option Ellipsoid has not been implemented yet." 
     121        print("The option Ellipsoid has not been implemented yet.") 
    122122        self.communicator.statusBarUpdateSignal.emit( 
    123123            "The option Ellipsoid has not been implemented yet.") 
    … …  
    165165                self.reader.queue() 
    166166        except (RuntimeError, IOError): 
    167             log_msg = "Generic SAS Calculator: %s" % sys.exc_value 
     167            log_msg = "Generic SAS Calculator: %s" % sys.exc_info()[1] 
    168168            logging.info(log_msg) 
    169169            raise 
    … …  
    556556            d.addCallback(self.plot_1_2d) 
    557557        except: 
    558             log_msg = "{}. stop".format(sys.exc_value) 
     558            log_msg = "{}. stop".format(sys.exc_info()[1]) 
    559559            logging.info(log_msg) 
    560560        return 
    … …  
    644644            self.graph_num += 1 
    645645            # TODO 
    646             print 'TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED' 
     646            print('TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED') 
    647647            return plot1D 
    648648        else: 
    … …  
    662662            self.graph_num += 1 
    663663            # TODO 
    664             print 'TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED' 
     664            print('TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED') 
    665665            return plot2D 
    666666 
    … …  
    744744        # II. Plot selective points in color 
    745745        other_color = numpy.ones(len(pix_symbol), dtype='bool') 
    746         for key in color_dic.keys(): 
     746        for key in list(color_dic.keys()): 
    747747            chosen_color = pix_symbol == key 
    748748            if numpy.any(chosen_color): 
    … …  
    758758                # Get atom names not in the list 
    759759                a_names = [symb for symb in pix_symbol \ 
    760                            if symb not in color_dic.keys()] 
     760                           if symb not in list(color_dic.keys())] 
    761761                a_name = a_names[0] 
    762762                for name in a_names: 

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

    • Property mode changed from 100644 to 100755
    rb0c5e8c rb0b09b9  
    33 
    44from sas.qtgui.UI import main_resources_rc 
    5 from UI.KiessigPanel import Ui_KiessigPanel 
     5from .UI.KiessigPanel import Ui_KiessigPanel 
    66import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    77 

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

    • Property mode changed from 100644 to 100755
    r170e95d rb0b09b9  
    2020import re 
    2121 
    22 from UI.ResolutionCalculatorPanelUI import Ui_ResolutionCalculatorPanel 
     22from .UI.ResolutionCalculatorPanelUI import Ui_ResolutionCalculatorPanel 
    2323 
    2424_SOURCE_MASS = {'Alpha': 6.64465620E-24, 
    … …  
    318318                self, "Choose a spectral distribution file", "", 
    319319                "All files (*.*)", 
    320                 None, QtGui.QFileDialog.DontUseNativeDialog) 
     320                QtGui.QFileDialog.DontUseNativeDialog) 
    321321 
    322322            if datafile is None or str(datafile) == '': 
    … …  
    328328            try: 
    329329                basename = os.path.basename(datafile) 
    330                 if basename not in self.spectrum_dic.keys(): 
     330                if basename not in list(self.spectrum_dic.keys()): 
    331331                    self.cbCustomSpectrum.addItem(basename) 
    332332 
    … …  
    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): 

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

    • Property mode changed from 100644 to 100755
    rb0c5e8c rb0b09b9  
    1515 
    1616def enum(*sequential, **named): 
    17     enums = dict(zip(sequential, range(len(sequential))), **named) 
     17    enums = dict(list(zip(sequential, list(range(len(sequential))))), **named) 
    1818    return type('Enum', (), enums) 
    1919 
    … …  
    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, 
    … …  
    142142        self.model.setItem(MODEL.WAVELENGTH       , QtGui.QStandardItem()) 
    143143 
    144         for key in self._getOutputs().keys(): 
     144        for key in list(self._getOutputs().keys()): 
    145145            self.model.setItem(key, QtGui.QStandardItem()) 
    146146 
    … …  
    161161        self.mapper.addMapping(self.ui.editWavelength      , MODEL.WAVELENGTH) 
    162162 
    163         for key, edit in self._getOutputs().iteritems(): 
     163        for key, edit in self._getOutputs().items(): 
    164164            self.mapper.addMapping(edit, key) 
    165165 
    … …  
    168168    def dataChanged(self, top, bottom): 
    169169        update = False 
    170         for index in xrange(top.row(), bottom.row() + 1): 
     170        for index in range(top.row(), bottom.row() + 1): 
    171171            if (index == MODEL.MOLECULAR_FORMULA) or (index == MODEL.MASS_DENSITY) or (index == MODEL.WAVELENGTH): 
    172172                update = True 
    … …  
    202202                    pass 
    203203 
    204             for key in self._getOutputs().keys(): 
     204            for key in list(self._getOutputs().keys()): 
    205205                self.model.item(key).setText("") 
    206206 

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

    • Property mode changed from 100644 to 100755
    rf4a1433 rb0b09b9  
    1111import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    1212 
    13 from UI.SlitSizeCalculator import Ui_SlitSizeCalculator 
     13from .UI.SlitSizeCalculator import Ui_SlitSizeCalculator 
    1414from sas.sascalc.dataloader.loader import Loader 
    1515from sas.sascalc.calculator.slit_length_calculator import SlitlengthCalculator 
    … …  
    7676        # But only with Qt built-in dialog (non-platform native) 
    7777        path = QtGui.QFileDialog.getOpenFileName(self, "Choose a file", "", 
    78                                                  "SAXSess 1D data (*.txt *.TXT *.dat *.DAT)", None, 
     78                                                 "SAXSess 1D data (*.txt *.TXT *.dat *.DAT)", 
    7979                                                 QtGui.QFileDialog.DontUseNativeDialog) 
    8080 
    … …  
    107107            self.clearResults() 
    108108            msg = "ERROR: Data hasn't been loaded correctly" 
    109             raise RuntimeError, msg 
     109            raise RuntimeError(msg) 
    110110 
    111111        if data.__class__.__name__ == 'Data2D': 
    112112            self.clearResults() 
    113113            msg = "Slit Length cannot be computed for 2D Data" 
    114             raise RuntimeError, msg 
     114            raise RuntimeError(msg) 
    115115 
    116116        #compute the slit size 
    … …  
    120120            if xdata == [] or xdata is None or ydata == [] or ydata is None: 
    121121                msg = "The current data is empty please check x and y" 
    122                 raise ValueError, msg 
     122                raise ValueError(msg) 
    123123            slit_length_calculator = SlitlengthCalculator() 
    124124            slit_length_calculator.set_data(x=xdata, y=ydata) 
    … …  
    126126        except: 
    127127            self.clearResults() 
    128             msg = "Slit Size Calculator: %s" % (sys.exc_value) 
    129             raise RuntimeError, msg 
     128            msg = "Slit Size Calculator: %s" % (sys.exc_info()[1]) 
     129            raise RuntimeError(msg) 
    130130 
    131131        slit_length_str = "{:.5f}".format(slit_length) 

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

    • Property mode changed from 100644 to 100755
    rf4a1433 rb0b09b9  
    8484        loader = Loader() 
    8585        data = loader.load(filename)[0] 
    86         self.assertRaisesRegexp(RuntimeError, 
     86        self.assertRaisesRegex(RuntimeError, 
    8787                                "Slit Length cannot be computed for 2D Data", 
    8888                                self.widget.calculateSlitSize, data) 
    8989 
    9090        data = None 
    91         self.assertRaisesRegexp(RuntimeError, 
     91        self.assertRaisesRegex(RuntimeError, 
    9292                                "ERROR: Data hasn't been loaded correctly", 
    9393                                self.widget.calculateSlitSize, data) 

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

    • Property mode changed from 100644 to 100755
    rcd2cc745 rb0b09b9  
    88from sas.qtgui.UI import main_resources_rc 
    99 
    10 from UI.AboutUI import Ui_AboutUI 
     10from .UI.AboutUI import Ui_AboutUI 
    1111 
    1212class AboutBox(QtGui.QDialog, Ui_AboutUI): 

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

    • Property mode changed from 100644 to 100755
    r88e1f57 rb0b09b9  
    155155        Populate the Perspective combobox and define callbacks 
    156156        """ 
    157         available_perspectives = sorted([p for p in Perspectives.PERSPECTIVES.keys()]) 
     157        available_perspectives = sorted([p for p in list(Perspectives.PERSPECTIVES.keys())]) 
    158158        if available_perspectives: 
    159159            self.cbFitting.clear() 
    … …  
    240240 
    241241        self.manager.assign(manager) 
    242         for id, item in self.manager.get_all_data().iteritems(): 
     242        for id, item in self.manager.get_all_data().items(): 
    243243            self.updateModel(item.data, item.path) 
    244244 
    … …  
    345345        # Figure out which rows are checked 
    346346        selected_items = [self.model.item(index) 
    347                           for index in xrange(self.model.rowCount()) 
     347                          for index in range(self.model.rowCount()) 
    348348                          if isItemReady(index)] 
    349349 
    … …  
    400400        else: 
    401401            freeze_msg = "Unexpected number of theories copied: %i" % theories_copied 
    402             raise AttributeError, freeze_msg 
     402            raise AttributeError(freeze_msg) 
    403403        self.communicator.statusBarUpdateSignal.emit(freeze_msg) 
    404404        # Actively switch tabs 
    … …  
    411411        new_item = item.clone() 
    412412        # clone doesn't do deepcopy :( 
    413         for child_index in xrange(item.rowCount()): 
     413        for child_index in range(item.rowCount()): 
    414414            child_item = self.recursivelyCloneItem(item.child(child_index)) 
    415415            new_item.setChild(child_index, child_item) 
    … …  
    435435            return 
    436436        new_plots = [PlotHelper.plotById(plot) for plot in graph_list] 
    437         active_plots_copy = self.active_plots.keys() 
     437        active_plots_copy = list(self.active_plots.keys()) 
    438438        for plot in active_plots_copy: 
    439439            if self.active_plots[plot] in new_plots: 
    … …  
    478478        for plot in plots: 
    479479            plot_id = plot.id 
    480             if plot_id in self.active_plots.keys(): 
     480            if plot_id in list(self.active_plots.keys()): 
    481481                self.active_plots[plot_id].replacePlot(plot_id, plot) 
    482482            else: 
    … …  
    530530            else: 
    531531                msg = "Incorrect data type passed to Plotting" 
    532                 raise AttributeError, msg 
     532                raise AttributeError(msg) 
    533533 
    534534        if 'new_plot' in locals() and \ 
    … …  
    597597 
    598598        id = data.id 
    599         if data.id in self.active_plots.keys(): 
     599        if data.id in list(self.active_plots.keys()): 
    600600            self.active_plots[id].replacePlot(id, data) 
    601601 
    … …  
    610610        # But only with Qt built-in dialog (non-platform native) 
    611611        paths = QtGui.QFileDialog.getOpenFileNames(self, "Choose a file", "", 
    612                 wlist, None, QtGui.QFileDialog.DontUseNativeDialog) 
     612                wlist, QtGui.QFileDialog.DontUseNativeDialog) 
    613613        if paths is None: 
    614614            return 
    615615 
    616         if isinstance(paths, QtCore.QStringList): 
    617             paths = [str(f) for f in paths] 
     616        #if isinstance(paths, QtCore.QStringList): 
     617        #    paths = [str(f) for f in paths] 
    618618 
    619619        if not isinstance(paths, list): 
    … …  
    687687 
    688688            except Exception as ex: 
    689                 logging.error(sys.exc_value) 
     689                logging.error(sys.exc_info()[1]) 
    690690 
    691691                any_error = True 
    … …  
    747747        if not isinstance(index, int): 
    748748            msg = "Incorrect type passed to DataExplorer.selectData()" 
    749             raise AttributeError, msg 
     749            raise AttributeError(msg) 
    750750 
    751751        # Respond appropriately 
    … …  
    773773                except AttributeError: 
    774774                    msg = "Bad structure of the data model." 
    775                     raise RuntimeError, msg 
     775                    raise RuntimeError(msg) 
    776776 
    777777                if is1D: 
    … …  
    787787                except AttributeError: 
    788788                    msg = "Bad structure of the data model." 
    789                     raise RuntimeError, msg 
     789                    raise RuntimeError(msg) 
    790790 
    791791                if item.isCheckable() and item.checkState() == QtCore.Qt.Checked and is1D: 
    … …  
    801801                except AttributeError: 
    802802                    msg = "Bad structure of the data model." 
    803                     raise RuntimeError, msg 
     803                    raise RuntimeError(msg) 
    804804 
    805805                if is2D: 
    … …  
    815815                except AttributeError: 
    816816                    msg = "Bad structure of the data model." 
    817                     raise RuntimeError, msg 
     817                    raise RuntimeError(msg) 
    818818 
    819819                if item.isCheckable() and item.checkState() == QtCore.Qt.Checked and is2D: 
    … …  
    823823            msg = "Incorrect value in the Selection Option" 
    824824            # Change this to a proper logging action 
    825             raise Exception, msg 
     825            raise Exception(msg) 
    826826 
    827827    def contextMenu(self): 
    … …  
    10161016        # Add the actual Data1D/Data2D object 
    10171017        object_item = QtGui.QStandardItem() 
    1018         object_item.setData(QtCore.QVariant(data)) 
     1018        object_item.setData(data) 
    10191019 
    10201020        checkbox_item.setChild(0, object_item) 
    … …  
    10401040        if not isinstance(model_item, QtGui.QStandardItem): 
    10411041            msg = "Wrong data type returned from calculations." 
    1042             raise AttributeError, msg 
     1042            raise AttributeError(msg) 
    10431043 
    10441044        # TODO: Assert other properties 
    … …  
    10571057        if not isinstance(model_item, QtGui.QStandardItem): 
    10581058            msg = "Wrong data type returned from calculations." 
    1059             raise AttributeError, msg 
     1059            raise AttributeError(msg) 
    10601060 
    10611061        # Check if there are any other items for this tab 
    … …  
    10641064        #  
    10651065        current_tab_name = model_item.text()[:2] 
    1066         for current_index in xrange(self.theory_model.rowCount()): 
     1066        for current_index in range(self.theory_model.rowCount()): 
    10671067            if current_tab_name in self.theory_model.item(current_index).text(): 
    10681068                self.theory_model.removeRow(current_index) 

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

    • Property mode changed from 100644 to 100755
    rf4a1433 rb0b09b9  
    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) 
    … …  
    146146        receive a list of 
    147147        """ 
    148         for id, data in data_list.iteritems(): 
     148        for id, data in data_list.items(): 
    149149            if id  in self.stored_data: 
    150150                msg = "Data manager already stores %s" % str(data.name) 
    … …  
    162162        """ 
    163163        """ 
    164         if prev_data.id not in self.stored_data.keys(): 
     164        if prev_data.id not in list(self.stored_data.keys()): 
    165165            return None, {} 
    166166        data_state = self.stored_data[prev_data.id] 
    167167        self.stored_data[new_data.id]  = data_state.clone() 
    168168        self.stored_data[new_data.id].data = new_data 
    169         if prev_data.id in self.stored_data.keys(): 
     169        if prev_data.id in list(self.stored_data.keys()): 
    170170            del self.stored_data[prev_data.id] 
    171171        return prev_data.id, {new_data.id: self.stored_data[new_data.id]} 
    … …  
    177177        if data_id is None and theory is not None: 
    178178            uid = theory.id 
    179         if uid in self.stored_data.keys(): 
     179        if uid in list(self.stored_data.keys()): 
    180180             data_state = self.stored_data[uid] 
    181181        else: 
    … …  
    207207                if search_id == d_id: 
    208208                    _selected_data[search_id] = data 
    209                 if search_id in theory_list.keys(): 
     209                if search_id in list(theory_list.keys()): 
    210210                     _selected_theory_list[search_id] = theory_list[search_id] 
    211211 
    … …  
    216216        """ 
    217217        """ 
    218         return self.freeze_theory(self.stored_data.keys(), theory_id) 
     218        return self.freeze_theory(list(self.stored_data.keys()), theory_id) 
    219219 
    220220    def freeze_theory(self, data_id, theory_id): 
    … …  
    227227                theory_list = data_state.get_theory() 
    228228                for t_id in theory_id: 
    229                     if t_id in theory_list.keys(): 
     229                    if t_id in list(theory_list.keys()): 
    230230                        theory_data, theory_state = theory_list[t_id] 
    231231                        new_theory = copy.deepcopy(theory_data) 
    … …  
    247247        """ 
    248248        for d_id in data_id: 
    249             if d_id in self.stored_data.keys(): 
     249            if d_id in list(self.stored_data.keys()): 
    250250                data_state = self.stored_data[d_id] 
    251251                if data_state.data.name in self.data_name_dict: 
    … …  
    265265                data_state = self.stored_data[d_id] 
    266266                theory_list = data_state.get_theory() 
    267                 if theory_id in theory_list.keys(): 
     267                if theory_id in list(theory_list.keys()): 
    268268                    del theory_list[theory_id] 
    269269        #del pure theory 
    … …  
    284284        _selected_data = {} 
    285285        for selected_name in name_list: 
    286             for id, data_state in self.stored_data.iteritems(): 
     286            for id, data_state in self.stored_data.items(): 
    287287                if data_state.data.name == selected_name: 
    288288                    _selected_data[id] = data_state.data 
    … …  
    294294        """ 
    295295        for selected_name in name_list: 
    296             for id, data_state in self.stored_data.iteritems(): 
     296            for id, data_state in self.stored_data.items(): 
    297297                if data_state.data.name == selected_name: 
    298298                    del self.stored_data[id] 
    … …  
    303303            # Take the copy of current, possibly shorter stored_data dict 
    304304            stored_data = copy.deepcopy(self.stored_data) 
    305             for idx in stored_data.keys(): 
     305            for idx in list(stored_data.keys()): 
    306306                if str(selected_name) in str(idx): 
    307307                    del self.stored_data[idx] 
    … …  
    313313        _selected_data_state = {} 
    314314        for id in data_id: 
    315             if id in self.stored_data.keys(): 
     315            if id in list(self.stored_data.keys()): 
    316316                _selected_data_state[id] = self.stored_data[id] 
    317317        return _selected_data_state 
    … …  
    396396            class Empty(object): 
    397397                def __init__(self): 
    398                     for key, value in data.iteritems(): 
     398                    for key, value in data.items(): 
    399399                        setattr(self, key, generate(value, level)) 
    400400 
    … …  
    451451                    # if dictionary doesn't have __type__ then it is assumed to be just an ordinary dictionary 
    452452                    o = {} 
    453                     for key, value in data.iteritems(): 
     453                    for key, value in data.items(): 
    454454                        o[key] = generate(value, level) 
    455455                    return o 
    … …  
    463463 
    464464        new_stored_data = {} 
    465         for id, data in json.load(fp).iteritems(): 
     465        for id, data in json.load(fp).items(): 
    466466            try: 
    467467                new_stored_data[id] = generate(data, 0) 

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

    rdc5ef15 rb0b09b9  
    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/GuiManager.py

    • Property mode changed from 100644 to 100755
    rf0bb711 rb0b09b9  
    191191        workspace_height = self._workspace.workspace.sizeHint().height() 
    192192        perspective_size = self._current_perspective.sizeHint() 
    193         if workspace_height < perspective_size.height: 
     193        if workspace_height < perspective_size.height(): 
    194194            perspective_width = perspective_size.width() 
    195195            self._current_perspective.resize(perspective_width, workspace_height-10) 
    … …  
    202202        assert isinstance(data, list) 
    203203        if self._current_perspective is not None: 
    204             self._current_perspective.setData(data.values()) 
     204            self._current_perspective.setData(list(data.values())) 
    205205        else: 
    206206            msg = "No perspective is currently active." 
    … …  
    246246        """ 
    247247        if self._current_perspective is not None: 
    248             self._current_perspective.setData(data.values()) 
     248            self._current_perspective.setData(list(data.values())) 
    249249        else: 
    250250            msg = "Guiframe does not have a current perspective" 
    … …  
    289289            version_info = json.loads(content) 
    290290            self.processVersion(version_info) 
    291         except ValueError, ex: 
     291        except ValueError as ex: 
    292292            logging.info("Failed to connect to www.sasview.org:", ex) 
    293293 
    … …  
    321321        except: 
    322322            msg = "guiframe: could not get latest application" 
    323             msg += " version number\n  %s" % sys.exc_value 
     323            msg += " version number\n  %s" % sys.exc_info()[1] 
    324324            logging.error(msg) 
    325325            msg = "Could not connect to the application server." 
    … …  
    743743                not isinstance(new_datalist_item, dict): 
    744744            msg = "Wrong data type returned from calculations." 
    745             raise AttributeError, msg 
     745            raise AttributeError(msg) 
    746746 
    747747        self.filesWidget.model.appendRow(new_item) 

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

    • Property mode changed from 100644 to 100755
    r2a8bd705 rb0b09b9  
    55# Local UI 
    66from sas.qtgui.UI import main_resources_rc 
    7 from UI.MainWindowUI import Ui_MainWindow 
     7from .UI.MainWindowUI import Ui_MainWindow 
    88 
    99# Initialize logging 
    … …  
    2121 
    2222        # Create the gui manager 
    23         from GuiManager import GuiManager 
     23        from .GuiManager import GuiManager 
    2424        self.guiManager = GuiManager(self) 
    2525 

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

    ree18d33 rb0b09b9  
    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... 

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

    ree18d33 rb0b09b9  
    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

    r377ade1 rb0b09b9  
    8080        Use options.FIT_FIELDS to assert which line edit gets what validator 
    8181        """ 
    82         for option in bumps.options.FIT_FIELDS.iterkeys(): 
     82        for option in bumps.options.FIT_FIELDS.keys(): 
    8383            (f_name, f_type) = bumps.options.FIT_FIELDS[option] 
    8484            validator = None 
    … …  
    8686                validator = QtGui.QIntValidator() 
    8787                validator.setBottom(0) 
    88             elif f_type == types.FloatType: 
     88            elif f_type == float: 
    8989                validator = QtGui.QDoubleValidator() 
    9090                validator.setBottom(0) 
    … …  
    153153 
    154154        # Update the BUMPS singleton 
    155         [bumpsUpdate(o) for o in self.config.values[self.current_fitter_id].iterkeys()] 
     155        [bumpsUpdate(o) for o in self.config.values[self.current_fitter_id].keys()] 
    156156 
    157157    def onHelp(self): 
    … …  
    175175        if current_fitter is None: 
    176176            current_fitter = self.current_fitter_id 
    177         if option_id not in bumps.options.FIT_FIELDS.keys(): return None 
     177        if option_id not in list(bumps.options.FIT_FIELDS.keys()): return None 
    178178        option = option_id + '_' + current_fitter 
    179179        if not hasattr(self, option): return None 
    … …  
    193193        """ 
    194194        options = self.config.values[fitter_id] 
    195         for option in options.iterkeys(): 
     195        for option in options.keys(): 
    196196            # Find the widget name of the option 
    197197            # e.g. 'samples' for 'dream' is 'self.samples_dream' 

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

    • Property mode changed from 100644 to 100755
    r377ade1 rb0b09b9  
    1111from sas.qtgui.Perspectives.Fitting.FittingWidget import FittingWidget 
    1212from sas.qtgui.Perspectives.Fitting.FittingOptions import FittingOptions 
    13 from sas.qtgui.Perspectives.Fitting import ModelUtilities 
     13#from sas.qtgui.Perspectives.Fitting import ModelUtilities 
    1414 
    1515class FittingWindow(QtGui.QTabWidget): 
    … …  
    6161        self.fit_options_widget.fit_option_changed.connect(self.onFittingOptionsChange) 
    6262 
    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() 
     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() 
    6767 
    6868        #self.setWindowTitle('Fit panel - Active Fitting Optimizer: %s' % self.optimizer) 
    … …  
    120120        Create a list if none exists and append if there's already a list 
    121121        """ 
    122         if item_key in self.dataToFitTab.keys(): 
    123             self.dataToFitTab[item_key].append(tab_name) 
     122        item_key_str = str(item_key) 
     123        if item_key_str in list(self.dataToFitTab.keys()): 
     124            self.dataToFitTab[item_key_str].append(tab_name) 
    124125        else: 
    125             self.dataToFitTab[item_key] = [tab_name] 
     126            self.dataToFitTab[item_key_str] = [tab_name] 
    126127 
    127128        #print "CURRENT dict: ", self.dataToFitTab 
    … …  
    169170        Given name of the fitting tab - close it 
    170171        """ 
    171         for tab_index in xrange(len(self.tabs)): 
     172        for tab_index in range(len(self.tabs)): 
    172173            if self.tabText(tab_index) == tab_name: 
    173174                self.tabCloses(tab_index) 
    … …  
    181182            return 
    182183        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]: 
     184            index_to_delete_str = str(index_to_delete) 
     185            if index_to_delete_str in list(self.dataToFitTab.keys()): 
     186                for tab_name in self.dataToFitTab[index_to_delete_str]: 
    185187                    # delete tab #index after corresponding data got removed 
    186188                    self.closeTabByName(tab_name) 
    187                 self.dataToFitTab.pop(index_to_delete) 
     189                self.dataToFitTab.pop(index_to_delete_str) 
    188190 
    189191        #print "CURRENT dict: ", self.dataToFitTab 
    … …  
    205207        if not isinstance(data_item, list): 
    206208            msg = "Incorrect type passed to the Fitting Perspective" 
    207             raise AttributeError, msg 
     209            raise AttributeError(msg) 
    208210 
    209211        if not isinstance(data_item[0], QtGui.QStandardItem): 
    210212            msg = "Incorrect type passed to the Fitting Perspective" 
    211             raise AttributeError, msg 
     213            raise AttributeError(msg) 
    212214 
    213215        items = [data_item] if is_batch else data_item 
    … …  
    216218            # Find the first unassigned tab. 
    217219            # If none, open a new tab. 
    218             available_tabs = list(map(lambda tab: tab.acceptsData(), self.tabs)) 
     220            available_tabs = list([tab.acceptsData() for tab in self.tabs]) 
    219221 
    220222            if numpy.any(available_tabs): 

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

    • Property mode changed from 100644 to 100755
    rd0dfcb2 rb0b09b9  
    4444    Returns a list of all multi-shell parameters in 'model' 
    4545    """ 
    46     return list(filter(lambda par: "[" in par.name, model.iq_parameters)) 
     46    return list([par for par in model.iq_parameters if "[" in par.name]) 
    4747 
    4848def getMultiplicity(model): 
    … …  
    156156    """ 
    157157    for i, item in enumerate(model_header_captions): 
    158         model.setHeaderData(i, QtCore.Qt.Horizontal, QtCore.QVariant(item)) 
     158        #model.setHeaderData(i, QtCore.Qt.Horizontal, QtCore.QVariant(item)) 
     159        model.setHeaderData(i, QtCore.Qt.Horizontal, item) 
    159160 
    160161    model.header_tooltips = model_header_tooltips 
    … …  
    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        model.setHeaderData(i, QtCore.Qt.Horizontal, item) 
    170171 
    171172    model_header_error_tooltips = model_header_tooltips 
    … …  
    178179    """ 
    179180    for i, item in enumerate(poly_header_captions): 
    180         model.setHeaderData(i, QtCore.Qt.Horizontal, QtCore.QVariant(item)) 
     181        model.setHeaderData(i, QtCore.Qt.Horizontal, item) 
    181182 
    182183    model.header_tooltips = poly_header_tooltips 
    … …  
    190191    poly_header_error_captions.insert(2, header_error_caption) 
    191192    for i, item in enumerate(poly_header_error_captions): 
    192         model.setHeaderData(i, QtCore.Qt.Horizontal, QtCore.QVariant(item)) 
     193        model.setHeaderData(i, QtCore.Qt.Horizontal, item) 
    193194 
    194195    poly_header_error_tooltips = poly_header_tooltips 
    … …  
    202203    multishell_parameters = getIterParams(parameters) 
    203204 
    204     for i in xrange(index): 
     205    for i in range(index): 
    205206        for par in multishell_parameters: 
    206207            # Create the name: <param>[<i>], e.g. "sld1" for parameter "sld[n]" 
    … …  
    396397 
    397398def binary_encode(i, digits): 
    398     return [i >> d & 1 for d in xrange(digits)] 
     399    return [i >> d & 1 for d in range(digits)] 
    399400 
    400401def getWeight(data, is2d, flag=None): 

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

    • Property mode changed from 100644 to 100755
    rdef64a0 rb0b09b9  
    22import os 
    33from collections import defaultdict 
    4 from itertools import izip 
     4 
    55 
    66import logging 
    … …  
    6969        if role == QtCore.Qt.ToolTipRole: 
    7070            if orientation == QtCore.Qt.Horizontal: 
    71                 return QtCore.QString(str(self.header_tooltips[section])) 
     71                return str(self.header_tooltips[section]) 
    7272 
    7373        return QtGui.QStandardItemModel.headerData(self, section, orientation, role) 
    … …  
    353353        # Similarly on other tabs 
    354354        self.options_widget.setEnablementOnDataLoad() 
    355  
     355        self.onSelectModel() 
    356356        # Smearing tab 
    357357        self.smearing_widget.updateSmearing(self.data) 
    … …  
    473473        model = str(self.cbModel.currentText()) 
    474474 
     475        # empty combobox forced to be read 
     476        if not model: 
     477            return 
    475478        # Reset structure factor 
    476479        self.cbStructureFactor.setCurrentIndex(0) 
    … …  
    763766        """ 
    764767        """ 
    765         print "UPDATE FIT" 
     768        print("UPDATE FIT") 
    766769        pass 
    767770 
    … …  
    769772        """ 
    770773        """ 
    771         print "FIT FAILED: ", reason 
     774        print("FIT FAILED: ", reason) 
    772775        pass 
    773776 
    … …  
    814817        param_values = res.pvec     # array([ 0.36221662,  0.0146783 ]) 
    815818        param_stderr = res.stderr   # array([ 1.71293015,  1.71294233]) 
    816         params_and_errors = zip(param_values, param_stderr) 
    817         param_dict = dict(izip(param_list, params_and_errors)) 
     819        params_and_errors = list(zip(param_values, param_stderr)) 
     820        param_dict = dict(zip(param_list, params_and_errors)) 
    818821 
    819822        # Dictionary of fitted parameter: value, error 
    … …  
    836839        Take func and throw it inside the model row loop 
    837840        """ 
    838         for row_i in xrange(self._model_model.rowCount()): 
     841        for row_i in range(self._model_model.rowCount()): 
    839842            func(row_i) 
    840843 
    … …  
    851854            # internal so can use closure for param_dict 
    852855            param_name = str(self._model_model.item(row, 0).text()) 
    853             if param_name not in param_dict.keys(): 
     856            if param_name not in list(param_dict.keys()): 
    854857                return 
    855858            # modify the param value 
    … …  
    863866            # Utility function for updateof polydispersity part of the main model 
    864867            param_name = str(self._model_model.item(row, 0).text())+'.width' 
    865             if param_name not in param_dict.keys(): 
     868            if param_name not in list(param_dict.keys()): 
    866869                return 
    867870            # modify the param value 
    … …  
    878881                return str(self._model_model.item(row, 0).text()) 
    879882 
    880             [createItem(param_name) for param_name in param_dict.keys() if curr_param() == param_name] 
     883            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name] 
    881884 
    882885            error_column.append(item) 
    … …  
    922925            Take func and throw it inside the poly model row loop 
    923926            """ 
    924             for row_i in xrange(self._poly_model.rowCount()): 
     927            for row_i in range(self._poly_model.rowCount()): 
    925928                func(row_i) 
    926929 
    … …  
    931934                return 
    932935            param_name = str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width' 
    933             if param_name not in param_dict.keys(): 
     936            if param_name not in list(param_dict.keys()): 
    934937                return 
    935938            # modify the param value 
    … …  
    954957                return str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width' 
    955958 
    956             [createItem(param_name) for param_name in param_dict.keys() if poly_param() == param_name] 
     959            [createItem(param_name) for param_name in list(param_dict.keys()) if poly_param() == param_name] 
    957960 
    958961            error_column.append(item) 
    … …  
    991994            Take func and throw it inside the magnet model row loop 
    992995            """ 
    993             for row_i in xrange(self._model_model.rowCount()): 
     996            for row_i in range(self._model_model.rowCount()): 
    994997                func(row_i) 
    995998 
    … …  
    9981001            # internal so can use closure for param_dict 
    9991002            param_name = str(self._magnet_model.item(row, 0).text()) 
    1000             if param_name not in param_dict.keys(): 
     1003            if param_name not in list(param_dict.keys()): 
    10011004                return 
    10021005            # modify the param value 
    … …  
    10161019                return str(self._magnet_model.item(row, 0).text()) 
    10171020 
    1018             [createItem(param_name) for param_name in param_dict.keys() if curr_param() == param_name] 
     1021            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name] 
    10191022 
    10201023            error_column.append(item) 
    … …  
    12911294            # Unparsable field 
    12921295            return 
    1293         parameter_name = str(self._model_model.data(name_index).toPyObject()) # sld, background etc. 
     1296        parameter_name = str(self._model_model.data(name_index)) #.toPyObject()) # sld, background etc. 
    12941297 
    12951298        # Update the parameter value - note: this supports +/-inf as well 
    … …  
    13571360 
    13581361        return [str(model.item(row_index, 0).text()) 
    1359                 for row_index in xrange(model.rowCount()) 
     1362                for row_index in range(model.rowCount()) 
    13601363                if isChecked(row_index)] 
    13611364 
    … …  
    13981401            fitted_data.symbol = 'Line' 
    13991402        # Notify the GUI manager so it can update the main model in DataExplorer 
    1400         GuiUtils.updateModelItemWithPlot(self._index, QtCore.QVariant(fitted_data), name) 
     1403        GuiUtils.updateModelItemWithPlot(self._index, fitted_data, name) 
    14011404 
    14021405    def createTheoryIndex(self, fitted_data): 
    … …  
    14061409        name = self.nameFromData(fitted_data) 
    14071410        # Notify the GUI manager so it can create the theory model in DataExplorer 
    1408         new_item = GuiUtils.createModelItemWithPlot(QtCore.QVariant(fitted_data), name=name) 
     1411        new_item = GuiUtils.createModelItemWithPlot(fitted_data, name=name) 
    14091412        self.communicate.updateTheoryFromPerspectiveSignal.emit(new_item) 
    14101413 
    … …  
    14601463        Thread returned error 
    14611464        """ 
    1462         print "Calculate Data failed with ", reason 
     1465        print("Calculate Data failed with ", reason) 
    14631466 
    14641467    def complete1D(self, return_data): 
    … …  
    15571560            else: 
    15581561                # Create as many entries as current shells 
    1559                 for ishell in xrange(1, self.current_shell_displayed+1): 
     1562                for ishell in range(1, self.current_shell_displayed+1): 
    15601563                    # Remove [n] and add the shell numeral 
    15611564                    name = param_name[0:param_name.index('[')] + str(ishell) 
    … …  
    15851588        # All possible polydisp. functions as strings in combobox 
    15861589        func = QtGui.QComboBox() 
    1587         func.addItems([str(name_disp) for name_disp in POLYDISPERSITY_MODELS.iterkeys()]) 
     1590        func.addItems([str(name_disp) for name_disp in POLYDISPERSITY_MODELS.keys()]) 
    15881591        # Set the default index 
    15891592        func.setCurrentIndex(func.findText(DEFAULT_POLYDISP_FUNCTION)) 
    … …  
    16361639                lo = self.lstPoly.itemDelegate().poly_pd 
    16371640                hi = self.lstPoly.itemDelegate().poly_function 
    1638                 [self._poly_model.item(row_index, i).setEnabled(False) for i in xrange(lo, hi)] 
     1641                [self._poly_model.item(row_index, i).setEnabled(False) for i in range(lo, hi)] 
    16391642                return 
    16401643            except IOError: 
    … …  
    16461649        self._poly_model.blockSignals(True) 
    16471650        max_range = self.lstPoly.itemDelegate().poly_filename 
    1648         [self._poly_model.item(row_index, i).setEnabled(True) for i in xrange(7)] 
     1651        [self._poly_model.item(row_index, i).setEnabled(True) for i in range(7)] 
    16491652        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename) 
    1650         self._poly_model.setData(file_index, QtCore.QVariant("")) 
     1653        self._poly_model.setData(file_index, "") 
    16511654        self._poly_model.blockSignals(False) 
    16521655 
    … …  
    16571660        nsigs = POLYDISPERSITY_MODELS[str(combo_string)].default['nsigmas'] 
    16581661 
    1659         self._poly_model.setData(npts_index, QtCore.QVariant(npts)) 
    1660         self._poly_model.setData(nsigs_index, QtCore.QVariant(nsigs)) 
     1662        self._poly_model.setData(npts_index, npts) 
     1663        self._poly_model.setData(nsigs_index, nsigs) 
    16611664 
    16621665        self.iterateOverModel(updateFunctionCaption) 
    … …  
    16691672        datafile = QtGui.QFileDialog.getOpenFileName( 
    16701673            self, "Choose a weight file", "", "All files (*.*)", 
    1671             None, QtGui.QFileDialog.DontUseNativeDialog) 
     1674            QtGui.QFileDialog.DontUseNativeDialog) 
    16721675 
    16731676        if datafile is None or str(datafile)=='': 
    … …  
    16981701        fname = os.path.basename(str(datafile)) 
    16991702        fname_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename) 
    1700         self._poly_model.setData(fname_index, QtCore.QVariant(fname)) 
     1703        self._poly_model.setData(fname_index, fname) 
    17011704 
    17021705    def setMagneticModel(self): 
    … …  
    17201723        top_index = self.kernel_module.multiplicity_info.number 
    17211724        shell_names = [] 
    1722         for i in xrange(1, top_index+1): 
     1725        for i in range(1, top_index+1): 
    17231726            for name in multi_names: 
    17241727                shell_names.append(name+str(i)) 
    … …  
    17701773        func = QtGui.QComboBox() 
    17711774        # Available range of shells displayed in the combobox 
    1772         func.addItems([str(i) for i in xrange(param_length+1)]) 
     1775        func.addItems([str(i) for i in range(param_length+1)]) 
    17731776 
    17741777        # Respond to index change 

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

    r6964d44 rb0b09b9  
    6565        if self.data is None: 
    6666            msg = "Compute Calc2D receive data = %s.\n" % str(self.data) 
    67             raise ValueError, msg 
     67            raise ValueError(msg) 
    6868 
    6969        # Define matrix where data will be plotted 

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

    r125c4be rb0b09b9  
    22    Utilities to manage models 
    33""" 
    4 from __future__ import print_function 
     4 
    55 
    66import traceback 
    … …  
    6868    except: 
    6969        msg = "Plugin %s error in __init__ \n\t: %s %s\n" % (str(name), 
    70                                                              str(sys.exc_type), 
     70                                                             str(sys.exc_info()[0]), 
    7171                                                             sys.exc_info()[1]) 
    7272        plugin_log(msg) 
    … …  
    7878        except: 
    7979            msg = "Plugin %s: error writing function \n\t :%s %s\n " % \ 
    80                     (str(name), str(sys.exc_type), sys.exc_info()[1]) 
     80                    (str(name), str(sys.exc_info()[0]), sys.exc_info()[1]) 
    8181            plugin_log(msg) 
    8282            return None 
    … …  
    138138    Class to check for problems with specific values 
    139139    """ 
    140     def __nonzero__(self): 
     140    def __bool__(self): 
    141141        type, value, tb = sys.exc_info() 
    142142        if type is not None and issubclass(type, py_compile.PyCompileError): 
    143143            print("Problem with", repr(value)) 
    144             raise type, value, tb 
     144            raise type(value).with_traceback(tb) 
    145145        return 1 
    146146 
    … …  
    211211 
    212212        """ 
    213         if name not in self.mydict.keys(): 
     213        if name not in list(self.mydict.keys()): 
    214214            self.reset_list(name, mylist) 
    215215 
    … …  
    292292        #Looking for plugins 
    293293        self.stored_plugins = self.findModels() 
    294         self.plugins = self.stored_plugins.values() 
    295         for name, plug in self.stored_plugins.iteritems(): 
     294        self.plugins = list(self.stored_plugins.values()) 
     295        for name, plug in self.stored_plugins.items(): 
    296296            self.model_dictionary[name] = plug 
    297297         
    … …  
    322322        new_plugins = self.findModels() 
    323323        if len(new_plugins) > 0: 
    324             for name, plug in  new_plugins.iteritems(): 
    325                 if name not in self.stored_plugins.keys(): 
     324            for name, plug in  new_plugins.items(): 
     325                if name not in list(self.stored_plugins.keys()): 
    326326                    self.stored_plugins[name] = plug 
    327327                    self.plugins.append(plug) 
    … …  
    338338        self.plugins = [] 
    339339        new_plugins = _find_models() 
    340         for name, plug in  new_plugins.iteritems(): 
    341             for stored_name, stored_plug in self.stored_plugins.iteritems(): 
     340        for name, plug in  new_plugins.items(): 
     341            for stored_name, stored_plug in self.stored_plugins.items(): 
    342342                if name == stored_name: 
    343343                    del self.stored_plugins[name] 
    … …  
    358358 
    359359        """ 
    360         if int(evt.GetId()) in self.form_factor_dict.keys(): 
     360        if int(evt.GetId()) in list(self.form_factor_dict.keys()): 
    361361            from sasmodels.sasview_model import MultiplicationModel 
    362362            self.model_dictionary[MultiplicationModel.__name__] = MultiplicationModel 
    … …  
    417417    __modelmanager = ModelManagerBase() 
    418418    cat_model_list = [__modelmanager.model_dictionary[model_name] for model_name \ 
    419                       in __modelmanager.model_dictionary.keys() \ 
    420                       if model_name not in __modelmanager.stored_plugins.keys()] 
     419                      in list(__modelmanager.model_dictionary.keys()) \ 
     420                      if model_name not in list(__modelmanager.stored_plugins.keys())] 
    421421 
    422422    CategoryInstaller.check_install(model_list=cat_model_list) 

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

    r457d961 rb0b09b9  
    9696        """ 
    9797        self.model = QtGui.QStandardItemModel() 
    98         for model_item in xrange(len(MODEL)): 
     98        for model_item in range(len(MODEL)): 
    9999            self.model.setItem(model_item, QtGui.QStandardItem()) 
    100100        # Attach slot 

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

    • Property mode changed from 100644 to 100755
    rdc5ef15 rb0b09b9  
    6565        """ 
    6666        self.model = QtGui.QStandardItemModel() 
    67         for model_item in xrange(len(MODEL)): 
     67        for model_item in range(len(MODEL)): 
    6868            self.model.setItem(model_item, QtGui.QStandardItem()) 
    6969        # Attach slot 

  • src/sas/qtgui/Perspectives/Invariant/InvariantDetails.py

    • Property mode changed from 100644 to 100755
    r28cda69 rb0b09b9  
    55 
    66# local 
    7 from UI.InvariantDetailsUI import Ui_Dialog 
    8 from InvariantUtils import WIDGETS 
     7from .UI.InvariantDetailsUI import Ui_Dialog 
     8from .InvariantUtils import WIDGETS 
    99 
    1010class DetailsDialog(QtGui.QDialog, Ui_Dialog): 

  • src/sas/qtgui/Perspectives/Invariant/InvariantPerspective.py

    • Property mode changed from 100644 to 100755
    r457d961 rb0b09b9  
    1515 
    1616# local 
    17 from UI.TabbedInvariantUI import Ui_tabbedInvariantUI 
    18 from InvariantDetails import DetailsDialog 
    19 from InvariantUtils import WIDGETS 
     17from .UI.TabbedInvariantUI import Ui_tabbedInvariantUI 
     18from .InvariantDetails import DetailsDialog 
     19from .InvariantUtils import WIDGETS 
    2020 
    2121# The minimum q-value to be used when extrapolating 
    … …  
    551551        if not isinstance(data_item, list): 
    552552            msg = "Incorrect type passed to the Invariant Perspective" 
    553             raise AttributeError, msg 
     553            raise AttributeError(msg) 
    554554 
    555555        if not isinstance(data_item[0], QtGui.QStandardItem): 
    556556            msg = "Incorrect type passed to the Invariant Perspective" 
    557             raise AttributeError, msg 
     557            raise AttributeError(msg) 
    558558 
    559559        self._model_item = data_item[0] 
    … …  
    631631                    self.calculateInvariant() 
    632632                except: 
    633                     msg = "Invariant Set_data: " + str(sys.exc_value) 
     633                    msg = "Invariant Set_data: " + str(sys.exc_info()[1]) 
    634634                    #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    635635        else: 

  • src/sas/qtgui/Perspectives/Invariant/InvariantUtils.py

    rf721030 rb0b09b9  
    11def enum(*sequential, **named): 
    2     enums = dict(zip(sequential, range(len(sequential))), **named) 
     2    enums = dict(list(zip(sequential, list(range(len(sequential))))), **named) 
    33    return type('Enum', (), enums) 
    44 

  • src/sas/qtgui/Perspectives/__init__.py

    • Property mode changed from 100644 to 100755
    r7adc2a8 rb0b09b9  
    22# When adding a new perspective, this dictionary needs to be updated 
    33 
    4 from Fitting.FittingPerspective import FittingWindow 
    5 from Invariant.InvariantPerspective import InvariantWindow 
     4from .Fitting.FittingPerspective import FittingWindow 
     5from .Invariant.InvariantPerspective import InvariantWindow 
    66 
    77PERSPECTIVES = { 

  • src/sas/qtgui/Plotting/Arrow3D.py

    rfef38e8 rb0b09b9  
    5959            return 
    6060        xs3d, ys3d, zs3d = self._verts3d 
    61         for i in xrange(len(xs3d)): 
     61        for i in range(len(xs3d)): 
    6262            xs, ys, _ = proj3d.proj_transform(xs3d[i], ys3d[i], zs3d[i], renderer.M) 
    6363            self.set_positions((xs[0], ys[0]), (xs[1], ys[1])) 

  • src/sas/qtgui/Plotting/Binder.py

    rdc5ef15 rb0b09b9  
    2424        return self.artist is not other.artist 
    2525 
    26     def __nonzero__(self): 
     26    def __bool__(self): 
    2727        return self.artist is not None 
    2828 
    … …  
    6161            ] 
    6262        except: 
    63             print "bypassing scroll_event: wrong matplotlib version" 
     63            print("bypassing scroll_event: wrong matplotlib version") 
    6464            self._connections = [ 
    6565                canvas.mpl_connect('motion_notify_event', self._onMotion), 
    … …  
    121121            for cid in self._connections: self.canvas.mpl_disconnect(cid) 
    122122        except: 
    123             logging.error("Error disconnection canvas: %s" % sys.exc_value) 
     123            logging.error("Error disconnection canvas: %s" % sys.exc_info()[1]) 
    124124        self._connections = [] 
    125125 
    … …  
    185185        # Check that the trigger is valid 
    186186        if trigger not in self._actions: 
    187             raise ValueError, "%s invalid --- valid triggers are %s"\ 
    188                  % (trigger, ", ".join(self.events)) 
     187            raise ValueError("%s invalid --- valid triggers are %s"\ 
     188                 % (trigger, ", ".join(self.events))) 
    189189 
    190190        # Register the trigger callback 
    … …  
    201201        """ 
    202202        if action not in self.events: 
    203             raise ValueError, "Trigger expects " + ", ".join(self.events) 
     203            raise ValueError("Trigger expects " + ", ".join(self.events)) 
    204204 
    205205        # Tag the event with modifiers 

  • src/sas/qtgui/Plotting/ColorMap.py

    • Property mode changed from 100644 to 100755
    rdc5ef15 rb0b09b9  
    1313from sas.qtgui.Plotting.PlotterData import Data2D 
    1414from sas.qtgui.Utilities.GuiUtils import formatNumber 
    15 from rangeSlider import RangeSlider 
     15from .rangeSlider import RangeSlider 
    1616 
    1717DEFAULT_MAP = 'jet' 

  • src/sas/qtgui/Plotting/ConvertUnits.py

    rdc5ef15 rb0b09b9  
    4242                            unit = toks[0] + "^{" + str(powerer) + "}" 
    4343                else: 
    44                     raise ValueError, "missing } in unit expression" 
     44                    raise ValueError("missing } in unit expression") 
    4545        else:  # no powerer 
    4646            if  power != 1: 
    4747                unit = "(" + unit + ")" + "^{" + str(power) + "}" 
    4848    else: 
    49         raise ValueError, "empty unit ,enter a powerer different from zero" 
     49        raise ValueError("empty unit ,enter a powerer different from zero") 
    5050    return unit 
    5151 
    … …  
    6868    unit8 = "m/s^{4}"  #         x^2               (m/s^{4})^{2} 
    6969 
    70     print "this unit1 %s ,its powerer %s , and value %s" % (unit1, 1, convert_unit(1, unit1)) 
    71     print "this unit2 %s ,its powerer %s , and value %s" % (unit2, 1, convert_unit(1, unit2)) 
    72     print "this unit3 %s ,its powerer %s , and value %s" % (unit3, 2, convert_unit(2, unit3)) 
    73     print "this unit4 %s ,its powerer %s , and value %s" % (unit4, -1, convert_unit(-1, unit4)) 
    74     print "this unit5 %s ,its powerer %s , and value %s" % (unit5, 2, convert_unit(2, unit5)) 
    75     print "this unit6 %s ,its powerer %s , and value %s" % (unit6, 2, convert_unit(2, unit6)) 
    76     print "this unit7 %s ,its powerer %s , and value %s" % (unit7, -1, convert_unit(-1, unit7)) 
    77     print "this unit8 %s ,its powerer %s , and value %s" % (unit8, 2, convert_unit(2, unit8)) 
    78     print "this unit9 %s ,its powerer %s , and value %s" % (unit9, 2, convert_unit(2, unit9)) 
     70    print("this unit1 %s ,its powerer %s , and value %s" % (unit1, 1, convert_unit(1, unit1))) 
     71    print("this unit2 %s ,its powerer %s , and value %s" % (unit2, 1, convert_unit(1, unit2))) 
     72    print("this unit3 %s ,its powerer %s , and value %s" % (unit3, 2, convert_unit(2, unit3))) 
     73    print("this unit4 %s ,its powerer %s , and value %s" % (unit4, -1, convert_unit(-1, unit4))) 
     74    print("this unit5 %s ,its powerer %s , and value %s" % (unit5, 2, convert_unit(2, unit5))) 
     75    print("this unit6 %s ,its powerer %s , and value %s" % (unit6, 2, convert_unit(2, unit6))) 
     76    print("this unit7 %s ,its powerer %s , and value %s" % (unit7, -1, convert_unit(-1, unit7))) 
     77    print("this unit8 %s ,its powerer %s , and value %s" % (unit8, 2, convert_unit(2, unit8))) 
     78    print("this unit9 %s ,its powerer %s , and value %s" % (unit9, 2, convert_unit(2, unit9))) 
    7979 
    8080 

  • src/sas/qtgui/Plotting/DataTransform.py

    rdc5ef15 rb0b09b9  
    2424    """ 
    2525    if not x > 0: 
    26         raise ValueError, "Transformation only accepts positive values." 
     26        raise ValueError("Transformation only accepts positive values.") 
    2727    else: 
    2828        return x 
    … …  
    5050    """ 
    5151    if not x >= 0: 
    52         raise ValueError, "square root of a negative value " 
     52        raise ValueError("square root of a negative value ") 
    5353    else: 
    5454        return math.sqrt(x) 
    … …  
    7676    """ 
    7777    if not x >= 0: 
    78         raise ValueError, "double square root of a negative value " 
     78        raise ValueError("double square root of a negative value ") 
    7979    else: 
    8080        return math.sqrt(math.sqrt(x)) 
    … …  
    9090    """ 
    9191    if not x > 0: 
    92         raise ValueError, "Log(x)of a negative value " 
     92        raise ValueError("Log(x)of a negative value ") 
    9393    else: 
    9494        return math.log(x) 
    … …  
    100100        return 1 / x 
    101101    else: 
    102         raise ValueError, "cannot divide by zero" 
     102        raise ValueError("cannot divide by zero") 
    103103 
    104104 
    … …  
    109109        return 1 / math.sqrt(y) 
    110110    else: 
    111         raise ValueError, "transform.toOneOverSqrtX: cannot be computed" 
     111        raise ValueError("transform.toOneOverSqrtX: cannot be computed") 
    112112 
    113113 
    … …  
    118118        return math.log(y * (x ** 2)) 
    119119    else: 
    120         raise ValueError, "transform.toLogYX2: cannot be computed" 
     120        raise ValueError("transform.toLogYX2: cannot be computed") 
    121121 
    122122 
    … …  
    127127        return math.log(math.pow(x, 4) * y) 
    128128    else: 
    129         raise ValueError, "transform.toLogYX4: input error" 
     129        raise ValueError("transform.toLogYX4: input error") 
    130130 
    131131 
    … …  
    149149    """ 
    150150    if not (x * y) > 0: 
    151         raise ValueError, "Log(X*Y)of a negative value " 
     151        raise ValueError("Log(X*Y)of a negative value ") 
    152152    else: 
    153153        return math.log(x * y) 
    … …  
    211211    else: 
    212212        msg = "transform.errFromX2: can't compute error of negative x" 
    213         raise ValueError, msg 
     213        raise ValueError(msg) 
    214214 
    215215 
    … …  
    245245    else: 
    246246        msg = "transform.errFromX4: can't compute error of negative x" 
    247         raise ValueError, msg 
     247        raise ValueError(msg) 
    248248 
    249249 
    … …  
    264264        msg = "Transformation does not accept" 
    265265        msg += " point that are consistent with zero." 
    266         raise ValueError, msg 
     266        raise ValueError(msg) 
    267267    if x != 0: 
    268268        dx = dx / (x * math.log(10)) 
    269269    else: 
    270         raise ValueError, "errToLogX: divide by zero" 
     270        raise ValueError("errToLogX: divide by zero") 
    271271    return dx 
    272272 
    … …  
    287287        dx = dx / x 
    288288    else: 
    289         raise ValueError, "errToLogX: divide by zero" 
     289        raise ValueError("errToLogX: divide by zero") 
    290290    return dx 
    291291 
    … …  
    312312        msg = "Transformation does not accept point " 
    313313        msg += " that are consistent with zero." 
    314         raise ValueError, msg 
     314        raise ValueError(msg) 
    315315    if x != 0 and y != 0: 
    316316        if dx == None: 
    … …  
    320320        err = (dx / x) ** 2 + (dy / y) ** 2 
    321321    else: 
    322         raise ValueError, "cannot compute this error" 
     322        raise ValueError("cannot compute this error") 
    323323 
    324324    return math.sqrt(math.fabs(err)) 
    … …  
    335335        msg = "Transformation does not accept point" 
    336336        msg += " that are consistent with zero." 
    337         raise ValueError, msg 
     337        raise ValueError(msg) 
    338338    if x > 0 and y > 0: 
    339339        if dx == None: 
    … …  
    343343        err = (2.0 * dx / x) ** 2 + (dy / y) ** 2 
    344344    else: 
    345         raise ValueError, "cannot compute this error" 
     345        raise ValueError("cannot compute this error") 
    346346    return math.sqrt(math.fabs(err)) 
    347347 
    … …  
    357357        err = dx / x ** 2 
    358358    else: 
    359         raise ValueError, "Cannot compute this error" 
     359        raise ValueError("Cannot compute this error") 
    360360    return math.fabs(err) 
    361361 
    … …  
    371371        err = -1 / 2 * math.pow(x, -3.0 / 2.0) * dx 
    372372    else: 
    373         raise ValueError, "Cannot compute this error" 
     373        raise ValueError("Cannot compute this error") 
    374374    return math.fabs(err) 
    375375 
    … …  
    387387        msg = "Transformation does not accept point " 
    388388        msg += " that are consistent with zero." 
    389         raise ValueError, msg 
     389        raise ValueError(msg) 
    390390    if dx == None: 
    391391        dx = 0 

  • src/sas/qtgui/Plotting/Fittings.py

    • Property mode changed from 100644 to 100755
    radc49fc rb0b09b9  
    9797    # Testing implementation 
    9898    # Fit a Line model 
    99     from LineModel import LineModel 
     99    from .LineModel import LineModel 
    100100    line = LineModel() 
    101101    cstA = Parameter(line, 'A', event.cstA) 
    … …  
    104104    chisqr, out, cov = sasfit(line, [cstA, cstB], event.x, y, 0) 
    105105    # print "Output parameters:", out 
    106     print "The right answer is [70.0, 1.0]" 
    107     print chisqr, out, cov 
     106    print("The right answer is [70.0, 1.0]") 
     107    print(chisqr, out, cov) 
    108108 

  • src/sas/qtgui/Plotting/LineModel.py

    rdc5ef15 rb0b09b9  
    8181        elif x.__class__.__name__ == 'tuple': 
    8282            msg = "Tuples are not allowed as input to BaseComponent models" 
    83             raise ValueError, msg 
     83            raise ValueError(msg) 
    8484        else: 
    8585            return self._line(x) 
    … …  
    103103        elif x.__class__.__name__ == 'tuple': 
    104104            msg = "Tuples are not allowed as input to BaseComponent models" 
    105             raise ValueError, msg 
     105            raise ValueError(msg) 
    106106        else: 
    107107            return self._line(x) 

  • src/sas/qtgui/Plotting/LinearFit.py

    • Property mode changed from 100644 to 100755
    rdc5ef15 rb0b09b9  
    7979        Overwrite default fit range label to correspond to actual unit 
    8080        """ 
    81         assert(isinstance(label, basestring)) 
     81        assert(isinstance(label, str)) 
    8282        self.lblRange.setText(label) 
    8383 
    … …  
    195195                         for i in range(len(x)) if x[i] >= xmin_check] 
    196196            else: 
    197                 tempy = map(numpy.log10, y) 
    198                 tempdy = map(lambda t1,t2:DataTransform.errToLogX(t1,0,t2,0),y,dy) 
     197                tempy = list(map(numpy.log10, y)) 
     198                tempdy = list(map(lambda t1,t2:DataTransform.errToLogX(t1,0,t2,0),y,dy)) 
    199199        else: 
    200200            tempy = y 

  • src/sas/qtgui/Plotting/PlotHelper.py

    • Property mode changed from 100644 to 100755
    r83eb5208 rb0b09b9  
    3535    Returns a list of IDs for all currently active plots 
    3636    """ 
    37     return this._plots.keys() 
     37    return list(this._plots.keys()) 
    3838 
    3939def plotById(plot_id): 
    … …  
    4848    """ 
    4949    plot_id = None 
    50     for key in this._plots.keys(): 
     50    for key in list(this._plots.keys()): 
    5151        if this._plots[key] == plot: 
    5252            plot_id = key 

  • src/sas/qtgui/Plotting/PlotProperties.py

    • Property mode changed from 100644 to 100755
    rcd2cc745 rb0b09b9  
    2626 
    2727        # Fill out the color combobox 
    28         self.cbColor.addItems(COLORS.keys()[:-1]) 
     28        self.cbColor.addItems(list(COLORS.keys())[:-1]) 
    2929        # data1d.custom_color can now be a simple integer, 
    3030        # specifying COLORS dict index or a string containing 
    … …  
    3434        else: 
    3535            # Need the Custom entry here. "Custom" is always last. 
    36             self.cbColor.addItems([COLORS.keys()[-1]]) 
    37             self.cbColor.setCurrentIndex(COLORS.keys().index("Custom")) 
     36            self.cbColor.addItems([list(COLORS.keys())[-1]]) 
     37            self.cbColor.setCurrentIndex(list(COLORS.keys()).index("Custom")) 
    3838 
    3939        # Fill out the marker combobox 
    40         self.cbShape.addItems(SHAPES.keys()) 
     40        self.cbShape.addItems(list(SHAPES.keys())) 
    4141        try: 
    4242            self.cbShape.setCurrentIndex(self._marker) 
    … …  
    8383            # Add Custom to the color combo box 
    8484            self.cbColor.addItems(["Custom"]) 
    85             self.cbColor.setCurrentIndex(COLORS.keys().index("Custom")) 
     85            self.cbColor.setCurrentIndex(list(COLORS.keys()).index("Custom")) 
    8686            # unblock currentIndexChanged 
    8787            self.cbColor.blockSignals(False) 

  • src/sas/qtgui/Plotting/PlotUtilities.py

    • Property mode changed from 100644 to 100755
    r83eb5208 rb0b09b9  
    273273        # Check if it's within the range 
    274274        if 0 <= color <=6: 
    275             color = COLORS.values()[color] 
     275            color = list(COLORS.values())[color] 
    276276    # Check if it's an RGB string 
    277277    elif isinstance(color, str): 

  • src/sas/qtgui/Plotting/Plottables.py

    rdc5ef15 rb0b09b9  
    239239        selected_color = None 
    240240        selected_plottable = None 
    241         for p in self.plottables.keys(): 
     241        for p in list(self.plottables.keys()): 
    242242            if plottable.id == p.id: 
    243243                selected_plottable = p 
    … …  
    384384 
    385385        """ 
    386         raise NotImplemented, "Not a valid transform" 
     386        raise NotImplemented("Not a valid transform") 
    387387 
    388388    # Related issues 
    … …  
    512512                label_dict[collection[0]] = basename 
    513513            else: 
    514                 for i in xrange(len(collection)): 
     514                for i in range(len(collection)): 
    515515                    label_dict[collection[i]] = "%s %d" % (basename, i) 
    516516        return label_dict 
    … …  
    684684                msg = "Plottable.View: Given x and dx are not" 
    685685                msg += " of the same length" 
    686                 raise ValueError, msg 
     686                raise ValueError(msg) 
    687687            # Check length of y array 
    688688            if not len(y) == len(x): 
    689689                msg = "Plottable.View: Given y " 
    690690                msg += "and x are not of the same length" 
    691                 raise ValueError, msg 
     691                raise ValueError(msg) 
    692692 
    693693            if not dy is None and not len(dy) == 0 and not len(y) == len(dy): 
    694694                msg = "Plottable.View: Given y and dy are not of the same " 
    695695                msg += "length: len(y)=%s, len(dy)=%s" % (len(y), len(dy)) 
    696                 raise ValueError, msg 
     696                raise ValueError(msg) 
    697697            self.x = [] 
    698698            self.y = [] 
    … …  
    729729                msg = "Plottable.View: transformed x " 
    730730                msg += "and y are not of the same length" 
    731                 raise ValueError, msg 
     731                raise ValueError(msg) 
    732732            if has_err_x and not (len(self.x) == len(self.dx)): 
    733733                msg = "Plottable.View: transformed x and dx" 
    734734                msg += " are not of the same length" 
    735                 raise ValueError, msg 
     735                raise ValueError(msg) 
    736736            if has_err_y and not (len(self.y) == len(self.dy)): 
    737737                msg = "Plottable.View: transformed y" 
    738738                msg += " and dy are not of the same length" 
    739                 raise ValueError, msg 
     739                raise ValueError(msg) 
    740740            # Check that negative values are not plot on x and y axis for 
    741741            # log10 transformation 
    … …  
    809809                except: 
    810810                    logging.error("check_data_logX: skipping point x %g", self.x[i]) 
    811                     logging.error(sys.exc_value) 
     811                    logging.error(sys.exc_info()[1]) 
    812812            self.x = tempx 
    813813            self.y = tempy 
    … …  
    839839                except: 
    840840                    logging.error("check_data_logY: skipping point %g", self.y[i]) 
    841                     logging.error(sys.exc_value) 
     841                    logging.error(sys.exc_info()[1]) 
    842842 
    843843            self.x = tempx 
    … …  
    11011101        Plottable.__init__(self) 
    11021102        msg = "Theory1D is no longer supported, please use Data1D and change symbol.\n" 
    1103         raise DeprecationWarning, msg 
     1103        raise DeprecationWarning(msg) 
    11041104 
    11051105class PlottableFit1D(Plottable): 

  • src/sas/qtgui/Plotting/Plotter.py

    • Property mode changed from 100644 to 100755
    rf0bb711 rb0b09b9  
    8787                marker = PlotUtilities.SHAPES[marker] 
    8888            except KeyError: 
    89                 marker = PlotUtilities.SHAPES.values()[marker] 
     89                marker = list(PlotUtilities.SHAPES.values())[marker] 
    9090 
    9191        assert marker is not None 
    … …  
    203203        Adds operations on all plotted sets of data to the context menu 
    204204        """ 
    205         for id in self.plot_dict.keys(): 
     205        for id in list(self.plot_dict.keys()): 
    206206            plot = self.plot_dict[id] 
    207207 
    … …  
    388388        Deletes the selected plot from the chart 
    389389        """ 
    390         if id not in self.plot_dict.keys(): 
     390        if id not in list(self.plot_dict.keys()): 
    391391            return 
    392392 
    … …  
    479479        """ 
    480480        # Transform all the plots on the chart 
    481         for id in self.plot_dict.keys(): 
     481        for id in list(self.plot_dict.keys()): 
    482482            current_plot = self.plot_dict[id] 
    483483            if current_plot.id == "fit": 

  • src/sas/qtgui/Plotting/SlicerModel.py

    • Property mode changed from 100644 to 100755
    r83eb5208 rb0b09b9  
    1919        self._model.removeRows( 0, self._model.rowCount() ) 
    2020        # Crete/overwrite model items 
    21         for parameter in parameters.keys(): 
     21        for parameter in list(parameters.keys()): 
    2222            item1 = QtGui.QStandardItem(parameter) 
    2323            item2 = QtGui.QStandardItem(GuiUtils.formatNumber(parameters[parameter])) 

  • src/sas/qtgui/Plotting/Slicers/AnnulusSlicer.py

    rdc5ef15 rb0b09b9  
    44 
    55import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    6 from BaseInteractor import BaseInteractor 
     6from .BaseInteractor import BaseInteractor 
    77from sas.qtgui.Plotting.PlotterData import Data1D 
    88from sas.qtgui.Utilities.GuiUtils import formatNumber 

  • src/sas/qtgui/Plotting/Slicers/Arc.py

    rdc5ef15 rb0b09b9  
    44import math 
    55 
    6 from BaseInteractor import BaseInteractor 
     6from .BaseInteractor import BaseInteractor 
    77 
    88class ArcInteractor(BaseInteractor): 

  • src/sas/qtgui/Plotting/Slicers/AzimutSlicer.py

    rdc5ef15 rb0b09b9  
    55# 
    66import math 
    7 from BaseInteractor import BaseInteractor 
     7from .BaseInteractor import BaseInteractor 
    88 
    99class SectorInteractor(BaseInteractor): 
    … …  
    2626 
    2727        # Inner circle 
    28         from Arc import ArcInteractor 
     28        from .Arc import ArcInteractor 
    2929        self.inner_circle = ArcInteractor(self, self.base.subplot, 
    3030                                          zorder=zorder, 

  • src/sas/qtgui/Plotting/Slicers/BoxSlicer.py

    rdc5ef15 rb0b09b9  
    33from PyQt4 import QtCore 
    44 
    5 from BaseInteractor import BaseInteractor 
     5from .BaseInteractor import BaseInteractor 
    66from sas.qtgui.Plotting.PlotterData import Data1D 
    77import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    … …  
    136136            if new_slab is None: 
    137137                msg = "post data:cannot average , averager is empty" 
    138                 raise ValueError, msg 
     138                raise ValueError(msg) 
    139139            self.averager = new_slab 
    140140        if self.direction == "X": 
    … …  
    152152        else: 
    153153            msg = "post data:no Box Average direction was supplied" 
    154             raise ValueError, msg 
     154            raise ValueError(msg) 
    155155        # # Average data2D given Qx or Qy 
    156156        box = self.averager(x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, 

  • src/sas/qtgui/Plotting/Slicers/BoxSum.py

    rdc5ef15 rb0b09b9  
    88from sas.qtgui.Utilities.GuiUtils import formatNumber 
    99 
    10 from BaseInteractor import BaseInteractor 
     10from .BaseInteractor import BaseInteractor 
    1111from sas.sascalc.dataloader.manipulations import Boxavg 
    1212from sas.sascalc.dataloader.manipulations import Boxsum 

  • src/sas/qtgui/Plotting/Slicers/SectorSlicer.py

    rdc5ef15 rb0b09b9  
    66from PyQt4 import QtCore 
    77 
    8 from BaseInteractor import BaseInteractor 
     8from .BaseInteractor import BaseInteractor 
    99from sas.qtgui.Plotting.PlotterData import Data1D 
    1010import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    … …  
    230230            msg = "Phi left and phi right are different" 
    231231            msg += " %f, %f" % (self.left_line.phi, self.right_line.phi) 
    232             raise ValueError, msg 
     232            raise ValueError(msg) 
    233233        params["Phi [deg]"] = self.main_line.theta * 180 / numpy.pi 
    234234        params["Delta_Phi [deg]"] = numpy.fabs(self.left_line.phi * 180 / numpy.pi) 

  • src/sas/qtgui/Utilities/CategoryInstaller.py

    r125c4be rb0b09b9  
    103103                master_category_dict[category].append(\ 
    104104                    (model, model_enabled_dict[model])) 
    105         return OrderedDict(sorted(master_category_dict.items(), key=lambda t: t[0])) 
     105        return OrderedDict(sorted(list(master_category_dict.items()), key=lambda t: t[0])) 
    106106 
    107107    @staticmethod 
    … …  
    126126        """ 
    127127        _model_dict = { model.name: model for model in model_list} 
    128         _model_list = _model_dict.keys() 
     128        _model_list = list(_model_dict.keys()) 
    129129 
    130130        serialized_file = None 
    … …  
    143143        add_list = _model_list 
    144144        del_name = False 
    145         for cat in master_category_dict.keys(): 
     145        for cat in list(master_category_dict.keys()): 
    146146            for ind in range(len(master_category_dict[cat])): 
    147147                model_name, enabled = master_category_dict[cat][ind] 
    … …  
    152152                        model_enabled_dict.pop(model_name) 
    153153                    except: 
    154                         logging.error("CategoryInstaller: %s", sys.exc_value) 
     154                        logging.error("CategoryInstaller: %s", sys.exc_info()[1]) 
    155155                else: 
    156156                    add_list.remove(model_name) 

  • src/sas/qtgui/Utilities/ConnectionProxy.py

    rdc5ef15 rb0b09b9  
    11#!/usr/bin/env python 
    22# -*- coding: utf-8 -*- 
    3 import urllib2 
     3import urllib.request, urllib.error, urllib.parse 
    44import sys 
    55import json 
    … …  
    3333        if sys.platform == 'win32': 
    3434            try: 
    35                 import _winreg as winreg  # used from python 2.0-2.6 
     35                import winreg as winreg  # used from python 2.0-2.6 
    3636            except: 
    3737                import winreg  # used from python 2.7 onwards 
    … …  
    4545                this_name, this_val, this_type = winreg.EnumValue(net, i) 
    4646                subkeys[this_name] = this_val 
    47             if 'AutoConfigURL' in subkeys.keys() and len(subkeys['AutoConfigURL']) > 0: 
     47            if 'AutoConfigURL' in list(subkeys.keys()) and len(subkeys['AutoConfigURL']) > 0: 
    4848                pac_files.append(subkeys['AutoConfigURL']) 
    4949        elif sys.platform == 'darwin': 
    … …  
    5353            networks = sys_prefs['NetworkServices'] 
    5454            # loop through each possible network (e.g. Ethernet, Airport...) 
    55             for network in networks.items(): 
     55            for network in list(networks.items()): 
    5656                # the first part is a long identifier 
    5757                net_key, network = network 
    58                 if 'ProxyAutoConfigURLString' in network['Proxies'].keys(): 
     58                if 'ProxyAutoConfigURLString' in list(network['Proxies'].keys()): 
    5959                    pac_files.append( 
    6060                        network['Proxies']['ProxyAutoConfigURLString']) 
    … …  
    7373            logging.debug('Trying pac file (%s)...' % this_pac_url) 
    7474            try: 
    75                 response = urllib2.urlopen( 
     75                response = urllib.request.urlopen( 
    7676                    this_pac_url, timeout=self.timeout) 
    7777                logging.debug('Succeeded (%s)...' % this_pac_url) 
    … …  
    101101            # information is retrieved from the OS X System Configuration 
    102102            # Framework. 
    103             proxy = urllib2.ProxyHandler() 
     103            proxy = urllib.request.ProxyHandler() 
    104104        else: 
    105105            # If proxies is given, it must be a dictionary mapping protocol names to 
    106106            # URLs of proxies. 
    107             proxy = urllib2.ProxyHandler(proxy_dic) 
    108         opener = urllib2.build_opener(proxy) 
    109         urllib2.install_opener(opener) 
     107            proxy = urllib.request.ProxyHandler(proxy_dic) 
     108        opener = urllib.request.build_opener(proxy) 
     109        urllib.request.install_opener(opener) 
    110110 
    111111    def connect(self): 
    … …  
    114114        @return: response object from urllib2.urlopen 
    115115        ''' 
    116         req = urllib2.Request(self.url) 
     116        req = urllib.request.Request(self.url) 
    117117        response = None 
    118118        try: 
    119119            logging.debug("Trying Direct connection to %s..."%self.url) 
    120             response = urllib2.urlopen(req, timeout=self.timeout) 
    121         except Exception, e: 
     120            response = urllib.request.urlopen(req, timeout=self.timeout) 
     121        except Exception as e: 
    122122            logging.debug("Failed!") 
    123123            logging.debug(e) 
    … …  
    125125                logging.debug("Trying to use system proxy if it exists...") 
    126126                self._set_proxy() 
    127                 response = urllib2.urlopen(req, timeout=self.timeout) 
    128             except Exception, e: 
     127                response = urllib.request.urlopen(req, timeout=self.timeout) 
     128            except Exception as e: 
    129129                logging.debug("Failed!") 
    130130                logging.debug(e) 
    … …  
    135135                        logging.debug("Trying to use the proxy %s found in proxy.pac configuration"%proxy) 
    136136                        self._set_proxy(proxy) 
    137                         response = urllib2.urlopen(req, timeout=self.timeout) 
    138                     except Exception, e: 
     137                        response = urllib.request.urlopen(req, timeout=self.timeout) 
     138                    except Exception as e: 
    139139                        logging.debug("Failed!") 
    140140                        logging.debug(e) 
    … …  
    151151    response = c.connect() 
    152152    if response is not None: 
    153         print 50 * '-' 
     153        print(50 * '-') 
    154154        content = json.loads(response.read().strip()) 
    155155        pprint(content) 

  • src/sas/qtgui/Utilities/GuiUtils.py

    • Property mode changed from 100644 to 100755
    r88e1f57 rb0b09b9  
    99import warnings 
    1010import webbrowser 
    11 import urlparse 
     11import urllib.parse 
    1212 
    1313warnings.simplefilter("ignore") 
    … …  
    8686        #logging.error("Error loading %s/%s: %s" % (path, confg_file, sys.exc_value)) 
    8787    except ValueError: 
    88         print "Value error" 
     88        print("Value error") 
    8989        pass 
    9090    finally: 
    … …  
    242242    """ 
    243243    assert isinstance(item, QtGui.QStandardItem) 
    244     assert isinstance(update_data, QtCore.QVariant) 
    245     py_update_data = update_data.toPyObject() 
     244    #assert isinstance(update_data, QtCore.QVariant) 
     245    #py_update_data = update_data.toPyObject() 
     246    py_update_data = update_data 
    246247 
    247248    # Check if data with the same ID is already present 
    … …  
    249250        plot_item = item.child(index) 
    250251        if plot_item.isCheckable(): 
    251             plot_data = plot_item.child(0).data().toPyObject() 
     252            plot_data = plot_item.child(0).data() #.toPyObject() 
    252253            if plot_data.id is not None and plot_data.id == py_update_data.id: 
    253254                # replace data section in item 
    … …  
    270271    Adds QVariant 'update_data' to that row. 
    271272    """ 
    272     assert isinstance(update_data, QtCore.QVariant) 
    273     py_update_data = update_data.toPyObject() 
     273    #assert isinstance(update_data, QtCore.QVariant) 
     274    #py_update_data = update_data.toPyObject() 
     275    py_update_data = update_data 
    274276 
    275277    checkbox_item = QtGui.QStandardItem() 
    … …  
    309311    object_item = QtGui.QStandardItem() 
    310312    object_item.setText(name) 
    311     object_item.setData(QtCore.QVariant(update_data)) 
     313    #object_item.setData(QtCore.QVariant(update_data)) 
     314    object_item.setData(update_data) 
    312315 
    313316    # Append the new row to the main item 
    … …  
    319322    """ 
    320323    assert isinstance(model_item, QtGui.QStandardItemModel) 
    321     assert isinstance(filename, basestring) 
     324    assert isinstance(filename, str) 
    322325 
    323326    # Iterate over model looking for named items 
    324     item = list(filter(lambda i: str(i.text()) == filename, 
    325                   [model_item.item(index) for index in range(model_item.rowCount())])) 
     327    item = list([i for i in [model_item.item(index) for index in range(model_item.rowCount())] if str(i.text()) == filename]) 
    326328    return item[0] if len(item)>0 else None 
    327329 
    … …  
    331333    """ 
    332334    assert isinstance(model_item, QtGui.QStandardItemModel) 
    333     assert isinstance(filename, basestring) 
     335    assert isinstance(filename, str) 
    334336 
    335337    plot_data = [] 
    … …  
    339341        if str(item.text()) == filename: 
    340342            # TODO: assure item type is correct (either data1/2D or Plotter) 
    341             plot_data.append(item.child(0).data().toPyObject()) 
     343            plot_data.append(item.child(0).data()) #.toPyObject()) 
    342344            # Going 1 level deeper only 
    343345            for index_2 in range(item.rowCount()): 
    … …  
    345347                if item_2 and item_2.isCheckable(): 
    346348                    # TODO: assure item type is correct (either data1/2D or Plotter) 
    347                     plot_data.append(item_2.child(0).data().toPyObject()) 
     349                    plot_data.append(item_2.child(0).data()) #.toPyObject()) 
    348350 
    349351    return plot_data 
    … …  
    361363        if item.isCheckable() and item.checkState() == QtCore.Qt.Checked: 
    362364            # TODO: assure item type is correct (either data1/2D or Plotter) 
    363             plot_data.append((item, item.child(0).data().toPyObject())) 
     365            plot_data.append((item, item.child(0).data())) #.toPyObject())) 
    364366        # Going 1 level deeper only 
    365367        for index_2 in range(item.rowCount()): 
    … …  
    367369            if item_2 and item_2.isCheckable() and item_2.checkState() == QtCore.Qt.Checked: 
    368370                # TODO: assure item type is correct (either data1/2D or Plotter) 
    369                 plot_data.append((item_2, item_2.child(0).data().toPyObject())) 
     371                plot_data.append((item_2, item_2.child(0).data())) #.toPyObject())) 
    370372 
    371373    return plot_data 
    … …  
    419421    Check the URL first, though. 
    420422    """ 
    421     parsed_url = urlparse.urlparse(url) 
     423    parsed_url = urllib.parse.urlparse(url) 
    422424    if parsed_url.scheme: 
    423425        webbrowser.open(url) 
    424426    else: 
    425427        msg = "Attempt at opening an invalid URL" 
    426         raise AttributeError, msg 
     428        raise AttributeError(msg) 
    427429 
    428430def retrieveData1d(data): 
    … …  
    433435    if not isinstance(data, Data1D): 
    434436        msg = "Incorrect type passed to retrieveData1d" 
    435         raise AttributeError, msg 
     437        raise AttributeError(msg) 
    436438    try: 
    437439        xmin = min(data.x) 
    … …  
    441443                    data.filename 
    442444        #logging.error(msg) 
    443         raise ValueError, msg 
     445        raise ValueError(msg) 
    444446 
    445447    text = data.__str__() 
    … …  
    485487    if not isinstance(data, Data2D): 
    486488        msg = "Incorrect type passed to retrieveData2d" 
    487         raise AttributeError, msg 
     489        raise AttributeError(msg) 
    488490 
    489491    text = data.__str__() 
    … …  
    499501    dy_val = 0.0 
    500502    len_data = len(data.qx_data) 
    501     for index in xrange(0, len_data): 
     503    for index in range(0, len_data): 
    502504        x_val = data.qx_data[index] 
    503505        y_val = data.qy_data[index] 
    … …  
    756758    The assumption - data stored in SasView standard, in child 0 
    757759    """ 
    758     return item.child(0).data().toPyObject() 
     760    return item.child(0).data() #.toPyObject() 
    759761 
    760762def formatNumber(value, high=False): 

  • src/sas/qtgui/Utilities/LocalConfig.py

    • Property mode changed from 100644 to 100755
    rdc5ef15 rb0b09b9  
    139139    """ 
    140140    if __EVT_DEBUG__: 
    141         print "%g:  %s" % (time.clock(), message) 
     141        print("%g:  %s" % (time.clock(), message)) 
    142142 
    143143        if __EVT_DEBUG_2_FILE__: 

  • src/sas/qtgui/Utilities/ObjectLibrary.py

    r61a92d4 rb0b09b9  
    99 
    1010def deleteObjectByRef(obj): 
    11     for name, object in this._objects.iteritems(): 
     11    for name, object in this._objects.items(): 
    1212        if object == obj: 
    1313            del this._objects[name] 
    … …  
    2222 
    2323def listObjects(): 
    24     return this._objects.keys() 
     24    return list(this._objects.keys()) 
    2525 
    2626 

  • src/sas/qtgui/Utilities/SasviewLogger.py

    • Property mode changed from 100644 to 100755
    r83eb5208 rb0b09b9  
    1919    def write(self, msg): 
    2020        if(not self.signalsBlocked()): 
    21             self.messageWritten.emit(unicode(msg)) 
     21            self.messageWritten.emit(str(msg)) 
    2222 
    2323    @staticmethod 

  • src/sas/qtgui/convertUI.py

    rcd2cc745 rb0b09b9  
    88 
    99def pyuic(in_file, out_file): 
    10     """ Run the pyuic4 script""" 
     10    """ Run the pyuic5 script""" 
    1111    execute = 'pyuic4 -o %s %s' % (out_file, in_file) 
    1212    os.system(execute) 

  • src/sas/sascalc/fit/expression.py

    r574adc7 rb0b09b9  
    210210 
    211211    #print("Function: "+functiondef) 
    212     exec functiondef in globals,locals 
     212    exec (functiondef in globals,locals) 
    213213    retfn = locals['eval_expressions'] 
    214214 
Note: See TracChangeset for help on using the changeset viewer.