Changeset fa81e94 in sasview for src/sas/sasgui/perspectives


Ignore:
Timestamp:
Nov 15, 2017 4:33:09 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:
d4881f6a
Parents:
7c487846
Message:

Initial commit of the P(r) inversion perspective.
Code merged from Jeff Krzywon's ESS_GUI_Pr branch.
Also, minor 2to3 mods to sascalc/sasgui to enble error free setup.

Location:
src/sas/sasgui/perspectives
Files:
41 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sasgui/perspectives/calculator/__init__.py

    • Property mode changed from 100644 to 100755
    r5a405bd rfa81e94  
    22import os 
    33from distutils.filelist import findall 
    4 from calculator import * 
     4from .calculator import * 
    55N_DIR = 12 
    66def get_data_path(media): 
  • src/sas/sasgui/perspectives/calculator/collimation_editor.py

    • Property mode changed from 100644 to 100755
    r959eb01 rfa81e94  
    66from sas.sascalc.dataloader.loader import Loader 
    77from sas.sascalc.dataloader.data_info import Aperture, Collimation 
    8 from aperture_editor import ApertureDialog 
     8from .aperture_editor import ApertureDialog 
    99 
    1010from sas.sasgui.guiframe.utils import check_float 
  • src/sas/sasgui/perspectives/calculator/data_editor.py

    • Property mode changed from 100644 to 100755
    r235f514 rfa81e94  
    77from sas.sascalc.dataloader.loader import Loader 
    88from sas.sascalc.dataloader.data_info import Data2D 
    9 from detector_editor import DetectorDialog 
    10 from collimation_editor import CollimationDialog 
    11 from console import ConsoleDialog 
     9from .detector_editor import DetectorDialog 
     10from .collimation_editor import CollimationDialog 
     11from .console import ConsoleDialog 
    1212 
    1313from sas.sasgui.guiframe.events import StatusEvent 
     
    397397        if data is None: 
    398398            return 
    399         from sample_editor import SampleDialog 
     399        from .sample_editor import SampleDialog 
    400400        dlg = SampleDialog(parent=self, sample=data.sample) 
    401401        dlg.set_manager(self) 
     
    409409        if data is None: 
    410410            return 
    411         from source_editor import SourceDialog 
     411        from .source_editor import SourceDialog 
    412412        dlg = SourceDialog(parent=self, source=data.source) 
    413413        dlg.set_manager(self) 
     
    527527        try: 
    528528            #Load data 
    529             from load_thread import DataReader 
     529            from .load_thread import DataReader 
    530530            ## If a thread is already started, stop it 
    531531            if self.reader is not None and self.reader.isrunning(): 
     
    536536            self.reader.queue() 
    537537        except: 
    538             msg = "Data Editor: %s" % (sys.exc_value) 
     538            msg = "Data Editor: %s" % (sys.exc_info()[1]) 
    539539            load_error(msg) 
    540540            return 
  • src/sas/sasgui/perspectives/calculator/data_operator.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    202202        else: 
    203203            text = name 
    204         state_list = self.get_datalist().values() 
     204        state_list = list(self.get_datalist().values()) 
    205205        name_list = [] 
    206206        for state in state_list: 
    207207            if state.data is None: 
    208208                theory_list = state.get_theory() 
    209                 theory, _ = theory_list.values()[0] 
     209                theory, _ = list(theory_list.values())[0] 
    210210                d_name = str(theory.name) 
    211211            else: 
     
    397397            self._set_textctrl_color(self.data1_cbox, 'pink') 
    398398            self._set_textctrl_color(self.data2_cbox, 'pink') 
    399             msg = "DataOperation: %s" % sys.exc_value 
     399            msg = "DataOperation: %s" % sys.exc_info()[1] 
    400400            self.send_warnings(msg, 'error') 
    401401            self.output = None 
     
    411411        operator = self.operator_cbox.GetClientData(pos) 
    412412        try: 
    413             exec "output = data1 %s data2" % operator 
     413            exec("output = data1 %s data2" % operator) 
    414414        except: 
    415415            raise 
     
    532532        self.data2_cbox.SetClientData(pos3, val) 
    533533        dnames = [] 
    534         ids = self._data.keys() 
     534        ids = list(self._data.keys()) 
    535535        for id in ids: 
    536536            if id is not None: 
     
    539539                else: 
    540540                    theory_list = self._data[id].get_theory() 
    541                     theory, _ = theory_list.values()[0] 
     541                    theory, _ = list(theory_list.values())[0] 
    542542                    dnames.append(theory.name) 
    543543        ind = np.argsort(dnames) 
    544544        if len(ind) > 0: 
    545             val_list = np.array(self._data.values())[ind] 
     545            val_list = np.array(list(self._data.values()))[ind] 
    546546            for datastate in val_list: 
    547547                data = datastate.data 
     
    558558                try: 
    559559                    theory_list = datastate.get_theory() 
    560                     for theory, _ in theory_list.values(): 
     560                    for theory, _ in list(theory_list.values()): 
    561561                        th_name = theory.name 
    562562                        posth1 = self.data1_cbox.Append(str(th_name)) 
     
    588588        self.send_warnings('') 
    589589        self.data_namectr.SetBackgroundColour('white') 
    590         state_list = self.get_datalist().values() 
     590        state_list = list(self.get_datalist().values()) 
    591591        name = self.data_namectr.GetValue().strip() 
    592592        name_list = [] 
     
    594594            if state.data is None: 
    595595                theory_list = state.get_theory() 
    596                 theory, _ = theory_list.values()[0] 
     596                theory, _ = list(theory_list.values())[0] 
    597597                d_name = str(theory.name) 
    598598            else: 
     
    896896        list = [] 
    897897        list = self.graph.returnPlottable() 
    898         if len(list.keys()) > 0: 
    899             first_item = list.keys()[0] 
     898        if len(list(list.keys())) > 0: 
     899            first_item = list(list.keys())[0] 
    900900            if first_item.x != []: 
    901901                from sas.sasgui.plottools.PropertyDialog import Properties 
  • src/sas/sasgui/perspectives/calculator/density_panel.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    364364        except: 
    365365            if self.base is not None: 
    366                 msg = "Density/Volume Calculator: %s" % (sys.exc_value) 
     366                msg = "Density/Volume Calculator: %s" % (sys.exc_info()[1]) 
    367367                wx.PostEvent(self.base, StatusEvent(status=msg)) 
    368368        if event is not None: 
  • src/sas/sasgui/perspectives/calculator/detector_editor.py

    • Property mode changed from 100644 to 100755
    ra1b8fee rfa81e94  
    1 from __future__ import print_function 
     1 
    22 
    33import wx 
     
    3535            self.set_values() 
    3636        except: 
    37             print("error", sys.exc_value) 
     37            print("error", sys.exc_info()[1]) 
    3838 
    3939    def _define_structure(self): 
  • src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py

    • Property mode changed from 100644 to 100755
    ra1b8fee rfa81e94  
    33This module relies on guiframe manager. 
    44""" 
    5 from __future__ import print_function 
     5 
    66 
    77import wx 
     
    228228        sizer.Add(unit_title, (iy, ix), (1, 1), \ 
    229229                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    230         key_list = params.keys() 
     230        key_list = list(params.keys()) 
    231231        key_list.sort() 
    232232        for param in key_list: 
     
    560560            if self.parent.parent is None: 
    561561                return 
    562             msg = "Generic SAS Calculator: %s" % (sys.exc_value) 
     562            msg = "Generic SAS Calculator: %s" % (sys.exc_info()[1]) 
    563563            wx.PostEvent(self.parent.parent, 
    564564                          StatusEvent(status=msg, type='stop')) 
     
    761761        # II. Plot selective points in color 
    762762        other_color = np.ones(len(pix_symbol), dtype='bool') 
    763         for key in color_dic.keys(): 
     763        for key in list(color_dic.keys()): 
    764764            chosen_color = pix_symbol == key 
    765765            if np.any(chosen_color): 
     
    775775                # Get atom names not in the list 
    776776                a_names = [symb  for symb in pix_symbol \ 
    777                            if symb not in color_dic.keys()] 
     777                           if symb not in list(color_dic.keys())] 
    778778                a_name = a_names[0] 
    779779                for name in a_names: 
     
    899899 
    900900        except: 
    901             msg = "%s." % sys.exc_value 
     901            msg = "%s." % sys.exc_info()[1] 
    902902            status_type = 'stop' 
    903903            self._status_info(msg, status_type) 
     
    12851285            else: 
    12861286               sld_sets[list[0]] = None 
    1287         for key in sld_sets.keys(): 
     1287        for key in list(sld_sets.keys()): 
    12881288            key_low = key.lower() 
    12891289            if key_low.count('mx') > 0: 
     
    13361336                    return 
    13371337 
    1338             for key in sets.keys(): 
     1338            for key in list(sets.keys()): 
    13391339                setattr(omfdata, key, sets[key]) 
    13401340 
     
    13451345            self.sld_data.filename = "Default SLD Profile" 
    13461346        except: 
    1347             msg = "OMF Panel: %s" % sys.exc_value 
     1347            msg = "OMF Panel: %s" % sys.exc_info()[1] 
    13481348            infor = 'Error' 
    13491349            #logger.error(msg) 
     
    13751375        step_list = self._get_step_key_list(omfdata) 
    13761376        for ctr_list in self.nodes: 
    1377             for key in nodes_list.keys(): 
     1377            for key in list(nodes_list.keys()): 
    13781378                if ctr_list[0] == key: 
    13791379                    ctr_list[1].SetValue(format_number(nodes_list[key], True)) 
     
    13811381                    break 
    13821382        for ctr_list in self.stepsize: 
    1383             for key in step_list.keys(): 
     1383            for key in list(step_list.keys()): 
    13841384                if ctr_list[0] == key: 
    13851385                    ctr_list[1].SetValue(format_number(step_list[key], True)) 
     
    14421442        sld_key_list = self._get_slds_key_list(omfdata) 
    14431443        # Dic is not sorted 
    1444         key_list = [key for key in sld_key_list.keys()] 
     1444        key_list = [key for key in list(sld_key_list.keys())] 
    14451445        # Sort here 
    14461446        key_list.sort() 
     
    14851485        ix = 0 
    14861486        iy = -1 
    1487         for key, value in key_list.iteritems(): 
     1487        for key, value in key_list.items(): 
    14881488            iy += 1 
    14891489            ix = 0 
     
    15211521        iy = -1 
    15221522        #key_list.sort() 
    1523         for key, value in key_list.iteritems(): 
     1523        for key, value in key_list.items(): 
    15241524            iy += 1 
    15251525            ix = 0 
     
    16411641        sld_list = self._get_slds_key_list(sld_data) 
    16421642        for ctr_list in self.slds: 
    1643             for key in sld_list.keys(): 
     1643            for key in list(sld_list.keys()): 
    16441644                if ctr_list[0] == key: 
    16451645                    min_val = np.min(sld_list[key]) 
  • src/sas/sasgui/perspectives/calculator/image_viewer.py

    • Property mode changed from 100644 to 100755
    r412e9e8b rfa81e94  
    1 from __future__ import print_function 
     1 
    22 
    33import os 
  • src/sas/sasgui/perspectives/calculator/kiessig_calculator_panel.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    1414from sas.sasgui.guiframe.panel_base import PanelBase 
    1515from sas.sascalc.calculator.kiessig_calculator import KiessigThicknessCalculator 
    16 from calculator_widgets import OutputTextCtrl 
    17 from calculator_widgets import InputTextCtrl 
     16from .calculator_widgets import OutputTextCtrl 
     17from .calculator_widgets import InputTextCtrl 
    1818from sas.sasgui.perspectives.calculator import calculator_widgets as widget 
    1919from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
  • src/sas/sasgui/perspectives/calculator/model_editor.py

    • Property mode changed from 100644 to 100755
    r69363c7 rfa81e94  
    2323#copyright 2009, University of Tennessee 
    2424################################################################################ 
    25 from __future__ import print_function 
     25 
    2626 
    2727import wx 
     
    790790            if item.count("_") < 1: 
    791791                try: 
    792                     exec "float(math.%s)" % item 
     792                    exec("float(math.%s)" % item) 
    793793                    self.math_combo.Append(str(item)) 
    794794                except Exception: 
  • src/sas/sasgui/perspectives/calculator/resolution_calculator_panel.py

    • Property mode changed from 100644 to 100755
    r01cda57 rfa81e94  
    148148        # Custom sorting 
    149149        source_list = [] 
    150         for key, _ in self.source_mass.iteritems(): 
     150        for key, _ in self.source_mass.items(): 
    151151            name_source = str(key) 
    152152            source_list.append(name_source) 
     
    10821082                msg = "The numbers must be one or two (separated by ',')..." 
    10831083                self._status_info(msg, 'stop') 
    1084                 raise RuntimeError, msg 
     1084                raise RuntimeError(msg) 
    10851085 
    10861086        return new_string 
     
    11001100                new_string.append(value) 
    11011101            except: 
    1102                 logger.error(sys.exc_value) 
     1102                logger.error(sys.exc_info()[1]) 
    11031103 
    11041104        return new_string 
     
    11421142                        return out 
    11431143                except: 
    1144                     logger.error(sys.exc_value) 
     1144                    logger.error(sys.exc_info()[1]) 
    11451145 
    11461146    def _on_xy_coordinate(self, event=None): 
     
    12691269            try: 
    12701270                basename = os.path.basename(path) 
    1271                 if basename not in self.spectrum_dic.keys(): 
     1271                if basename not in list(self.spectrum_dic.keys()): 
    12721272                    self.spectrum_cb.Append(basename) 
    12731273                self.spectrum_dic[basename] = self._read_file(path) 
     
    13201320                except: 
    13211321                    # Skip non-data lines 
    1322                     logger.error(sys.exc_value) 
     1322                    logger.error(sys.exc_info()[1]) 
    13231323 
    13241324            return [wavelength, intensity] 
  • src/sas/sasgui/perspectives/calculator/sld_panel.py

    • Property mode changed from 100644 to 100755
    r2d220dd rfa81e94  
    366366        if len(myformula.atoms) != 1: 
    367367            return 
    368         element = myformula.atoms.keys()[0] 
     368        element = list(myformula.atoms.keys())[0] 
    369369        energy = xray_energy(element.K_alpha) 
    370370 
     
    450450        if len(element_formula.atoms) != 1: 
    451451            return 
    452         element = element_formula.atoms.keys()[0] 
     452        element = list(element_formula.atoms.keys())[0] 
    453453        energy = xray_energy(element.K_alpha) 
    454454        atom = molecule_formula.atoms 
     
    507507        except: 
    508508            if self.base is not None: 
    509                 msg = "SLD Calculator: %s" % (sys.exc_value) 
     509                msg = "SLD Calculator: %s" % (sys.exc_info()[1]) 
    510510                wx.PostEvent(self.base, StatusEvent(status=msg)) 
    511511        if event is not None: 
  • src/sas/sasgui/perspectives/calculator/slit_length_calculator_panel.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    1717from sas.sasgui.guiframe.events import StatusEvent 
    1818from sas.sascalc.calculator.slit_length_calculator import SlitlengthCalculator 
    19 from calculator_widgets import OutputTextCtrl 
    20 from calculator_widgets import InterActiveOutputTextCtrl 
     19from .calculator_widgets import OutputTextCtrl 
     20from .calculator_widgets import InterActiveOutputTextCtrl 
    2121from sas.sasgui.perspectives.calculator import calculator_widgets as widget 
    2222from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     
    210210        try: 
    211211            #Load data 
    212             from load_thread import DataReader 
     212            from .load_thread import DataReader 
    213213            ## If a thread is already started, stop it 
    214214            if self.reader is not None and self.reader.isrunning(): 
     
    226226            if self.parent.parent is None: 
    227227                return 
    228             msg = "Slit Length Calculator: %s" % (sys.exc_value) 
     228            msg = "Slit Length Calculator: %s" % (sys.exc_info()[1]) 
    229229            wx.PostEvent(self.parent.parent, 
    230230                          StatusEvent(status=msg, type='stop')) 
     
    262262            if x == [] or  x is None or y == [] or y is None: 
    263263                msg = "The current data is empty please check x and y" 
    264                 raise ValueError, msg 
     264                raise ValueError(msg) 
    265265            slit_length_calculator = SlitlengthCalculator() 
    266266            slit_length_calculator.set_data(x=x, y=y) 
     
    269269            if self.parent.parent is None: 
    270270                return 
    271             msg = "Slit Size Calculator: %s" % (sys.exc_value) 
     271            msg = "Slit Size Calculator: %s" % (sys.exc_info()[1]) 
    272272            wx.PostEvent(self.parent.parent, 
    273273                          StatusEvent(status=msg, type='stop')) 
  • src/sas/sasgui/perspectives/corfunc/__init__.py

    • Property mode changed from 100644 to 100755
    rc23f303 rfa81e94  
    11PLUGIN_ID = "Corfunc Plug-In 0.1" 
    2 from corfunc import * 
     2from .corfunc import * 
  • src/sas/sasgui/perspectives/corfunc/corfunc.py

    • Property mode changed from 100644 to 100755
    r9b90bf8 rfa81e94  
    1818from sas.sascalc.dataloader.loader import Loader 
    1919import sas.sascalc.dataloader 
    20 from plot_labels import * 
     20from .plot_labels import * 
    2121 
    2222logger = logging.getLogger(__name__) 
     
    149149                    self.corfunc_panel.set_data(data) 
    150150                except: 
    151                     msg = "Corfunc set_data: " + str(sys.exc_value) 
     151                    msg = "Corfunc set_data: " + str(sys.exc_info()[1]) 
    152152                    wx.PostEvent(self.parent, StatusEvent(status=msg, 
    153153                        info='error')) 
  • src/sas/sasgui/perspectives/corfunc/corfunc_panel.py

    • Property mode changed from 100644 to 100755
    r2a399ca rfa81e94  
    1717from sas.sascalc.corfunc.corfunc_calculator import CorfuncCalculator 
    1818from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
    19 from plot_labels import * 
     19from .plot_labels import * 
    2020 
    2121OUTPUT_STRINGS = { 
     
    393393        if params is None: 
    394394            # Reset outputs 
    395             for output in self._extrapolation_outputs.values(): 
     395            for output in list(self._extrapolation_outputs.values()): 
    396396                output.SetValue('-') 
    397397            return 
    398         for key, value in params.iteritems(): 
     398        for key, value in params.items(): 
    399399            output = self._extrapolation_outputs[key] 
    400400            rounded = self._round_sig_figs(value, 6) 
     
    411411        if params is None: 
    412412            if not reset: error = True 
    413             for output in self._output_boxes.values(): 
     413            for output in list(self._output_boxes.values()): 
    414414                output.SetValue('-') 
    415415        else: 
     
    417417                # Not all parameters were calculated 
    418418                error = True 
    419             for key, value in params.iteritems(): 
     419            for key, value in params.items(): 
    420420                rounded = self._round_sig_figs(value, 6) 
    421421                self._output_boxes[key].SetValue(rounded) 
     
    656656        self._extrapolation_outputs['K'] = k_output 
    657657 
    658         sigma_label = wx.StaticText(self, -1, u'\u03C3: ') 
     658        sigma_label = wx.StaticText(self, -1, '\u03C3: ') 
    659659        params_sizer.Add(sigma_label, (2, 2), (1, 1), wx.LEFT | wx.EXPAND, 15) 
    660660 
     
    713713        self._output_boxes = dict() 
    714714        i = 0 
    715         for key, value in OUTPUT_STRINGS.iteritems(): 
     715        for key, value in OUTPUT_STRINGS.items(): 
    716716            # Create a label and a text box for each poperty 
    717717            label = wx.StaticText(self, -1, value) 
  • src/sas/sasgui/perspectives/corfunc/corfunc_state.py

    • Property mode changed from 100644 to 100755
    r1fa4f736 rfa81e94  
    7474        if self.outputs != {} and self.outputs is not None: 
    7575            state += "\nOutputs:\n" 
    76             for key, value in self.outputs.iteritems(): 
     76            for key, value in self.outputs.items(): 
    7777                name = output_list[key][1] 
    7878                state += "{}: {}\n".format(name, str(value)) 
     
    158158        state = new_doc.createElement("state") 
    159159        top_element.appendChild(state) 
    160         for name, value in self.saved_state.iteritems(): 
     160        for name, value in self.saved_state.items(): 
    161161            element = new_doc.createElement(name) 
    162162            element.appendChild(new_doc.createTextNode(str(value))) 
     
    181181            output = new_doc.createElement("output") 
    182182            top_element.appendChild(output) 
    183             for key, value in self.outputs.iteritems(): 
     183            for key, value in self.outputs.items(): 
    184184                element = new_doc.createElement(key) 
    185185                element.appendChild(new_doc.createTextNode(str(value))) 
     
    216216                except: 
    217217                    msg = ("CorfuncState.fromXML: Could not read timestamp", 
    218                         "\n{}").format(sys.exc_value) 
     218                        "\n{}").format(sys.exc_info()[1]) 
    219219                    logger.error(msg) 
    220220 
     
    222222            entry = get_content('ns:state', node) 
    223223            if entry is not None: 
    224                 for item in DEFAULT_STATE.iterkeys(): 
     224                for item in DEFAULT_STATE.keys(): 
    225225                    input_field = get_content("ns:{}".format(item), entry) 
    226226                    if input_field is not None: 
     
    283283            root, ext = os.path.splitext(basename) 
    284284            if not ext.lower() in self.ext: 
    285                 raise IOError, "{} is not a supported file type".format(ext) 
     285                raise IOError("{} is not a supported file type".format(ext)) 
    286286            tree = etree.parse(path, parser=etree.ETCompatXMLParser()) 
    287287            root = tree.getroot() 
     
    299299            # File not found 
    300300            msg = "{} is not a valid file path or doesn't exist".format(path) 
    301             raise IOError, msg 
     301            raise IOError(msg) 
    302302 
    303303        if len(output) == 0: 
     
    323323            msg = ("The CanSAS writer expects a Data1D instance. {} was " 
    324324                "provided").format(datainfo.__class__.__name__) 
    325             raise RuntimeError, msg 
     325            raise RuntimeError(msg) 
    326326        if datainfo.title is None or datainfo.title == '': 
    327327            datainfo.title = datainfo.name 
     
    360360        except: 
    361361            msg = "XML document does not contain CorfuncState information\n{}" 
    362             msg.format(sys.exc_value) 
     362            msg.format(sys.exc_info()[1]) 
    363363            logger.info(msg) 
    364364        return state 
  • src/sas/sasgui/perspectives/file_converter/__init__.py

    • Property mode changed from 100644 to 100755
    r77d92cd rfa81e94  
    11PLUGIN_ID = "File-Converter Plug-In 1.0" 
    2 from file_converter import * 
     2from .file_converter import * 
  • src/sas/sasgui/perspectives/file_converter/converter_panel.py

    • Property mode changed from 100644 to 100755
    ra26f67f rfa81e94  
    112112            [group_path, group_name] = os.path.split(filepath) 
    113113            ext = "." + group_name.split('.')[-1] # File extension 
    114             for frame_number, frame_data in frame_data.iteritems(): 
     114            for frame_number, frame_data in frame_data.items(): 
    115115                # Append frame number to base filename 
    116116                filename = group_name.replace(ext, str(frame_number)+ext) 
     
    155155            # If lines end with comma or semi-colon, trim the last character 
    156156            if end_char == ',' or end_char == ';': 
    157                 data = map(lambda s: s[0:-1], data) 
     157                data = [s[0:-1] for s in data] 
    158158            else: 
    159159                msg = ("Error reading {}: Lines must end with a digit, comma " 
     
    275275            else: 
    276276                return { 'frames': [], 'inc': None, 'file': single_file } 
    277         frames = range(first_frame, last_frame + 1, increment) 
     277        frames = list(range(first_frame, last_frame + 1, increment)) 
    278278        return { 'frames': frames, 'inc': increment, 'file': single_file } 
    279279 
     
    335335        if single_file: 
    336336            # Only need to set metadata on first Data1D object 
    337             frame_data = frame_data.values() # Don't need to know frame numbers 
     337            frame_data = list(frame_data.values()) # Don't need to know frame numbers 
    338338            frame_data[0].filename = output_path.split('\\')[-1] 
    339             for key, value in metadata.iteritems(): 
     339            for key, value in metadata.items(): 
    340340                setattr(frame_data[0], key, value) 
    341341        else: 
    342342            # Need to set metadata for all Data1D objects 
    343             for datainfo in frame_data.values(): 
     343            for datainfo in list(frame_data.values()): 
    344344                datainfo.filename = output_path.split('\\')[-1] 
    345                 for key, value in metadata.iteritems(): 
     345                for key, value in metadata.items(): 
    346346                    setattr(datainfo, key, value) 
    347347 
     
    355355    def convert_2d_data(self, dataset): 
    356356        metadata = self.get_metadata() 
    357         for key, value in metadata.iteritems(): 
     357        for key, value in metadata.items(): 
    358358            setattr(dataset[0], key, value) 
    359359 
  • src/sas/sasgui/perspectives/file_converter/converter_widgets.py

    • Property mode changed from 100644 to 100755
    r0e11ec7 rfa81e94  
    5454        v = Vector() 
    5555        if not self.Validate(): return v 
    56         for direction, control in self._inputs.iteritems(): 
     56        for direction, control in self._inputs.items(): 
    5757            try: 
    5858                value = float(control.GetValue()) 
     
    8686        all_valid = True 
    8787        invalid_ctrl = None 
    88         for control in self._inputs.values(): 
     88        for control in list(self._inputs.values()): 
    8989            if control.GetValue() == '': continue 
    9090            control.SetBackgroundColour(wx.WHITE) 
  • src/sas/sasgui/perspectives/fitting/__init__.py

    • Property mode changed from 100644 to 100755
    r12d3e0e rfa81e94  
    11PLUGIN_ID = "Fitting plug-in 1.0" 
    22import os 
    3 from fitting import * 
     3from .fitting import * 
    44from distutils.filelist import findall 
    55def get_data_path(media): 
  • src/sas/sasgui/perspectives/fitting/basepage.py

    • Property mode changed from 100644 to 100755
    rf4a1433 rfa81e94  
    22Base Page for fitting 
    33""" 
    4 from __future__ import print_function 
     4 
    55 
    66import sys 
     
    1212import logging 
    1313import traceback 
    14 from Queue import Queue 
     14from queue import Queue 
    1515from threading import Thread 
    1616from collections import defaultdict 
     
    223223        self.popUpMenu = wx.Menu() 
    224224 
    225         wx_id = self._ids.next() 
     225        wx_id = next(self._ids) 
    226226        self._keep = wx.MenuItem(self.popUpMenu, wx_id, "Add bookmark", 
    227227                                 " Keep the panel status to recall it later") 
     
    623623        if self.model is not None: 
    624624            self.m_name = self.model.name 
    625         if name in self.saved_states.keys(): 
     625        if name in list(self.saved_states.keys()): 
    626626            previous_state = self.saved_states[name] 
    627627            # reset state of checkbox,textcrtl  and  regular parameters value 
     
    918918 
    919919        if len(self._disp_obj_dict) > 0: 
    920             for k, v in self._disp_obj_dict.iteritems(): 
     920            for k, v in self._disp_obj_dict.items(): 
    921921                self.state.disp_obj_dict[k] = v.type 
    922922 
     
    985985 
    986986            if len(self.disp_cb_dict) > 0: 
    987                 for k, v in self.disp_cb_dict.iteritems(): 
     987                for k, v in self.disp_cb_dict.items(): 
    988988                    if v is None: 
    989989                        self.state.disp_cb_dict[k] = v 
     
    994994                            self.state.disp_cb_dict[k] = None 
    995995            if len(self._disp_obj_dict) > 0: 
    996                 for k, v in self._disp_obj_dict.iteritems(): 
     996                for k, v in self._disp_obj_dict.items(): 
    997997                    self.state.disp_obj_dict[k] = v.type 
    998998 
     
    10961096            if name == "ArrayDispersion": 
    10971097 
    1098                 for item in self.disp_cb_dict.keys(): 
     1098                for item in list(self.disp_cb_dict.keys()): 
    10991099 
    11001100                    if hasattr(self.disp_cb_dict[item], "SetValue"): 
     
    11671167        :return: combo_box_position 
    11681168        """ 
    1169         for key, value in self.master_category_dict.iteritems(): 
     1169        for key, value in self.master_category_dict.items(): 
    11701170            formfactor = state.formfactorcombobox.split(":") 
    11711171            if isinstance(formfactor, list): 
     
    12191219        # select the current model 
    12201220        state._convert_to_sasmodels() 
    1221         state.categorycombobox = unicode(state.categorycombobox) 
     1221        state.categorycombobox = str(state.categorycombobox) 
    12221222        if state.categorycombobox in self.categorybox.Items: 
    12231223            category_pos = self.categorybox.Items.index( 
     
    12441244        structfactor_pos = 0 
    12451245        if state.structurecombobox is not None: 
    1246             state.structurecombobox = unicode(state.structurecombobox) 
     1246            state.structurecombobox = str(state.structurecombobox) 
    12471247            for ind_struct in range(self.structurebox.GetCount()): 
    12481248                if (self.structurebox.GetString(ind_struct) 
     
    13541354        self.weights = copy.deepcopy(state.weights) 
    13551355 
    1356         for key, disp_type in state.disp_obj_dict.iteritems(): 
     1356        for key, disp_type in state.disp_obj_dict.items(): 
    13571357            # disp_model = disp 
    13581358            disp_model = POLYDISPERSITY_MODELS[disp_type]() 
     
    14151415        """ 
    14161416        ids = iter(self._id_pool)  # Reusing ids for context menu 
    1417         for name, _ in self.state.saved_states.iteritems(): 
     1417        for name, _ in self.state.saved_states.items(): 
    14181418            self.number_saved_state += 1 
    14191419            # Add item in the context menu 
    1420             wx_id = ids.next() 
     1420            wx_id = next(ids) 
    14211421            msg = 'Save model and state %g' % self.number_saved_state 
    14221422            self.popUpMenu.Append(wx_id, name, msg) 
     
    23142314                    value_ctrl.SetValue(format_number(value)) 
    23152315 
    2316                 if name not in self.model.details.keys(): 
     2316                if name not in list(self.model.details.keys()): 
    23172317                    self.model.details[name] = ["", None, None] 
    23182318                old_low, old_high = self.model.details[name][1:3] 
     
    26752675        if disp_func is not None: 
    26762676            try: 
    2677                 return POLYDISPERSITY_MODELS.values().index(disp_func.__class__) 
     2677                return list(POLYDISPERSITY_MODELS.values()).index(disp_func.__class__) 
    26782678            except ValueError: 
    26792679                pass  # Fall through to default class 
    2680         return POLYDISPERSITY_MODELS.keys().index('gaussian') 
     2680        return list(POLYDISPERSITY_MODELS.keys()).index('gaussian') 
    26812681 
    26822682    def on_reset_clicked(self, event): 
     
    27702770        gui_manager = self._manager.parent 
    27712771        # loops through the panels [dic] 
    2772         for _, item2 in gui_manager.plot_panels.iteritems(): 
     2772        for _, item2 in gui_manager.plot_panels.items(): 
    27732773            data_title = self.data.group_id 
    27742774            # try to get all plots belonging to this control panel 
     
    33403340            if self.data.__class__.__name__ == "Data2D": 
    33413341                name = item[1] 
    3342                 if name in content.keys(): 
     3342                if name in list(content.keys()): 
    33433343                    values = content[name] 
    33443344                    check = values[0] 
     
    33893389                if not item[1] in orient_param: 
    33903390                    name = item[1] 
    3391                     if name in content.keys(): 
     3391                    if name in list(content.keys()): 
    33923392                        check = content[name][0] 
    33933393                        # Avoid changing combox content 
     
    36153615        sizer_cat = wx.BoxSizer(wx.HORIZONTAL) 
    36163616        self.mbox_description.SetForegroundColour(wx.RED) 
    3617         wx_id = self._ids.next() 
     3617        wx_id = next(self._ids) 
    36183618        self.model_func = wx.Button(self, wx_id, 'Help', size=(80, 23)) 
    36193619        self.model_func.Bind(wx.EVT_BUTTON, self.on_function_help_clicked, 
    36203620                             id=wx_id) 
    36213621        self.model_func.SetToolTipString("Full Model Function Help") 
    3622         wx_id = self._ids.next() 
     3622        wx_id = next(self._ids) 
    36233623        self.model_help = wx.Button(self, wx_id, 'Description', size=(80, 23)) 
    36243624        self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked, 
    36253625                             id=wx_id) 
    36263626        self.model_help.SetToolTipString("Short Model Function Description") 
    3627         wx_id = self._ids.next() 
     3627        wx_id = next(self._ids) 
    36283628        self.model_view = wx.Button(self, wx_id, "Show 2D", size=(80, 23)) 
    36293629        self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=wx_id) 
  • src/sas/sasgui/perspectives/fitting/fit_thread.py

    • Property mode changed from 100644 to 100755
    rf4a1433 rfa81e94  
    1111 
    1212def map_apply(arguments): 
    13     return apply(arguments[0], arguments[1:]) 
     13    return arguments[0](*arguments[1:]) 
    1414 
    1515class FitThread(CalcThread): 
     
    4949        except KeyboardInterrupt: 
    5050            msg = "Fitting: terminated by the user." 
    51             raise KeyboardInterrupt, msg 
     51            raise KeyboardInterrupt(msg) 
    5252 
    5353    def compute(self): 
     
    7272                list_map_get_attr.append(map_getattr) 
    7373            #from multiprocessing import Pool 
    74             inputs = zip(list_map_get_attr, self.fitter, list_fit_function, 
     74            inputs = list(zip(list_map_get_attr, self.fitter, list_fit_function, 
    7575                         list_q, list_q, list_handler, list_curr_thread, 
    76                          list_reset_flag) 
    77             result = map(map_apply, inputs) 
     76                         list_reset_flag)) 
     77            result = list(map(map_apply, inputs)) 
    7878 
    7979            self.complete(result=result, 
     
    8484                          elapsed=time.time() - self.starttime) 
    8585 
    86         except KeyboardInterrupt, msg: 
     86        except KeyboardInterrupt as msg: 
    8787            # Thread was interrupted, just proceed and re-raise. 
    8888            # Real code should not print, but this is an example... 
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    • Property mode changed from 100644 to 100755
    r3bd677b rfa81e94  
    281281 
    282282        # Fit button 
    283         self.btFit = wx.Button(self, self._ids.next(), 'Fit') 
     283        self.btFit = wx.Button(self, next(self._ids), 'Fit') 
    284284        self.default_bt_colour = self.btFit.GetDefaultAttributes() 
    285285        self.btFit.Bind(wx.EVT_BUTTON, self._onFit, id=self.btFit.GetId()) 
     
    377377 
    378378        # Update and Draw button 
    379         self.draw_button = wx.Button(self, self._ids.next(), 'Compute') 
     379        self.draw_button = wx.Button(self, next(self._ids), 'Compute') 
    380380        self.draw_button.Bind(wx.EVT_BUTTON, 
    381381                              self._onDraw, id=self.draw_button.GetId()) 
     
    532532        self.qmin.Bind(wx.EVT_TEXT, self.on_qrange_text) 
    533533        self.qmax.Bind(wx.EVT_TEXT, self.on_qrange_text) 
    534         wx_id = self._ids.next() 
     534        wx_id = next(self._ids) 
    535535        self.reset_qrange = wx.Button(self, wx_id, 'Reset') 
    536536 
     
    540540        sizer = wx.GridSizer(5, 5, 2, 6) 
    541541 
    542         self.btEditMask = wx.Button(self, self._ids.next(), 'Editor') 
     542        self.btEditMask = wx.Button(self, next(self._ids), 'Editor') 
    543543        self.btEditMask.Bind(wx.EVT_BUTTON, self._onMask, 
    544544                             id=self.btEditMask.GetId()) 
     
    660660        self.text_disp_min.Show(True) 
    661661 
    662         for item in self.model.dispersion.keys(): 
     662        for item in list(self.model.dispersion.keys()): 
    663663            if not self.magnetic_on: 
    664664                if item in self.model.magnetic_params: 
     
    675675 
    676676                iy += 1 
    677                 for p in self.model.dispersion[item].keys(): 
     677                for p in list(self.model.dispersion[item].keys()): 
    678678 
    679679                    if p == "width": 
     
    765765                disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1), 
    766766                                       style=wx.CB_READONLY, name='%s' % name1) 
    767                 for key, value in POLYDISPERSITY_MODELS.iteritems(): 
     767                for key, value in POLYDISPERSITY_MODELS.items(): 
    768768                    name_disp = str(key) 
    769769                    disp_box.Append(name_disp, value) 
     
    779779                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
    780780        first_orient = True 
    781         for item in self.model.dispersion.keys(): 
     781        for item in list(self.model.dispersion.keys()): 
    782782            if not self.magnetic_on: 
    783783                if item in self.model.magnetic_params: 
     
    795795 
    796796                iy += 1 
    797                 for p in self.model.dispersion[item].keys(): 
     797                for p in list(self.model.dispersion[item].keys()): 
    798798 
    799799                    if p == "width": 
     
    929929                disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1), 
    930930                                style=wx.CB_READONLY, name='%s' % name1) 
    931                 for key, value in POLYDISPERSITY_MODELS.iteritems(): 
     931                for key, value in POLYDISPERSITY_MODELS.items(): 
    932932                    name_disp = str(key) 
    933933                    disp_box.Append(name_disp, value) 
     
    13701370            except: 
    13711371                tcrtl.SetBackgroundColour("pink") 
    1372                 msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1372                msg = "Model Error:wrong value entered : %s" % sys.exc_info()[1] 
    13731373                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    13741374                return 
     
    14821482                else: 
    14831483                    tcrtl.SetBackgroundColour("pink") 
    1484                     msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1484                    msg = "Model Error:wrong value entered : %s" % sys.exc_info()[1] 
    14851485                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14861486                    return 
    14871487            except: 
    14881488                tcrtl.SetBackgroundColour("pink") 
    1489                 msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1489                msg = "Model Error:wrong value entered : %s" % sys.exc_info()[1] 
    14901490                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14911491                return 
     
    17331733        ind = 0 
    17341734        while(ind < len(list)): 
    1735             for key, val in list.items(): 
     1735            for key, val in list(list.items()): 
    17361736                if val == ind: 
    17371737                    fun_box.Append(key, val) 
     
    18651865                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg, 
    18661866                                               info="error")) 
    1867                     raise ValueError, msg 
     1867                    raise ValueError(msg) 
    18681868 
    18691869            else: 
     
    18771877                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg, 
    18781878                                               info="error")) 
    1879                     raise ValueError, msg 
     1879                    raise ValueError(msg) 
    18801880                # Maximum value of data 
    18811881                qmax = math.sqrt(x * x + y * y) 
     
    21182118        self._on_fit_complete() 
    21192119        if out is None or not np.isfinite(chisqr): 
    2120             raise ValueError, "Fit error occured..." 
     2120            raise ValueError("Fit error occured...") 
    21212121 
    21222122        is_modified = False 
     
    21932193                i += 1 
    21942194            else: 
    2195                 raise ValueError, "onsetValues: Invalid parameters..." 
     2195                raise ValueError("onsetValues: Invalid parameters...") 
    21962196        # Show error title when any errors displayed 
    21972197        if has_error: 
     
    29512951 
    29522952        # type can be either Guassian or Array 
    2953         if len(self.model.dispersion.values()) > 0: 
    2954             type = self.model.dispersion.values()[0]["type"] 
     2953        if len(list(self.model.dispersion.values())) > 0: 
     2954            type = list(self.model.dispersion.values())[0]["type"] 
    29552955        else: 
    29562956            type = "Gaussian" 
  • src/sas/sasgui/perspectives/fitting/fitpanel.py

    • Property mode changed from 100644 to 100755
    r69363c7 rfa81e94  
    9494            batch_state = self.sim_page.set_state() 
    9595 
    96         for uid, page in self.opened_pages.iteritems(): 
     96        for uid, page in self.opened_pages.items(): 
    9797            data = page.get_data() 
    9898            # state must be cloned 
     
    135135        if uid not in self.opened_pages: 
    136136            msg = "Fitpanel cannot find ID: %s in self.opened_pages" % str(uid) 
    137             raise ValueError, msg 
     137            raise ValueError(msg) 
    138138        else: 
    139139            return self.opened_pages[uid] 
     
    217217        page_is_opened = False 
    218218        if state is not None: 
    219             for uid, panel in self.opened_pages.iteritems(): 
     219            for uid, panel in self.opened_pages.items(): 
    220220                # Don't return any panel is the exact same page is created 
    221221                if uid == panel.uid and panel.data == state.data: 
     
    396396        """ 
    397397        if data.__class__.__name__ != "list": 
    398             raise ValueError, "Fitpanel delete_data expect list of id" 
     398            raise ValueError("Fitpanel delete_data expect list of id") 
    399399        else: 
    400             for page in self.opened_pages.values(): 
     400            for page in list(self.opened_pages.values()): 
    401401                pos = self.GetPageIndex(page) 
    402402                temp_data = page.get_data() 
     
    433433                data_2d_list.append(data) 
    434434        page = None 
    435         for p in self.opened_pages.values(): 
     435        for p in list(self.opened_pages.values()): 
    436436            # check if there is an empty page to fill up 
    437437            if not check_data_validity(p.get_data()) and p.batch_on: 
     
    503503                return None 
    504504        focused_page = self.GetPage(self.GetSelection()) 
    505         for page in self.opened_pages.values(): 
     505        for page in list(self.opened_pages.values()): 
    506506            # check if the selected data existing in the fitpanel 
    507507            pos = self.GetPageIndex(page) 
     
    592592        if selected_page in page_finder: 
    593593            # Delete the name of the page into the list of open page 
    594             for uid, list in self.opened_pages.iteritems(): 
     594            for uid, list in self.opened_pages.items(): 
    595595                # Don't return any panel is the exact same page is created 
    596596                if flag and selected_page.uid == uid: 
     
    600600 
    601601        # Delete the name of the page into the list of open page 
    602         for uid, list in self.opened_pages.iteritems(): 
     602        for uid, list in self.opened_pages.items(): 
    603603            # Don't return any panel is the exact same page is created 
    604604            if selected_page.uid == uid: 
  • src/sas/sasgui/perspectives/fitting/fitproblem.py

    • Property mode changed from 100644 to 100755
    r251ef684 rfa81e94  
    309309        self._smear_on = flag 
    310310        if fid is None: 
    311             for value in self.values(): 
     311            for value in list(self.values()): 
    312312                value.enable_smearing(flag) 
    313313        elif fid in self: 
     
    320320        """ 
    321321        if fid is None: 
    322             for value in self.values(): 
     322            for value in list(self.values()): 
    323323                value.set_smearer(smearer) 
    324324        elif fid in self: 
     
    336336        """ 
    337337        if fid is None: 
    338             for value in self.values(): 
     338            for value in list(self.values()): 
    339339                value.save_model_name(name) 
    340340        elif fid in self: 
     
    346346        result = [] 
    347347        if fid is None: 
    348             for value in self.values(): 
     348            for value in list(self.values()): 
    349349                result.append(value.get_name()) 
    350350        elif fid in self: 
     
    360360        self.model = model 
    361361        if fid is None: 
    362             for value in self.values(): 
     362            for value in list(self.values()): 
    363363                value.set_model(self.model) 
    364364        elif fid in self: 
     
    456456        """ 
    457457        if fid is None: 
    458             for value in self.values(): 
     458            for value in list(self.values()): 
    459459                value.set_model_param(name, value) 
    460460        elif fid in self: 
     
    486486        """ 
    487487        self.scheduled = schedule 
    488         for value in self.values(): 
     488        for value in list(self.values()): 
    489489            value.schedule_tofit(schedule) 
    490490 
     
    502502        self.qmax = qmax 
    503503        if fid is None: 
    504             for value in self.values(): 
     504            for value in list(self.values()): 
    505505                value.set_range(self.qmin, self.qmax) 
    506506        elif fid in self: 
     
    519519        """ 
    520520        if fid is None: 
    521             for value in self.values(): 
     521            for value in list(self.values()): 
    522522                value.set_weight(flag=flag, is2d=is2d) 
    523523        elif fid in self: 
     
    536536        """ 
    537537        if fid is None: 
    538             for value in self.values(): 
     538            for value in list(self.values()): 
    539539                value.clear_model_param() 
    540540        elif fid in self: 
     
    545545        return fitproblem contained in this dictionary 
    546546        """ 
    547         return self.values() 
     547        return list(self.values()) 
    548548 
    549549    def set_result(self, result, fid): 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    • Property mode changed from 100644 to 100755
    rc416a17 rfa81e94  
    1111#copyright 2009, University of Tennessee 
    1212################################################################################ 
    13 from __future__ import print_function 
     13 
    1414 
    1515import re 
     
    142142        Given an ID create a fitproblem container 
    143143        """ 
    144         if page_id in self.page_finder.iterkeys(): 
     144        if page_id in iter(self.page_finder.keys()): 
    145145            del self.page_finder[page_id] 
    146146 
     
    335335            if temp: 
    336336                # Set the new plugin model list for all fit pages 
    337                 for uid, page in self.fit_panel.opened_pages.iteritems(): 
     337                for uid, page in self.fit_panel.opened_pages.items(): 
    338338                    if hasattr(page, "formfactorbox"): 
    339339                        page.model_list_box = temp 
     
    350350                                page.formfactorbox.SetLabel(current_val) 
    351351        except: 
    352             logger.error("update_custom_combo: %s", sys.exc_value) 
     352            logger.error("update_custom_combo: %s", sys.exc_info()[1]) 
    353353 
    354354    def set_edit_menu(self, owner): 
     
    556556        else: 
    557557            if len(data_list) > MAX_NBR_DATA: 
    558                 from fitting_widgets import DataDialog 
     558                from .fitting_widgets import DataDialog 
    559559                dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA) 
    560560                if dlg.ShowModal() == wx.ID_OK: 
     
    576576                        self.add_fit_page(data=[data]) 
    577577            except: 
    578                 msg = "Fitting set_data: " + str(sys.exc_value) 
     578                msg = "Fitting set_data: " + str(sys.exc_info()[1]) 
    579579                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    580580 
     
    590590                msg = "Fitting: cannot deal with the theory received" 
    591591                evt = StatusEvent(status=msg, info="error") 
    592                 logger.error("set_theory " + msg + "\n" + str(sys.exc_value)) 
     592                logger.error("set_theory " + msg + "\n" + str(sys.exc_info()[1])) 
    593593                wx.PostEvent(self.parent, evt) 
    594594 
     
    602602        """ 
    603603        from pagestate import PageState 
    604         from simfitpage import SimFitPageState 
     604        from .simfitpage import SimFitPageState 
    605605        if isinstance(state, PageState): 
    606606            state = state.clone() 
     
    713713        if fid is None: 
    714714            return 
    715         if uid in self.page_finder.keys(): 
     715        if uid in list(self.page_finder.keys()): 
    716716            self.page_finder[uid].set_weight(flag=flag, is2d=is2d) 
    717717 
     
    726726        :param qmax: maximum  value of the fit range 
    727727        """ 
    728         if uid in self.page_finder.keys(): 
     728        if uid in list(self.page_finder.keys()): 
    729729            self.page_finder[uid].set_range(qmin=qmin, qmax=qmax, fid=fid) 
    730730 
     
    737737        :param uid: the id related to a page contaning fitting information 
    738738        """ 
    739         if uid in self.page_finder.keys(): 
     739        if uid in list(self.page_finder.keys()): 
    740740            self.page_finder[uid].schedule_tofit(value) 
    741741 
     
    756756        """ 
    757757        sim_page_id = self.sim_page.uid 
    758         for uid, value in self.page_finder.iteritems(): 
     758        for uid, value in self.page_finder.items(): 
    759759            if uid != sim_page_id and uid != self.batch_page.uid: 
    760760                model_list = value.get_model() 
     
    821821        Stop the fit 
    822822        """ 
    823         if uid in self.fit_thread_list.keys(): 
     823        if uid in list(self.fit_thread_list.keys()): 
    824824            calc_fit = self.fit_thread_list[uid] 
    825825            if calc_fit is not  None and calc_fit.isrunning(): 
     
    833833        batch_flag = self.batch_page is not None and uid == self.batch_page.uid 
    834834        if sim_flag or batch_flag: 
    835             for uid, value in self.page_finder.iteritems(): 
     835            for uid, value in self.page_finder.items(): 
    836836                if value.get_scheduled() == 1: 
    837                     if uid in self.fit_panel.opened_pages.keys(): 
     837                    if uid in list(self.fit_panel.opened_pages.keys()): 
    838838                        panel = self.fit_panel.opened_pages[uid] 
    839839                        panel._on_fit_complete() 
     
    852852        :param draw: Determine if the theory needs to be plot 
    853853        """ 
    854         if uid not in self.page_finder.keys(): 
     854        if uid not in list(self.page_finder.keys()): 
    855855            return 
    856856        self.page_finder[uid].enable_smearing(flag=enable_smearer) 
     
    964964        list_page_id = [] 
    965965        fit_id = 0 
    966         for page_id, page_info in self.page_finder.iteritems(): 
     966        for page_id, page_info in self.page_finder.items(): 
    967967            # For simulfit (uid give with None), do for-loop 
    968968            # if uid is specified (singlefit), do it only on the page. 
     
    991991 
    992992                    pars = [str(element[1]) for element in page.param_toFit] 
    993                     fitproblem_list = page_info.values() 
     993                    fitproblem_list = list(page_info.values()) 
    994994                    for fitproblem in  fitproblem_list: 
    995995                        if sim_fitter is None: 
     
    10131013            except: 
    10141014                raise 
    1015                 msg = "Fitting error: %s" % str(sys.exc_value) 
     1015                msg = "Fitting error: %s" % str(sys.exc_info()[1]) 
    10161016                evt = StatusEvent(status=msg, info="error", type="stop") 
    10171017                wx.PostEvent(self.parent, evt) 
     
    10701070        :param fid: the id of the fitproblem(data, model, range,etc) 
    10711071        """ 
    1072         if uid not in self.page_finder.keys(): 
     1072        if uid not in list(self.page_finder.keys()): 
    10731073            return 
    10741074        fitproblemList = self.page_finder[uid].get_fit_problem(fid) 
     
    11161116                wx.PostEvent(self.parent, evt) 
    11171117        except: 
    1118             msg = "Creating Fit page: %s" % sys.exc_value 
     1118            msg = "Creating Fit page: %s" % sys.exc_info()[1] 
    11191119            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    11201120 
     
    11961196        # case that uid is not specified 
    11971197        if uid is None: 
    1198             for page_id in self.page_finder.keys(): 
     1198            for page_id in list(self.page_finder.keys()): 
    11991199                self.page_finder[page_id].schedule_tofit(value) 
    12001200        # when uid is given 
    12011201        else: 
    1202             if uid in self.page_finder.keys(): 
     1202            if uid in list(self.page_finder.keys()): 
    12031203                self.page_finder[uid].schedule_tofit(value) 
    12041204 
     
    12341234        panel = self.plot_panel 
    12351235        if panel is None: 
    1236             raise ValueError, "Fitting:_onSelect: NonType panel" 
     1236            raise ValueError("Fitting:_onSelect: NonType panel") 
    12371237        Plugin.on_perspective(self, event=event) 
    12381238        self.select_data(panel) 
     
    12671267        """ 
    12681268        uid = page_id[0] 
    1269         if uid in self.fit_thread_list.keys(): 
     1269        if uid in list(self.fit_thread_list.keys()): 
    12701270            del self.fit_thread_list[uid] 
    12711271 
     
    12931293                #get all fittable parameters of the current model 
    12941294                for param in  model.getParamList(): 
    1295                     if param  not in batch_outputs.keys(): 
     1295                    if param  not in list(batch_outputs.keys()): 
    12961296                        batch_outputs[param] = [] 
    12971297                for param in model.getDispParamList(): 
    12981298                    if not model.is_fittable(param) and \ 
    1299                         param in batch_outputs.keys(): 
     1299                        param in list(batch_outputs.keys()): 
    13001300                        del batch_outputs[param] 
    13011301                # Add fitted parameters and their error 
    13021302                for param in res.param_list: 
    1303                     if param not in batch_outputs.keys(): 
     1303                    if param not in list(batch_outputs.keys()): 
    13041304                        batch_outputs[param] = [] 
    13051305                    err_param = "error on %s" % str(param) 
    1306                     if err_param not in batch_inputs.keys(): 
     1306                    if err_param not in list(batch_inputs.keys()): 
    13071307                        batch_inputs[err_param] = [] 
    13081308        msg = "" 
     
    13891389                #model 
    13901390                EMPTY = "-" 
    1391                 for key in batch_outputs.keys(): 
     1391                for key in list(batch_outputs.keys()): 
    13921392                    if key not in param_list and key not in ["Chi2", "Data"]: 
    13931393                        batch_outputs[key].append(EMPTY) 
     
    14321432        tbatch_outputs = {} 
    14331433        shownkeystr = cpage.get_copy_params() 
    1434         for key in batch_outputs.keys(): 
     1434        for key in list(batch_outputs.keys()): 
    14351435            if key in ["Chi2", "Data"] or shownkeystr.count(key) > 0: 
    14361436                tbatch_outputs[key] = batch_outputs[key] 
     
    14521452        model = fitproblem.get_model() 
    14531453        #fill batch result information 
    1454         if "Data" not in batch_outputs.keys(): 
     1454        if "Data" not in list(batch_outputs.keys()): 
    14551455            batch_outputs["Data"] = [] 
    14561456        from sas.sasgui.guiframe.data_processor import BatchCell 
     
    14821482        cell.object = [data, theory_data] 
    14831483        batch_outputs["Data"].append(cell) 
    1484         for key, value in data.meta_data.iteritems(): 
    1485             if key not in batch_inputs.keys(): 
     1484        for key, value in data.meta_data.items(): 
     1485            if key not in list(batch_inputs.keys()): 
    14861486                batch_inputs[key] = [] 
    14871487            #if key.lower().strip() != "loader": 
     
    14891489        param = "temperature" 
    14901490        if hasattr(data.sample, param): 
    1491             if param not in  batch_inputs.keys(): 
     1491            if param not in  list(batch_inputs.keys()): 
    14921492                batch_inputs[param] = [] 
    14931493            batch_inputs[param].append(data.sample.temperature) 
     
    15621562        except: 
    15631563            msg = ("Fit completed but the following error occurred: %s" 
    1564                    % sys.exc_value) 
     1564                   % sys.exc_info()[1]) 
    15651565            #import traceback; msg = "\n".join((traceback.format_exc(), msg)) 
    15661566            evt = StatusEvent(status=msg, info="warning", type="stop") 
     
    16501650        if model is None: 
    16511651            return 
    1652         if uid not in self.page_finder.keys(): 
     1652        if uid not in list(self.page_finder.keys()): 
    16531653            return 
    16541654        # save the name containing the data name with the appropriate model 
     
    19031903            return None 
    19041904        try: 
    1905             from model_thread import Calc2D 
     1905            from .model_thread import Calc2D 
    19061906            ## If a thread is already started, stop it 
    19071907            if (self.calc_2D is not None) and self.calc_2D.isrunning(): 
     
    19501950            return 
    19511951        try: 
    1952             from model_thread import Calc1D 
     1952            from .model_thread import Calc1D 
    19531953            ## If a thread is already started, stop it 
    19541954            if (self.calc_1D is not None) and self.calc_1D.isrunning(): 
     
    19891989        except: 
    19901990            msg = " Error occurred when drawing %s Model 1D: " % model.name 
    1991             msg += " %s" % sys.exc_value 
     1991            msg += " %s" % sys.exc_info()[1] 
    19921992            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    19931993 
  • src/sas/sasgui/perspectives/fitting/model_thread.py

    • Property mode changed from 100644 to 100755
    rc416a17 rfa81e94  
    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/sasgui/perspectives/fitting/simfitpage.py

    • Property mode changed from 100644 to 100755
    r0a3c740 rfa81e94  
    168168        i = 0 
    169169        for model in self.model_list: 
    170             model_id = self._format_id(model[1].keys()[0]) 
     170            model_id = self._format_id(list(model[1].keys())[0]) 
    171171            for saved_model in sim_state.model_list: 
    172172                save_id = saved_model.pop('name') 
     
    195195                param = item.pop('param_cbox') 
    196196                equality = item.pop('egal_txt') 
    197                 for key, value in init_map.items(): 
     197                for key, value in list(init_map.items()): 
    198198                    model_cbox = model_cbox.replace(key, value) 
    199199                    constraint_value = constraint_value.replace(key, value) 
    200                 for key, value in final_map.items(): 
     200                for key, value in list(final_map.items()): 
    201201                    model_cbox = model_cbox.replace(key, value) 
    202202                    constraint_value = constraint_value.replace(key, value) 
     
    328328        sizer.Add(tab_used, (iy, ix), (1, 1), 
    329329                  wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    330         for id, value in self.page_finder.iteritems(): 
     330        for id, value in self.page_finder.items(): 
    331331            if id not in self.parent.opened_pages: 
    332332                continue 
     
    757757        self.set_button.Disable() 
    758758 
    759         for id, model in self.constraint_dict.iteritems(): 
     759        for id, model in self.constraint_dict.items(): 
    760760            # check if all parameters have been selected for constraint 
    761761            # then do not allow add constraint on parameters 
    762762            self.model_cbox_left.Append(str(model.name), model) 
    763763        self.model_cbox_left.Select(0) 
    764         for id, model in self.constraint_dict.iteritems(): 
     764        for id, model in self.constraint_dict.items(): 
    765765            # check if all parameters have been selected for constraint 
    766766            # then do not allow add constraint on parameters 
     
    814814        model_right = self.model_cbox_right.GetValue() 
    815815        model_b = self.model_cbox_right.GetClientData(selection_b) 
    816         for id, dic_model in self.constraint_dict.iteritems(): 
     816        for id, dic_model in self.constraint_dict.items(): 
    817817            if model == dic_model: 
    818818                param_list = self.page_finder[id].get_param2fit() 
     
    857857        if len(self.constraints_list) != 0: 
    858858            nb_fit_param = 0 
    859             for id, model in self.constraint_dict.iteritems(): 
     859            for id, model in self.constraint_dict.items(): 
    860860                nb_fit_param += len(self.page_finder[id].get_param2fit()) 
    861861            # Don't add anymore 
     
    879879        model_cbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY) 
    880880        model_cbox.Clear() 
    881         for id, model in self.constraint_dict.iteritems(): 
     881        for id, model in self.constraint_dict.items(): 
    882882            # check if all parameters have been selected for constraint 
    883883            # then do not allow add constraint on parameters 
     
    898898        # Remove button 
    899899        #btRemove = wx.Button(self, self.ID_REMOVE, 'Remove') 
    900         bt_remove = wx.Button(self, self._ids.next(), 'Remove') 
     900        bt_remove = wx.Button(self, next(self._ids), 'Remove') 
    901901        bt_remove.Bind(wx.EVT_BUTTON, self.on_remove, 
    902902                      id=bt_remove.GetId()) 
     
    931931        hide buttons related constraint 
    932932        """ 
    933         for id in self.page_finder.iterkeys(): 
     933        for id in self.page_finder.keys(): 
    934934            self.page_finder[id].clear_model_param() 
    935935 
     
    969969        model = model_cbox.GetClientData(n) 
    970970        param_list = [] 
    971         for id, dic_model in self.constraint_dict.iteritems(): 
     971        for id, dic_model in self.constraint_dict.items(): 
    972972            if model == dic_model: 
    973973                param_list = self.page_finder[id].get_param2fit() 
     
    10561056                msg += " in combobox to set constraint! " 
    10571057                wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    1058             for id, value in self.constraint_dict.iteritems(): 
     1058            for id, value in self.constraint_dict.items(): 
    10591059                if model == value: 
    10601060                    if constraint == "": 
     
    10801080                        return False 
    10811081 
    1082                     for fid in self.page_finder[id].iterkeys(): 
     1082                    for fid in self.page_finder[id].keys(): 
    10831083                        # wrap in param/constraint in str() to remove unicode 
    10841084                        self.page_finder[id].set_model_param(str(param), 
  • src/sas/sasgui/perspectives/invariant/__init__.py

    • Property mode changed from 100644 to 100755
    r5a405bd rfa81e94  
    33 
    44from distutils.filelist import findall 
    5 from invariant import * 
     5from .invariant import * 
    66 
    77def get_data_path(media): 
  • src/sas/sasgui/perspectives/invariant/invariant.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    133133            name = data.__class__.__name__ 
    134134            msg = "Invariant use only Data1D got: [%s] " % str(name) 
    135             raise ValueError, msg 
     135            raise ValueError(msg) 
    136136        self.compute_helper(data=data) 
    137137 
     
    169169                msg += "Please select one.\n" 
    170170                if len(data_list) > 1: 
    171                     from invariant_widgets import DataDialog 
     171                    from .invariant_widgets import DataDialog 
    172172                    dlg = DataDialog(data_list=data_1d_list, text=msg) 
    173173                    if dlg.ShowModal() == wx.ID_OK: 
     
    191191                    self.compute_helper(data) 
    192192                except: 
    193                     msg = "Invariant Set_data: " + str(sys.exc_value) 
     193                    msg = "Invariant Set_data: " + str(sys.exc_info()[1]) 
    194194                    wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    195195        else: 
     
    240240            msg = "invariant.save_file: the data being saved is" 
    241241            msg += " not a sas.sascalc.dataloader.data_info.Data1D object" 
    242             raise RuntimeError, msg 
     242            raise RuntimeError(msg) 
    243243 
    244244    def set_state(self, state=None, datainfo=None): 
     
    258258                msg = "invariant.set_state: datainfo parameter cannot" 
    259259                msg += " be None in standalone mode" 
    260                 raise RuntimeError, msg 
     260                raise RuntimeError(msg) 
    261261            # Make sure the user sees the invariant panel after loading 
    262262            # self.parent.set_perspective(self.perspective) 
     
    282282 
    283283        except: 
    284             logger.error("invariant.set_state: %s" % sys.exc_value) 
     284            logger.error("invariant.set_state: %s" % sys.exc_info()[1]) 
    285285 
    286286    def on_set_state_helper(self, event=None): 
     
    320320        else: 
    321321            msg = "Scale can not be zero." 
    322             raise ValueError, msg 
     322            raise ValueError(msg) 
    323323        if len(new_plot.x) == 0: 
    324324            return 
  • src/sas/sasgui/perspectives/invariant/invariant_details.py

    • Property mode changed from 100644 to 100755
    r959eb01 rfa81e94  
    66 
    77from sas.sasgui.guiframe.utils import format_number 
    8 from invariant_widgets import OutputTextCtrl 
     8from .invariant_widgets import OutputTextCtrl 
    99# Dimensions related to chart 
    1010RECTANGLE_WIDTH = 400.0 
  • src/sas/sasgui/perspectives/invariant/invariant_panel.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    318318        background = self.background_tcl.GetValue().lstrip().rstrip() 
    319319        if background == "": 
    320             raise ValueError, "Need a background" 
     320            raise ValueError("Need a background") 
    321321        if check_float(self.background_tcl): 
    322322            return float(background) 
    323323        else: 
    324324            msg = "Receive invalid value for background : %s" % (background) 
    325             raise ValueError, msg 
     325            raise ValueError(msg) 
    326326 
    327327    def get_scale(self): 
     
    331331        scale = self.scale_tcl.GetValue().lstrip().rstrip() 
    332332        if scale == "": 
    333             raise ValueError, "Need a background" 
     333            raise ValueError("Need a background") 
    334334        if check_float(self.scale_tcl): 
    335335            if float(scale) <= 0.0: 
     
    337337                self.scale_tcl.Refresh() 
    338338                msg = "Receive invalid value for scale: %s" % (scale) 
    339                 raise ValueError, msg 
     339                raise ValueError(msg) 
    340340            return float(scale) 
    341341        else: 
    342             raise ValueError, "Receive invalid value for scale : %s" % (scale) 
     342            raise ValueError("Receive invalid value for scale : %s" % (scale)) 
    343343 
    344344    def get_contrast(self): 
     
    389389                self.volume_err_tcl.SetValue(format_number(None)) 
    390390                msg = "Error occurred computing volume " 
    391                 msg += " fraction: %s" % sys.exc_value 
     391                msg += " fraction: %s" % sys.exc_info()[1] 
    392392                wx.PostEvent(self.parent, StatusEvent(status=msg, 
    393393                                                      info="error", 
     
    409409                self.surface_err_tcl.SetValue(format_number(None)) 
    410410                msg = "Error occurred computing " 
    411                 msg += "specific surface: %s" % sys.exc_value 
     411                msg += "specific surface: %s" % sys.exc_info()[1] 
    412412                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
    413413                                                      type="stop")) 
     
    431431            self.invariant_total_err_tcl.SetValue(format_number(None)) 
    432432            msg = "Error occurred computing invariant using" 
    433             msg += " extrapolation: %s" % sys.exc_value 
     433            msg += " extrapolation: %s" % sys.exc_info()[1] 
    434434            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    435435 
     
    454454                self._manager.plot_theory(name="Low-Q extrapolation") 
    455455                msg = "Error occurred computing low-Q " 
    456                 msg += "invariant: %s" % sys.exc_value 
     456                msg += "invariant: %s" % sys.exc_info()[1] 
    457457                wx.PostEvent(self.parent, 
    458458                             StatusEvent(status=msg, type="stop")) 
     
    462462                self._manager.plot_theory(name="Low-Q extrapolation") 
    463463            except: 
    464                 logger.error(sys.exc_value) 
     464                logger.error(sys.exc_info()[1]) 
    465465 
    466466    def get_high_qstar(self, inv, high_q=False): 
     
    488488                self._manager.plot_theory(name="High-Q extrapolation") 
    489489                msg = "Error occurred computing high-Q " 
    490                 msg += "invariant: %s" % sys.exc_value 
     490                msg += "invariant: %s" % sys.exc_info()[1] 
    491491                wx.PostEvent(self.parent, StatusEvent(status=msg, 
    492492                                                      type="stop")) 
     
    496496                self._manager.plot_theory(name="High-Q extrapolation") 
    497497            except: 
    498                 logger.error(sys.exc_value) 
     498                logger.error(sys.exc_info()[1]) 
    499499 
    500500    def get_qstar(self, inv): 
     
    625625            scale = self.get_scale() 
    626626        except: 
    627             msg = "Invariant Error: %s" % (sys.exc_value) 
     627            msg = "Invariant Error: %s" % (sys.exc_info()[1]) 
    628628            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    629629            return 
     
    641641            inv, npts_high = self.set_extrapolation_high(inv=inv, high_q=high_q) 
    642642        except: 
    643             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     643            msg = "Error occurred computing invariant: %s" % sys.exc_info()[1] 
    644644            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    645645                                                  info="warning", type="stop")) 
     
    652652            self.get_qstar(inv=inv) 
    653653        except: 
    654             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     654            msg = "Error occurred computing invariant: %s" % sys.exc_info()[1] 
    655655            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    656656                                                  info="warning", 
     
    675675        except: 
    676676            msg = r_msg + "Error occurred computing invariant: %s" % \ 
    677                                                             sys.exc_value 
     677                                                            sys.exc_info()[1] 
    678678            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    679679                                                  info="error", 
     
    685685            #compute surface and set value to txtcrtl 
    686686        except: 
    687             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     687            msg = "Error occurred computing invariant: %s" % sys.exc_info()[1] 
    688688            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    689689                                                  info="warning", 
     
    695695 
    696696        except: 
    697             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     697            msg = "Error occurred computing invariant: %s" % sys.exc_info()[1] 
    698698            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    699699                                                  info="warning", 
     
    847847            attr.SetValue(value) 
    848848        except: 
    849             logger.error("Invariant state: %s", sys.exc_value) 
     849            logger.error("Invariant state: %s", sys.exc_info()[1]) 
    850850 
    851851    def get_bookmark_by_num(self, num=None): 
     
    864864            _, _, current_state, comp_state = self.state.bookmark_list[int(num)] 
    865865        except: 
    866             logger.error(sys.exc_value) 
    867             raise ValueError, "No such bookmark exists" 
     866            logger.error(sys.exc_info()[1]) 
     867            raise ValueError("No such bookmark exists") 
    868868 
    869869        # set the parameters 
     
    959959                    self.state.clone_state() 
    960960        except: 
    961             logger.error(sys.exc_value) 
     961            logger.error(sys.exc_info()[1]) 
    962962 
    963963        self._set_undo_flag(True) 
     
    10031003                del self.state.state_list[str(i)] 
    10041004            except: 
    1005                 logger.error(sys.exc_value) 
     1005                logger.error(sys.exc_info()[1]) 
    10061006        # Enable the undo button if it was not 
    10071007        self._set_undo_flag(True) 
     
    10681068                del self.state.state_list[str(i)] 
    10691069            except: 
    1070                 logger.error(sys.exc_value) 
     1070                logger.error(sys.exc_info()[1]) 
    10711071 
    10721072        # try to add new state of the text changes in the state_list 
     
    10831083            self.state.state_list[str(self.state.state_num)] = self.state.clone_state() 
    10841084        except: 
    1085             logger.error(sys.exc_value) 
     1085            logger.error(sys.exc_info()[1]) 
    10861086 
    10871087        self._set_undo_flag(True) 
     
    11051105            self.state.state_list[str(self.state.state_num)] = self.state.clone_state() 
    11061106        except: 
    1107             logger.error(sys.exc_value) 
     1107            logger.error(sys.exc_info()[1]) 
    11081108 
    11091109    def _get_input_list(self): 
     
    11141114        compute_num = self.state.saved_state['compute_num'] 
    11151115        # find values and put into the input list 
    1116         for key1, value1 in self.state.state_list[str(compute_num)].iteritems(): 
    1117             for key, _ in self.state.input_list.iteritems(): 
     1116        for key1, value1 in self.state.state_list[str(compute_num)].items(): 
     1117            for key, _ in self.state.input_list.items(): 
    11181118                if key == key1: 
    11191119                    self.state.input_list[key] = value1 
  • src/sas/sasgui/perspectives/invariant/invariant_state.py

    • Property mode changed from 100644 to 100755
    r1fa4f736 rfa81e94  
    137137 
    138138        # text ctl general inputs ( excluding extrapolation text ctl) 
    139         for key, value in self.input_list.iteritems(): 
     139        for key, value in self.input_list.items(): 
    140140            if value == '': 
    141141                continue 
     
    163163        low_off = False 
    164164        high_off = False 
    165         for key, value in self.input_list.iteritems(): 
     165        for key, value in self.input_list.items(): 
    166166            key_split = key.split('_') 
    167167            max_ind = len(key_split) - 1 
     
    213213                # other outputs than Q* 
    214214                name = item[0] + "_tcl" 
    215                 if name in self.saved_state.keys(): 
     215                if name in list(self.saved_state.keys()): 
    216216                    value = self.saved_state[name] 
    217217 
     
    298298        top_element.appendChild(state) 
    299299 
    300         for name, value in self.saved_state.iteritems(): 
     300        for name, value in self.saved_state.items(): 
    301301            element = newdoc.createElement(str(name)) 
    302302            element.appendChild(newdoc.createTextNode(str(value))) 
     
    307307        top_element.appendChild(history) 
    308308 
    309         for name, value in self.state_list.iteritems(): 
     309        for name, value in self.state_list.items(): 
    310310            history_element = newdoc.createElement('state_' + str(name)) 
    311             for state_name, state_value in value.iteritems(): 
     311            for state_name, state_value in value.items(): 
    312312                state_element = newdoc.createElement(str(state_name)) 
    313313                child = newdoc.createTextNode(str(state_value)) 
     
    322322        top_element.appendChild(bookmark) 
    323323        item_list = ['time', 'date', 'state', 'comp_state'] 
    324         for name, value_list in self.bookmark_list.iteritems(): 
     324        for name, value_list in self.bookmark_list.items(): 
    325325            element = newdoc.createElement('mark_' + str(name)) 
    326326            _, date, state, comp_state = value_list 
     
    331331            state_list_element = newdoc.createElement('state') 
    332332            comp_state_list_element = newdoc.createElement('comp_state') 
    333             for state_name, state_value in value_list[2].iteritems(): 
     333            for state_name, state_value in value_list[2].items(): 
    334334                state_element = newdoc.createElement(str(state_name)) 
    335335                child = newdoc.createTextNode(str(state_value)) 
    336336                state_element.appendChild(child) 
    337337                state_list_element.appendChild(state_element) 
    338             for comp_name, comp_value in value_list[3].iteritems(): 
     338            for comp_name, comp_value in value_list[3].items(): 
    339339                comp_element = newdoc.createElement(str(comp_name)) 
    340340                comp_element.appendChild(newdoc.createTextNode(str(comp_value))) 
     
    365365            msg = "InvariantSate no longer supports non-CanSAS" 
    366366            msg += " format for invariant files" 
    367             raise RuntimeError, msg 
     367            raise RuntimeError(msg) 
    368368 
    369369        if node.get('version')\ 
     
    382382                except: 
    383383                    msg = "InvariantSate.fromXML: Could not read" 
    384                     msg += " timestamp\n %s" % sys.exc_value 
     384                    msg += " timestamp\n %s" % sys.exc_info()[1] 
    385385                    logger.error(msg) 
    386386 
     
    454454        # default string values 
    455455        for num in range(1, 19): 
    456             exec "s_%s = 'NA'" % str(num) 
     456            exec("s_%s = 'NA'" % str(num)) 
    457457        lines = strings.split('\n') 
    458458        # get all string values from __str__() 
     
    695695        except: 
    696696            msg = "XML document does not contain invariant" 
    697             msg += " information.\n %s" % sys.exc_value 
     697            msg += " information.\n %s" % sys.exc_info()[1] 
    698698            logger.info(msg) 
    699699        return state 
     
    737737                        output.append(sas_entry) 
    738738        else: 
    739             raise RuntimeError, "%s is not a file" % path 
     739            raise RuntimeError("%s is not a file" % path) 
    740740 
    741741        # Return output consistent with the loader's api 
     
    783783            msg = "The cansas writer expects a Data1D" 
    784784            msg += " instance: %s" % str(datainfo.__class__.__name__) 
    785             raise RuntimeError, msg 
     785            raise RuntimeError(msg) 
    786786        # make sure title and data run is filled up. 
    787787        if datainfo.title is None or datainfo.title == '': 
  • src/sas/sasgui/perspectives/invariant/report_dialog.py

    • Property mode changed from 100644 to 100755
    r959eb01 rfa81e94  
    9494                    except: 
    9595                        # DO not open 
    96                         logger.error("Could not open file: %s" % sys.exc_value) 
     96                        logger.error("Could not open file: %s" % sys.exc_info()[1]) 
    9797            # delete image file 
    9898            os.remove(pic_fname) 
  • src/sas/sasgui/perspectives/pr/__init__.py

    • Property mode changed from 100644 to 100755
    r959eb01 rfa81e94  
    11PLUGIN_ID = "P(r) plug-in 1.0" 
    2 from pr import * 
     2from .pr import * 
  • src/sas/sasgui/perspectives/pr/explore_dialog.py

    • Property mode changed from 100644 to 100755
    r959eb01 rfa81e94  
    3535from sas.sasgui.plottools.plottables import Graph 
    3636 
    37 from pr_widgets import PrTextCtrl 
     37from .pr_widgets import PrTextCtrl 
    3838 
    3939# Default number of points on the output plot 
     
    331331        selection_msg = wx.StaticText(self, -1, "Select a dependent variable:") 
    332332        self.output_box = wx.ComboBox(self, -1, style=wx.CB_READONLY) 
    333         for item in self.results.outputs.keys(): 
     333        for item in list(self.results.outputs.keys()): 
    334334            self.output_box.Append(item, "") 
    335335        self.output_box.SetStringSelection(DEFAULT_OUTPUT) 
     
    419419                # This inversion failed, skip this D_max value 
    420420                msg = "ExploreDialog: inversion failed " 
    421                 msg += "for D_max=%s\n%s" % (str(d), sys.exc_value) 
     421                msg += "for D_max=%s\n%s" % (str(d), sys.exc_info()[1]) 
    422422                logger.error(msg) 
    423423 
  • src/sas/sasgui/perspectives/pr/inversion_panel.py

    • Property mode changed from 100644 to 100755
    rcb62bd5 rfa81e94  
    1212from sas.sasgui.guiframe.events import StatusEvent 
    1313from sas.sasgui.guiframe.panel_base import PanelBase 
    14 from inversion_state import InversionState 
    15 from pr_widgets import PrTextCtrl 
    16 from pr_widgets import DataFileTextCtrl 
    17 from pr_widgets import OutputTextCtrl 
     14from .inversion_state import InversionState 
     15from .pr_widgets import PrTextCtrl 
     16from .pr_widgets import DataFileTextCtrl 
     17from .pr_widgets import OutputTextCtrl 
    1818from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
    1919 
     
    754754        except: 
    755755            # No estimate or bad estimate, either do nothing 
    756             logger.error("InversionControl._on_accept_alpha: %s" % sys.exc_value) 
     756            logger.error("InversionControl._on_accept_alpha: %s" % sys.exc_info()[1]) 
    757757 
    758758    def _on_accept_nterms(self, evt): 
     
    770770        except: 
    771771            # No estimate or bad estimate, either do nothing 
    772             logger.error("InversionControl._on_accept_nterms: %s" % sys.exc_value) 
     772            logger.error("InversionControl._on_accept_nterms: %s" % sys.exc_info()[1]) 
    773773 
    774774    def clear_panel(self): 
     
    901901                message += "than the number of points" 
    902902                wx.PostEvent(self._manager.parent, StatusEvent(status=message)) 
    903                 raise ValueError, message 
     903                raise ValueError(message) 
    904904            self.nfunc_ctl.SetBackgroundColour(wx.WHITE) 
    905905            self.nfunc_ctl.Refresh() 
     
    957957        Invoke the d_max exploration dialog 
    958958        """ 
    959         from explore_dialog import ExploreDialog 
     959        from .explore_dialog import ExploreDialog 
    960960        if self._manager._last_pr is not None: 
    961961            pr = self._manager._create_plot_pr() 
     
    10091009                self._set_analysis(True) 
    10101010            except: 
    1011                 msg = "InversionControl._change_file: %s" % sys.exc_value 
     1011                msg = "InversionControl._change_file: %s" % sys.exc_info()[1] 
    10121012                logger.error(msg) 
    10131013 
  • src/sas/sasgui/perspectives/pr/inversion_state.py

    • Property mode changed from 100644 to 100755
    r1fa4f736 rfa81e94  
    238238            msg = "InversionState no longer supports non-CanSAS" 
    239239            msg += " format for P(r) files" 
    240             raise RuntimeError, msg 
     240            raise RuntimeError(msg) 
    241241 
    242242        if node.get('version') and node.get('version') == '1.0': 
     
    254254                except: 
    255255                    msg = "InversionState.fromXML: Could not read " 
    256                     msg += "timestamp\n %s" % sys.exc_value 
     256                    msg += "timestamp\n %s" % sys.exc_info()[1] 
    257257                    logger.error(msg) 
    258258 
     
    434434        except: 
    435435            msg = "XML document does not contain P(r) " 
    436             msg += "information.\n %s" % sys.exc_value 
     436            msg += "information.\n %s" % sys.exc_info()[1] 
    437437            logger.info(msg) 
    438438 
     
    481481                        output.append(sas_entry) 
    482482        else: 
    483             raise RuntimeError, "%s is not a file" % path 
     483            raise RuntimeError("%s is not a file" % path) 
    484484 
    485485        # Return output consistent with the loader's api 
     
    525525            msg = "The cansas writer expects a Data1D " 
    526526            msg += "instance: %s" % str(datainfo.__class__.__name__) 
    527             raise RuntimeError, msg 
     527            raise RuntimeError(msg) 
    528528 
    529529        # Create basic XML document 
  • src/sas/sasgui/perspectives/pr/pr.py

    • Property mode changed from 100644 to 100755
    rcb62bd5 rfa81e94  
    1515# Make sure the option of saving each curve is available 
    1616# Use the I(q) curve as input and compare the output to P(r) 
    17 from __future__ import print_function 
     17 
    1818 
    1919import sys 
     
    3333import sas.sascalc.dataloader 
    3434 
    35 from pr_widgets import load_error 
     35from .pr_widgets import load_error 
    3636from sas.sasgui.guiframe.plugin_base import PluginBase 
    3737 
     
    107107 
    108108        # Associate the inversion state reader with .prv files 
    109         from inversion_state import Reader 
     109        from .inversion_state import Reader 
    110110 
    111111        # Create a CanSAS/Pr reader 
     
    151151                msg = "Pr.set_state: datainfo parameter cannot " 
    152152                msg += "be None in standalone mode" 
    153                 raise RuntimeError, msg 
     153                raise RuntimeError(msg) 
    154154 
    155155            # Ensuring that plots are coordinated correctly 
     
    185185            self.control_panel.set_state(state) 
    186186        except: 
    187             logger.error("prview.set_state: %s" % sys.exc_value) 
     187            logger.error("prview.set_state: %s" % sys.exc_info()[1]) 
    188188 
    189189 
     
    195195 
    196196        """ 
    197         from inversion_panel import HelpDialog 
     197        from .inversion_panel import HelpDialog 
    198198        dialog = HelpDialog(None, -1) 
    199199        if dialog.ShowModal() == wx.ID_OK: 
     
    369369        Redisplay P(r) with a different number of points 
    370370        """ 
    371         from inversion_panel import PrDistDialog 
     371        from .inversion_panel import PrDistDialog 
    372372        dialog = PrDistDialog(None, -1) 
    373373        dialog.set_content(self._pr_npts) 
     
    452452        # Notify the user if we could not read the file 
    453453        if dataread is None: 
    454             raise RuntimeError, "Invalid data" 
     454            raise RuntimeError("Invalid data") 
    455455 
    456456        x = None 
     
    472472                if dataread is None: 
    473473                    return x, y, err 
    474                 raise RuntimeError, "This tool can only read 1D data" 
     474                raise RuntimeError("This tool can only read 1D data") 
    475475 
    476476        self._current_file_data.x = x 
     
    512512                    data_err = np.append(data_err, err) 
    513513                except: 
    514                     logger.error(sys.exc_value) 
     514                    logger.error(sys.exc_info()[1]) 
    515515 
    516516        if scale is not None: 
     
    563563                        data_err = np.append(data_err, err) 
    564564                    except: 
    565                         logger.error(sys.exc_value) 
     565                        logger.error(sys.exc_info()[1]) 
    566566                elif line.find("The 6 columns") >= 0: 
    567567                    data_started = True 
     
    720720            Start a calculation thread 
    721721        """ 
    722         from pr_thread import CalcPr 
     722        from .pr_thread import CalcPr 
    723723 
    724724        # If a thread is already started, stop it 
     
    850850                pr = self._create_file_pr(data) 
    851851            except: 
    852                 status = "Problem reading data: %s" % sys.exc_value 
     852                status = "Problem reading data: %s" % sys.exc_info()[1] 
    853853                wx.PostEvent(self.parent, StatusEvent(status=status)) 
    854                 raise RuntimeError, status 
     854                raise RuntimeError(status) 
    855855 
    856856            # If the file contains nothing, just return 
    857857            if pr is None: 
    858                 raise RuntimeError, "Loaded data is invalid" 
     858                raise RuntimeError("Loaded data is invalid") 
    859859 
    860860            self.pr = pr 
     
    906906            msg = "pr.save_data: the data being saved is not a" 
    907907            msg += " sas.data_info.Data1D object" 
    908             raise RuntimeError, msg 
     908            raise RuntimeError(msg) 
    909909 
    910910    def setup_plot_inversion(self, alpha, nfunc, d_max, q_min=None, q_max=None, 
     
    929929                self.perform_inversion() 
    930930        except: 
    931             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     931            wx.PostEvent(self.parent, StatusEvent(status=sys.exc_info()[1])) 
    932932 
    933933    def estimate_plot_inversion(self, alpha, nfunc, d_max, 
     
    953953                self.perform_estimate() 
    954954        except: 
    955             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     955            wx.PostEvent(self.parent, StatusEvent(status=sys.exc_info()[1])) 
    956956 
    957957    def _create_plot_pr(self, estimate=False): 
     
    10341034                self.perform_inversion() 
    10351035        except: 
    1036             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     1036            wx.PostEvent(self.parent, StatusEvent(status=sys.exc_info()[1])) 
    10371037 
    10381038    def estimate_file_inversion(self, alpha, nfunc, d_max, data, 
     
    10571057                self.perform_estimate() 
    10581058        except: 
    1059             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     1059            wx.PostEvent(self.parent, StatusEvent(status=sys.exc_info()[1])) 
    10601060 
    10611061    def _create_file_pr(self, data): 
     
    10861086            x, y, err = data.x, data.y, data.dy 
    10871087        except: 
    1088             load_error(sys.exc_value) 
     1088            load_error(sys.exc_info()[1]) 
    10891089            return None 
    10901090 
     
    11251125            return pr 
    11261126        except: 
    1127             load_error(sys.exc_value) 
     1127            load_error(sys.exc_info()[1]) 
    11281128        return None 
    11291129 
     
    11321132            Perform parameter estimation 
    11331133        """ 
    1134         from pr_thread import EstimatePr 
     1134        from .pr_thread import EstimatePr 
    11351135 
    11361136        # If a thread is already started, stop it 
     
    11621162            Perform parameter estimation 
    11631163        """ 
    1164         from pr_thread import EstimateNT 
     1164        from .pr_thread import EstimateNT 
    11651165 
    11661166        # If a thread is already started, stop it 
     
    12391239            Create and return a list of panel objects 
    12401240        """ 
    1241         from inversion_panel import InversionControl 
     1241        from .inversion_panel import InversionControl 
    12421242 
    12431243        self.parent = parent 
     
    12871287                msg += "Please select one.\n" 
    12881288                if len(data_list) > 1: 
    1289                     from pr_widgets import DataDialog 
     1289                    from .pr_widgets import DataDialog 
    12901290                    dlg = DataDialog(data_list=data_1d_list, text=msg) 
    12911291                    if dlg.ShowModal() == wx.ID_OK: 
     
    13071307                    self.control_panel._change_file(evt=None, data=data) 
    13081308                except: 
    1309                     msg = "Prview Set_data: " + str(sys.exc_value) 
     1309                    msg = "Prview Set_data: " + str(sys.exc_info()[1]) 
    13101310                    wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    13111311            else: 
  • src/sas/sasgui/perspectives/pr/pr_thread.py

    • Property mode changed from 100644 to 100755
    rac07a3a rfa81e94  
    4343        except: 
    4444            if self.error_func is not None: 
    45                 self.error_func("CalcPr.compute: %s" % sys.exc_value) 
     45                self.error_func("CalcPr.compute: %s" % sys.exc_info()[1]) 
    4646 
    4747class EstimatePr(CalcThread): 
     
    7171        except: 
    7272            if self.error_func is not None: 
    73                 self.error_func("EstimatePr.compute: %s" % sys.exc_value) 
     73                self.error_func("EstimatePr.compute: %s" % sys.exc_info()[1]) 
    7474 
    7575class EstimateNT(CalcThread): 
     
    111111        except: 
    112112            if self.error_func is not None: 
    113                 self.error_func("EstimatePr2.compute: %s" % sys.exc_value) 
     113                self.error_func("EstimatePr2.compute: %s" % sys.exc_info()[1]) 
Note: See TracChangeset for help on using the changeset viewer.