Changeset 5251ec6 in sasview for src/sas/sasgui/perspectives


Ignore:
Timestamp:
Oct 11, 2018 12:20:56 PM (6 years ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1249
Children:
98b9f32
Parents:
67ed543
Message:

improved support for py37 in sasgui

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

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/perspectives/calculator/__init__.py

    r5a405bd r5251ec6  
    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/calculator.py

    r61bfd36 r5251ec6  
    1212################################################################################ 
    1313 
     14import logging 
     15 
    1416import wx 
     17 
    1518from sas.sasgui.guiframe.plugin_base import PluginBase 
    1619from sas.sasgui.perspectives.calculator.data_operator import DataOperatorWindow 
    … …  
    2629from sas.sasgui.perspectives.calculator.image_viewer import ImageView 
    2730from sas.sasgui.perspectives.calculator.pyconsole import PyConsole 
    28 import logging 
    2931 
    3032logger = logging.getLogger(__name__) 

  • src/sas/sasgui/perspectives/calculator/collimation_editor.py

    r959eb01 r5251ec6  
    11""" 
    22""" 
    3 import wx 
    43import sys 
    54from copy import deepcopy 
     5 
     6import wx 
     7 
    68from sas.sascalc.dataloader.loader import Loader 
    79from sas.sascalc.dataloader.data_info import Aperture, Collimation 
    8 from aperture_editor import ApertureDialog 
    9  
    1010from sas.sasgui.guiframe.utils import check_float 
     11 
     12from .aperture_editor import ApertureDialog 
     13 
    1114_BOX_WIDTH = 60 
    1215 

  • src/sas/sasgui/perspectives/calculator/data_editor.py

    r235f514 r5251ec6  
    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 
    129 
    1310from sas.sasgui.guiframe.events import StatusEvent 
     11 
     12from .detector_editor import DetectorDialog 
     13from .collimation_editor import CollimationDialog 
     14from .console import ConsoleDialog 
     15 
    1416 
    1517 
    … …  
    397399        if data is None: 
    398400            return 
    399         from sample_editor import SampleDialog 
     401        from .sample_editor import SampleDialog 
    400402        dlg = SampleDialog(parent=self, sample=data.sample) 
    401403        dlg.set_manager(self) 
    … …  
    409411        if data is None: 
    410412            return 
    411         from source_editor import SourceDialog 
     413        from .source_editor import SourceDialog 
    412414        dlg = SourceDialog(parent=self, source=data.source) 
    413415        dlg.set_manager(self) 
    … …  
    426428        wlist = '|'.join(cards) 
    427429 
    428         dlg = wx.FileDialog(self, "Choose a file", location, "", wlist, wx.OPEN) 
     430        dlg = wx.FileDialog(self, "Choose a file", location, "", wlist, wx.FD_OPEN) 
    429431        if dlg.ShowModal() == wx.ID_OK: 
    430432            path = dlg.GetPath() 
    … …  
    527529        try: 
    528530            #Load data 
    529             from load_thread import DataReader 
     531            from .load_thread import DataReader 
    530532            ## If a thread is already started, stop it 
    531533            if self.reader is not None and self.reader.isrunning(): 
    … …  
    535537                                    updatefn=None) 
    536538            self.reader.queue() 
    537         except: 
    538             msg = "Data Editor: %s" % (sys.exc_value) 
     539        except Exception as exc: 
     540            msg = "Data Editor: %s" % exc 
    539541            load_error(msg) 
    540542            return 

  • src/sas/sasgui/perspectives/calculator/data_operator.py

    r7432acb r5251ec6  
    202202        else: 
    203203            text = name 
    204         state_list = self.get_datalist().values() 
    205204        name_list = [] 
    206         for state in state_list: 
     205        for state in self.get_datalist().values(): 
    207206            if state.data is None: 
    208207                theory_list = state.get_theory() 
    209                 theory, _ = theory_list.values()[0] 
     208                theory, _ = list(theory_list.values())[0] 
    210209                d_name = str(theory.name) 
    211210            else: 
    … …  
    393392        try: 
    394393            self.output = self.make_data_out(data1, data2) 
    395         except: 
     394        except Exception as exc: 
    396395            self._check_newname() 
    397396            self._set_textctrl_color(self.data1_cbox, 'pink') 
    398397            self._set_textctrl_color(self.data2_cbox, 'pink') 
    399             msg = "DataOperation: %s" % sys.exc_value 
     398            msg = "DataOperation: %s" % exc 
    400399            self.send_warnings(msg, 'error') 
    401400            self.output = None 
    … …  
    411410        operator = self.operator_cbox.GetClientData(pos) 
    412411        try: 
    413             exec "output = data1 %s data2" % operator 
     412            output = eval("data1 %s data2" % operator, 
     413                          {"data1": data1, "data2": data2}) 
    414414        except: 
    415415            raise 
    … …  
    532532        self.data2_cbox.SetClientData(pos3, val) 
    533533        dnames = [] 
    534         ids = self._data.keys() 
    535         for id in ids: 
     534        for id in self._data.keys(): 
    536535            if id is not None: 
    537536                if self._data[id].data is not None: 
    … …  
    539538                else: 
    540539                    theory_list = self._data[id].get_theory() 
    541                     theory, _ = theory_list.values()[0] 
     540                    theory, _ = list(theory_list.values())[0] 
    542541                    dnames.append(theory.name) 
    543542        ind = np.argsort(dnames) 
    544543        if len(ind) > 0: 
    545             val_list = np.array(self._data.values())[ind] 
     544            val_list = np.array(list(self._data.values()))[ind] 
    546545            for datastate in val_list: 
    547546                data = datastate.data 
    … …  
    588587        self.send_warnings('') 
    589588        self.data_namectr.SetBackgroundColour('white') 
    590         state_list = self.get_datalist().values() 
    591589        name = self.data_namectr.GetValue().strip() 
    592590        name_list = [] 
    593         for state in state_list: 
     591        for state in self.get_datalist().values(): 
    594592            if state.data is None: 
    595593                theory_list = state.get_theory() 
    596                 theory, _ = theory_list.values()[0] 
     594                theory, _ = list(theory_list.values())[0] 
    597595                d_name = str(theory.name) 
    598596            else: 
    … …  
    889887    def _onProperties(self, event): 
    890888        """ 
    891         when clicking on Properties on context menu , 
    892         The Property dialog is displayed 
    893         The user selects a transformation for x or y value and 
    894         a new plot is displayed 
    895         """ 
    896         list = [] 
    897         list = self.graph.returnPlottable() 
    898         if len(list.keys()) > 0: 
    899             first_item = list.keys()[0] 
     889        When clicking on Properties on context menu, the 
     890        Property dialog is displayed the user selects a 
     891        transformation for x or y value and a new plot is displayed 
     892        """ 
     893        plottables = self.graph.returnPlottable() 
     894        if plottables: 
     895            # TODO: key order is random prior to py 3.7 
     896            first_item = list(plottables.keys())[0] 
    900897            if first_item.x != []: 
    901898                from sas.sasgui.plottools.PropertyDialog import Properties 
    … …  
    929926        and set the scale 
    930927        """ 
    931         list = [] 
    932         list = self.graph.returnPlottable() 
    933928        # Changing the scale might be incompatible with 
    934929        # currently displayed data (for instance, going 
    … …  
    940935        _xscale = 'linear' 
    941936        _yscale = 'linear' 
    942         for item in list: 
     937        for item in self.graph.returnPlottable(): 
    943938            item.setLabel(self.xLabel, self.yLabel) 
    944939            # control axis labels from the panel itself 

  • src/sas/sasgui/perspectives/calculator/density_panel.py

    r7432acb r5251ec6  
    362362            self.molar_mass_ctl.SetValue(str(self._format_number(molar_mass))) 
    363363            self.output_ctl.SetValue(str(output)) 
    364         except: 
     364        except Exception as exc: 
    365365            if self.base is not None: 
    366                 msg = "Density/Volume Calculator: %s" % (sys.exc_value) 
     366                msg = "Density/Volume Calculator: %s" % exc 
    367367                wx.PostEvent(self.base, StatusEvent(status=msg)) 
    368368        if event is not None: 

  • src/sas/sasgui/perspectives/calculator/detector_editor.py

    ra1b8fee r5251ec6  
    3434            self._do_layout() 
    3535            self.set_values() 
    36         except: 
    37             print("error", sys.exc_value) 
     36        except Exception as exc: 
     37            print("error", exc) 
    3838 
    3939    def _define_structure(self): 

  • src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py

    r20fa5fe r5251ec6  
    228228        sizer.Add(unit_title, (iy, ix), (1, 1), \ 
    229229                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    230         key_list = params.keys() 
    231         key_list.sort() 
    232         for param in key_list: 
     230        for param in sorted(params.keys()): 
    233231            iy += 1 
    234232            ix = 0 
    … …  
    341339        ix = 0 
    342340        iy = 0 
    343         #key_list.sort() 
    344341        name = wx.StaticText(self, -1, 'No. of Qx (Qy) bins: ') 
    345342        sizer.Add(name, (iy, ix), (1, 1), \ 
    … …  
    509506        wildcard = '|'.join(wildcard) 
    510507        dlg = wx.FileDialog(self, "Choose a file", location, 
    511                             "", wildcard, wx.OPEN) 
     508                            "", wildcard, wx.FD_OPEN) 
    512509        if dlg.ShowModal() == wx.ID_OK: 
    513510            path = dlg.GetPath() 
    … …  
    556553            self.reader.queue() 
    557554            #self.load_update() 
    558         except: 
     555        except Exception as exc: 
    559556            self.ext = None 
    560557            if self.parent.parent is None: 
    561558                return 
    562             msg = "Generic SAS Calculator: %s" % (sys.exc_value) 
     559            msg = "Generic SAS Calculator: %s" % exc 
    563560            wx.PostEvent(self.parent.parent, 
    564561                          StatusEvent(status=msg, type='stop')) 
    … …  
    774771            if output.pix_type == 'atom': 
    775772                # Get atom names not in the list 
    776                 a_names = [symb  for symb in pix_symbol \ 
    777                            if symb not in color_dic.keys()] 
     773                a_names = [symb  for symb in pix_symbol 
     774                           if symb not in color_dic] 
    778775                a_name = a_names[0] 
    779776                for name in a_names: 
    … …  
    898895            cal_out.queue() 
    899896 
    900         except: 
    901             msg = "%s." % sys.exc_value 
     897        except Exception as exc: 
     898            msg = "%s." % exc 
    902899            status_type = 'stop' 
    903900            self._status_info(msg, status_type) 
    … …  
    13441341            self.sld_data.is_data = False 
    13451342            self.sld_data.filename = "Default SLD Profile" 
    1346         except: 
    1347             msg = "OMF Panel: %s" % sys.exc_value 
     1343        except Exception as exc: 
     1344            msg = "OMF Panel: %s" % exc 
    13481345            infor = 'Error' 
    13491346            #logger.error(msg) 
    … …  
    14411438            raise 
    14421439        sld_key_list = self._get_slds_key_list(omfdata) 
    1443         # Dic is not sorted 
    1444         key_list = [key for key in sld_key_list.keys()] 
    1445         # Sort here 
    1446         key_list.sort() 
    14471440        is_data = self.sld_data.is_data 
    14481441        sizer = wx.GridBagSizer(2, 3) 
    14491442        ix = 0 
    14501443        iy = -1 
    1451         for key in key_list: 
    1452             value = sld_key_list[key] 
     1444        for key, value in sorted(sld_key_list.items()): 
    14531445            iy += 1 
    14541446            ix = 0 
    … …  
    14851477        ix = 0 
    14861478        iy = -1 
    1487         for key, value in key_list.iteritems(): 
     1479        for key, value in sorted(key_list.items()): 
    14881480            iy += 1 
    14891481            ix = 0 
    … …  
    15201512        ix = 0 
    15211513        iy = -1 
    1522         #key_list.sort() 
    1523         for key, value in key_list.iteritems(): 
     1514        for key, value in sorted(key_list.items()): 
    15241515            iy += 1 
    15251516            ix = 0 

  • src/sas/sasgui/perspectives/calculator/image_viewer.py

    r412e9e8b r5251ec6  
    9595        if location is None: 
    9696            location = os.getcwd() 
    97         wildcard="Images (*.bmp;*.gif;*jpeg,*jpg;*.png;*tif;*.tiff)|*bmp;\ 
    98             *.gif; *.jpg; *.jpeg;*png;*.png;*.tif;*.tiff|"\ 
    99             "Bitmap (*.bmp)|*.bmp|"\ 
    100             "GIF (*.gif)|*.gif|"\ 
    101             "JPEG (*.jpg;*.jpeg)|*.jpg;*.jpeg|"\ 
    102             "PNG (*.png)|*.png|"\ 
    103             "TIFF (*.tif;*.tiff)|*.tif;*tiff|"\ 
    104             "All Files (*.*)|*.*|" 
     97        wildcard="|".join(( 
     98            "Images (*.bmp;*.gif;*jpeg,*jpg;*.png;*tif;*.tiff)" 
     99                "|*bmp;*.gif;*.jpg;*.jpeg;*png;*.png;*.tif;*.tiff", 
     100            "Bitmap (*.bmp)|*.bmp", 
     101            "GIF (*.gif)|*.gif", 
     102            "JPEG (*.jpg;*.jpeg)|*.jpg;*.jpeg", 
     103            "PNG (*.png)|*.png", 
     104            "TIFF (*.tif;*.tiff)|*.tif;*tiff", 
     105            "All Files (*.*)|*.*", 
     106            )) 
    105107 
    106108        dlg = wx.FileDialog(self.parent, "Image Viewer: Choose an image file", 

  • src/sas/sasgui/perspectives/calculator/kiessig_calculator_panel.py

    r7432acb r5251ec6  
    1212import sys 
    1313 
     14from sas.sascalc.calculator.kiessig_calculator import KiessigThicknessCalculator 
    1415from sas.sasgui.guiframe.panel_base import PanelBase 
    15 from sas.sascalc.calculator.kiessig_calculator import KiessigThicknessCalculator 
    16 from calculator_widgets import OutputTextCtrl 
    17 from calculator_widgets import InputTextCtrl 
    1816from sas.sasgui.perspectives.calculator import calculator_widgets as widget 
    1917from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     18from .calculator_widgets import OutputTextCtrl 
     19from .calculator_widgets import InputTextCtrl 
    2020 
    2121_BOX_WIDTH = 77 

  • src/sas/sasgui/perspectives/calculator/model_editor.py

    r9bf40e7 r5251ec6  
    578578        self.base = base 
    579579        self.path = path 
    580         self.font = wx.SystemSettings_GetFont(wx.SYS_SYSTEM_FONT) 
     580        self.font = wx.SystemSettings.GetFont(wx.SYS_SYSTEM_FONT) 
    581581        self.font.SetPointSize(10) 
    582582        self.reader = None 
    … …  
    781781            if item.count("_") < 1: 
    782782                try: 
    783                     exec "float(math.%s)" % item 
     783                    exec("float(math.%s)" % item) 
    784784                    self.math_combo.Append(str(item)) 
    785785                except Exception: 

  • src/sas/sasgui/perspectives/calculator/resolcal_thread.py

    r20fa5fe r5251ec6  
    4646        executing computation 
    4747        """ 
    48         self.image = map(self.func, self.qx, self.qy, 
    49                         self.qx_min, self.qx_max, 
    50                         self.qy_min, self.qy_max)[0] 
     48        self.image = list(map(self.func, self.qx, self.qy, 
     49                              self.qx_min, self.qx_max, 
     50                              self.qy_min, self.qy_max))[0] 
    5151        elapsed = time.time() - self.starttime 
    5252 

  • src/sas/sasgui/perspectives/calculator/resolution_calculator_panel.py

    r1cf490b6 r5251ec6  
    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) 
    … …  
    667667        Execute the computation of resolution 
    668668        """ 
     669        # Clone the event before CallAfter; the event seems 
     670        # to delete the event when it is done processing, so 
     671        # the original will not be available when the call 
     672        # after method starts. 
     673        if event is not None: 
     674            event = event.Clone() 
    669675        wx.CallAfter(self.on_compute_call, event) 
    670676 
    … …  
    753759            wx.MessageBox(msg, 'Warning') 
    754760            return 
    755             #raise ValueError, "Invalid Q Input..." 
     761            #raise ValueError("Invalid Q Input...") 
    756762 
    757763        # Validate the q inputs 
    … …  
    934940    def _sigma_strings(self): 
    935941        """ 
    936         Recode sigmas as strins 
     942        Recode sigmas as strings 
    937943        """ 
    938944        sigma_r = self.format_number(self.resolution.sigma_1) 
    … …  
    10821088                msg = "The numbers must be one or two (separated by ',')..." 
    10831089                self._status_info(msg, 'stop') 
    1084                 raise RuntimeError, msg 
     1090                raise RuntimeError(msg) 
    10851091 
    10861092        return new_string 
    … …  
    10991105                value = float(string_split[ind]) 
    11001106                new_string.append(value) 
    1101             except: 
    1102                 logger.error(sys.exc_value) 
     1107            except Exception as exc: 
     1108                logger.error(exc) 
    11031109 
    11041110        return new_string 
    … …  
    11411147                        out = self._string2inputlist(string) 
    11421148                        return out 
    1143                 except: 
    1144                     logger.error(sys.exc_value) 
     1149                except Exception as exc: 
     1150                    logger.error(exc) 
    11451151 
    11461152    def _on_xy_coordinate(self, event=None): 
    … …  
    12691275            try: 
    12701276                basename = os.path.basename(path) 
    1271                 if basename not in self.spectrum_dic.keys(): 
     1277                if basename not in self.spectrum_dic: 
    12721278                    self.spectrum_cb.Append(basename) 
    12731279                self.spectrum_dic[basename] = self._read_file(path) 
    … …  
    12861292        dlg = wx.FileDialog(self, 
    12871293                            "Choose a wavelength spectrum file: Intensity vs. wavelength", 
    1288                             self.parent.parent.get_save_location() , "", "*.*", wx.OPEN) 
     1294                            self.parent.parent.get_save_location() , "", "*.*", wx.FD_OPEN) 
    12891295        path = None 
    12901296        if dlg.ShowModal() == wx.ID_OK: 
    … …  
    13181324                    wavelength.append(wave) 
    13191325                    intensity.append(intens) 
    1320                 except: 
     1326                except Exception as exc: 
    13211327                    # Skip non-data lines 
    1322                     logger.error(sys.exc_value) 
     1328                    logger.error(exc) 
    13231329 
    13241330            return [wavelength, intensity] 

  • src/sas/sasgui/perspectives/calculator/sld_panel.py

    r2d220dd r5251ec6  
    363363 
    364364        """ 
     365        # TODO: use periodictable.elements object 
     366        #    energy = xray_energy(periodictable.elements[element].K_alpha) 
     367        # TODO: code is very similar to sld helper 
    365368        myformula = formula(str(element)) 
    366369        if len(myformula.atoms) != 1: 
    367370            return 
    368         element = myformula.atoms.keys()[0] 
     371        element = list(myformula.atoms.keys())[0] 
    369372        energy = xray_energy(element.K_alpha) 
    370373 
    … …  
    413416                    msg += "Error for wavelength value :expect float" 
    414417            elif (self.xray_source == 'Element'): 
     418                # TODO: use periodictable.elements instead of exec() hacks 
     419                #     if self.xray_source_input not in periodictable.elements: 
     420                #         ... 
    415421                try: 
    416422                    import periodictable 
    … …  
    447453 
    448454        """ 
     455        # TODO: use periodictable.elements object 
     456        #    energy = xray_energy(periodictable.elements[element].K_alpha) 
    449457        element_formula = formula(str(element)) 
    450458        if len(element_formula.atoms) != 1: 
    451459            return 
    452         element = element_formula.atoms.keys()[0] 
     460        element = list(element_formula.atoms.keys())[0] 
    453461        energy = xray_energy(element.K_alpha) 
     462 
    454463        atom = molecule_formula.atoms 
    455464        return xray_sld_from_atoms(atom, density=density, energy=energy) 
    … …  
    505514            #self.wavelength_ctl.SetValue(str(self.wavelength)) 
    506515            #self.wavelength_ctl.SetValue(str(self.wavelength)) 
    507         except: 
     516        except Exception as exc: 
    508517            if self.base is not None: 
    509                 msg = "SLD Calculator: %s" % (sys.exc_value) 
     518                msg = "SLD Calculator: %s" % exc 
    510519                wx.PostEvent(self.base, StatusEvent(status=msg)) 
    511520        if event is not None: 

  • src/sas/sasgui/perspectives/calculator/slit_length_calculator_panel.py

    rd788619 r5251ec6  
    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 
    2119from sas.sasgui.perspectives.calculator import calculator_widgets as widget 
    2220from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     21from .calculator_widgets import OutputTextCtrl 
     22from .calculator_widgets import InterActiveOutputTextCtrl 
    2323 
    2424_BOX_WIDTH = 76 
    … …  
    163163 
    164164        dlg = wx.FileDialog(self, "Choose a file", location, 
    165                             "", wildcard, wx.OPEN) 
     165                            "", wildcard, wx.FD_OPEN) 
    166166        if dlg.ShowModal() == wx.ID_OK: 
    167167            path = dlg.GetPath() 
    … …  
    223223            self.reader.queue() 
    224224            self.load_update() 
    225         except: 
     225        except Exception as exc: 
    226226            if self.parent.parent is None: 
    227227                return 
    228             msg = "Slit Length Calculator: %s" % (sys.exc_value) 
     228            msg = "Slit Length Calculator: %s" % exc 
    229229            wx.PostEvent(self.parent.parent, 
    230230                          StatusEvent(status=msg, type='stop')) 
    … …  
    264264            if x == [] or  x is None or y == [] or y is None: 
    265265                msg = "The current data is empty please check x and y" 
    266                 raise ValueError, msg 
     266                raise ValueError(msg) 
    267267            slit_length_calculator = SlitlengthCalculator() 
    268268            slit_length_calculator.set_data(x=x, y=y) 
    269269            slit_length = slit_length_calculator.calculate_slit_length() 
    270         except: 
     270        except Exception as exc: 
    271271            if self.parent.parent is None: 
    272272                return 
    273             msg = "Slit Size Calculator: %s" % (sys.exc_value) 
     273            msg = "Slit Size Calculator: %s" % exc 
    274274            wx.PostEvent(self.parent.parent, 
    275275                          StatusEvent(status=msg, type='stop')) 

  • src/sas/sasgui/perspectives/corfunc/__init__.py

    rc23f303 r5251ec6  
    11PLUGIN_ID = "Corfunc Plug-In 0.1" 
    2 from corfunc import * 
     2from .corfunc import * 

  • src/sas/sasgui/perspectives/corfunc/corfunc.py

    r9b90bf8 r5251ec6  
    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__) 
    … …  
    148148                    self.data_id = data.id 
    149149                    self.corfunc_panel.set_data(data) 
    150                 except: 
    151                     msg = "Corfunc set_data: " + str(sys.exc_value) 
     150                except Exception as exc: 
     151                    msg = "Corfunc set_data: " + str(exc) 
    152152                    wx.PostEvent(self.parent, StatusEvent(status=msg, 
    153153                        info='error')) 

  • src/sas/sasgui/perspectives/corfunc/corfunc_panel.py

    r5652efc r5251ec6  
    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 = { 
    … …  
    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) 
    … …  
    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) 
    … …  
    549549            wx.CENTER | wx.ADJUST_MINSIZE, 15) 
    550550 
    551         file_sizer.AddSpacer((1, 25), pos=(0,2)) 
     551        #file_sizer.AddSpacer((1, 25), pos=(0,2)) 
    552552        databox_sizer.Add(file_sizer, wx.TOP, 15) 
    553553 
    … …  
    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

    r5652efc r5251ec6  
    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))) 
    … …  
    214214                try: 
    215215                    self.timestamp = (entry.get('epoch')) 
    216                 except: 
     216                except Exception as exc: 
    217217                    msg = ("CorfuncState.fromXML: Could not read timestamp", 
    218                         "\n{}").format(sys.exc_value) 
     218                        "\n{}").format(exc) 
    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 
    … …  
    358358                state = CorfuncState() 
    359359                state.fromXML(nodes[0]) 
    360         except: 
     360        except Exception as exc: 
    361361            msg = "XML document does not contain CorfuncState information\n{}" 
    362             msg.format(sys.exc_value) 
     362            msg.format(exc) 
    363363            logger.info(msg) 
    364364        return state 

  • src/sas/sasgui/perspectives/file_converter/__init__.py

    r77d92cd r5251ec6  
    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

    ra26f67f r5251ec6  
    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: 
    … …  
    343343            for datainfo in 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

    r0e11ec7 r5251ec6  
    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()) 

  • src/sas/sasgui/perspectives/fitting/__init__.py

    r12d3e0e r5251ec6  
    11PLUGIN_ID = "Fitting plug-in 1.0" 
    22import os 
    3 from fitting import * 
    43from distutils.filelist import findall 
     4from .fitting import * 
    55def get_data_path(media): 
    66    """ 

  • src/sas/sasgui/perspectives/fitting/basepage.py

    r5323490 r5251ec6  
    1212import logging 
    1313import traceback 
    14 from Queue import Queue 
     14try: 
     15    from Queue import Queue 
     16except ImportError: 
     17    from queue import Queue 
    1518from threading import Thread 
    1619from collections import defaultdict 
    … …  
    6669    FONT_VARIANT = 1 
    6770    ON_MAC = True 
     71if sys.version_info[0] >= 3: 
     72    unicode = str 
    6873 
    6974CUSTOM_MODEL = 'Plugin Models' 
    … …  
    115120        # Q range for data set 
    116121        self.qmin_data_set = np.inf 
    117         self.qmax_data_set = None 
     122        self.qmax_data_set = -np.inf 
    118123        self.npts_data_set = 0 
    119124        # Q range 
    … …  
    624629        if self.model is not None: 
    625630            self.m_name = self.model.name 
    626         if name in self.saved_states.keys(): 
     631        if name in self.saved_states: 
    627632            previous_state = self.saved_states[name] 
    628633            # reset state of checkbox,textcrtl  and  regular parameters value 
    … …  
    893898 
    894899        if len(self._disp_obj_dict) > 0: 
    895             for k, v in self._disp_obj_dict.iteritems(): 
     900            for k, v in self._disp_obj_dict.items(): 
    896901                self.state.disp_obj_dict[k] = v.type 
    897902 
    … …  
    960965 
    961966            if len(self.disp_cb_dict) > 0: 
    962                 for k, v in self.disp_cb_dict.iteritems(): 
     967                for k, v in self.disp_cb_dict.items(): 
    963968                    if v is None: 
    964969                        self.state.disp_cb_dict[k] = v 
    … …  
    969974                            self.state.disp_cb_dict[k] = None 
    970975            if len(self._disp_obj_dict) > 0: 
    971                 for k, v in self._disp_obj_dict.iteritems(): 
     976                for k, v in self._disp_obj_dict.items(): 
    972977                    self.state.disp_obj_dict[k] = v.type 
    973978 
    … …  
    10971102 
    10981103            else: 
    1099                 keys = self.model.getParamList() 
    1100                 for item in keys: 
     1104                for item in self.model.getParamList(): 
    11011105                    if item in self.disp_list and \ 
    11021106                            item not in self.model.details: 
    … …  
    11421146        :return: combo_box_position 
    11431147        """ 
    1144         for key, value in self.master_category_dict.iteritems(): 
     1148        for key, value in self.master_category_dict.items(): 
    11451149            formfactor = state.formfactorcombobox.split(":") 
    11461150            if isinstance(formfactor, list): 
    … …  
    13181322        Help to rest page for dispersions 
    13191323        """ 
    1320         keys = self.model.getParamList() 
    1321         for item in keys: 
     1324        for item in self.model.getParamList(): 
    13221325            if item in self.disp_list and \ 
    13231326                            item not in self.model.details: 
    13241327                self.model.details[item] = ["", None, None] 
    1325         # for k,v in self.state.disp_cb_dict.iteritems(): 
     1328        # for k,v in self.state.disp_cb_dict.items(): 
    13261329        self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    13271330        self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    … …  
    13291332        self.weights = copy.deepcopy(state.weights) 
    13301333 
    1331         for key, disp_type in state.disp_obj_dict.iteritems(): 
     1334        for key, disp_type in state.disp_obj_dict.items(): 
    13321335            # disp_model = disp 
    13331336            disp_model = POLYDISPERSITY_MODELS[disp_type]() 
    … …  
    13781381        dlg = wx.FileDialog(self, "Choose a weight file", 
    13791382                            self._default_save_location, "", 
    1380                             "*.*", wx.OPEN) 
     1383                            "*.*", wx.FD_OPEN) 
    13811384        path = None 
    13821385        if dlg.ShowModal() == wx.ID_OK: 
    … …  
    13901393        """ 
    13911394        ids = iter(self._id_pool)  # Reusing ids for context menu 
    1392         for name, _ in self.state.saved_states.iteritems(): 
     1395        for name, _ in self.state.saved_states.items(): 
    13931396            self.number_saved_state += 1 
    13941397            # Add item in the context menu 
    … …  
    19191922                else: 
    19201923                    tcrtl.SetBackgroundColour("pink") 
    1921                     msg = "Model Error: wrong value entered: %s" % \ 
    1922                           sys.exc_info()[1] 
     1924                    _, exc, _ = sys.exc_info() 
     1925                    msg = "Model Error: wrong value entered: %s" % exc 
    19231926                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    19241927                    return 
    1925             except Exception: 
     1928            except Exception as exc: 
    19261929                tcrtl.SetBackgroundColour("pink") 
    1927                 msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1] 
     1930                msg = "Model Error: wrong value entered: %s" % exc 
    19281931                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    19291932                return 
    … …  
    19761979                else: 
    19771980                    tcrtl.SetBackgroundColour("pink") 
    1978                     msg = "Model Error: wrong value entered: %s" % \ 
    1979                           sys.exc_info()[1] 
     1981                    _, exc, _ = sys.exc_info() 
     1982                    msg = "Model Error: wrong value entered: %s" % exc 
    19801983                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    19811984                    return 
    1982             except Exception: 
     1985            except Exception as exc: 
    19831986                tcrtl.SetBackgroundColour("pink") 
    1984                 msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1] 
     1987                msg = "Model Error: wrong value entered: %s" % exc 
    19851988                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    19861989                return 
    … …  
    22912294                    value_ctrl.SetValue(format_number(value)) 
    22922295 
    2293                 if name not in self.model.details.keys(): 
     2296                if name not in self.model.details: 
    22942297                    self.model.details[name] = ["", None, None] 
    22952298                old_low, old_high = self.model.details[name][1:3] 
    … …  
    27502753        gui_manager = self._manager.parent 
    27512754        # loops through the panels [dic] 
    2752         for _, item2 in gui_manager.plot_panels.iteritems(): 
     2755        for _, item2 in gui_manager.plot_panels.items(): 
    27532756            data_title = self.data.group_id 
    27542757            # try to get all plots belonging to this control panel 
    … …  
    33243327            if self.data.__class__.__name__ == "Data2D": 
    33253328                name = item[1] 
    3326                 if name in content.keys(): 
     3329                if name in content: 
    33273330                    values = content[name] 
    33283331                    check = values[0] 
    … …  
    33733376                if not item[1] in orient_param: 
    33743377                    name = item[1] 
    3375                     if name in content.keys(): 
     3378                    if name in content: 
    33763379                        check = content[name][0] 
    33773380                        # Avoid changing combox content 
    … …  
    34803483                self.state.weights = self.weights 
    34813484 
    3482         except Exception: 
     3485        except Exception as exc: 
    34833486            logger.error(traceback.format_exc()) 
    3484             print("Error in BasePage._paste_poly_help: %s" % \ 
    3485                   sys.exc_info()[1]) 
     3487            print("Error in BasePage._paste_poly_help: %s" % exc) 
    34863488 
    34873489    def _set_disp_cb(self, isarray, item): 
    … …  
    35483550 
    35493551        self.categorybox.Clear() 
    3550         cat_list = sorted(self.master_category_dict.keys()) 
     3552        cat_list = list(sorted(self.master_category_dict.keys())) 
    35513553        if uncat_str not in cat_list: 
    35523554            cat_list.append(uncat_str) 

  • src/sas/sasgui/perspectives/fitting/fit_thread.py

    rba8d326 r5251ec6  
    1212 
    1313def map_apply(arguments): 
    14     return apply(arguments[0], arguments[1:]) 
     14    fn, args = arguments[0], arguments[1:] 
     15    return fn(*args) 
    1516 
    1617class FitThread(CalcThread): 
    … …  
    5051        except KeyboardInterrupt: 
    5152            msg = "Fitting: terminated by the user." 
    52             raise KeyboardInterrupt, msg 
     53            raise KeyboardInterrupt(msg) 
    5354 
    5455    def compute(self): 
    … …  
    7677                         list_q, list_q, list_handler, list_curr_thread, 
    7778                         list_reset_flag) 
    78             result = map(map_apply, inputs) 
     79            result = list(map(map_apply, inputs)) 
    7980 
    8081            self.complete(result=result, 
    … …  
    8586                          elapsed=time.time() - self.starttime) 
    8687 
    87         except KeyboardInterrupt, msg: 
     88        except KeyboardInterrupt as msg: 
    8889            # Thread was interrupted, just proceed and re-raise. 
    8990            # Real code should not print, but this is an example... 

  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rba1c145 r5251ec6  
    766766                disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1), 
    767767                                       style=wx.CB_READONLY, name='%s' % name1) 
    768                 for key, value in POLYDISPERSITY_MODELS.iteritems(): 
     768                for key, value in POLYDISPERSITY_MODELS.items(): 
    769769                    name_disp = str(key) 
    770770                    disp_box.Append(name_disp, value) 
    … …  
    930930                disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1), 
    931931                                style=wx.CB_READONLY, name='%s' % name1) 
    932                 for key, value in POLYDISPERSITY_MODELS.iteritems(): 
     932                for key, value in POLYDISPERSITY_MODELS.items(): 
    933933                    name_disp = str(key) 
    934934                    disp_box.Append(name_disp, value) 
    … …  
    13721372                self._check_value_enter(self.fittable_param) 
    13731373                self._check_value_enter(self.parameters) 
    1374             except: 
     1374            except Exception as exc: 
    13751375                tcrtl.SetBackgroundColour("pink") 
    1376                 msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1376                msg = "Model Error:wrong value entered : %s" % exc 
    13771377                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    13781378                return 
    … …  
    14861486                else: 
    14871487                    tcrtl.SetBackgroundColour("pink") 
    1488                     msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1488                    _, exc, _ = sys.exc_info() 
     1489                    msg = "Model Error:wrong value entered : %s" % exc 
    14891490                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14901491                    return 
    1491             except: 
     1492            except Exception as exc: 
    14921493                tcrtl.SetBackgroundColour("pink") 
    1493                 msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1494                msg = "Model Error:wrong value entered : %s" % exc 
    14941495                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14951496                return 
    … …  
    18591860                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg, 
    18601861                                               info="error")) 
    1861                     raise ValueError, msg 
     1862                    raise ValueError(msg) 
    18621863 
    18631864            else: 
    … …  
    18711872                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg, 
    18721873                                               info="error")) 
    1873                     raise ValueError, msg 
     1874                    raise ValueError(msg) 
    18741875                # Maximum value of data 
    18751876                qmax = math.sqrt(x * x + y * y) 
    … …  
    21132114        self._on_fit_complete() 
    21142115        if out is None or not np.isfinite(chisqr): 
    2115             raise ValueError, "Fit error occured..." 
     2116            raise ValueError("Fit error occured...") 
    21162117 
    21172118        is_modified = False 
    … …  
    21882189                i += 1 
    21892190            else: 
    2190                 raise ValueError, "onsetValues: Invalid parameters..." 
     2191                raise ValueError("onsetValues: Invalid parameters...") 
    21912192        # Show error title when any errors displayed 
    21922193        if has_error: 
    … …  
    29472948        # type can be either Guassian or Array 
    29482949        if len(self.model.dispersion.values()) > 0: 
    2949             type = self.model.dispersion.values()[0]["type"] 
     2950            dist_type = list(self.model.dispersion.values())[0]["type"] 
    29502951        else: 
    2951             type = "Gaussian" 
     2952            dist_type = "Gaussian" 
    29522953 
    29532954        iy += 1 
    … …  
    30083009 
    30093010        # For Gaussian only 
    3010         if type.lower() != "array": 
     3011        if dist_type.lower() != "array": 
    30113012            for item in self.model.orientation_params: 
    30123013                if not self.magnetic_on: 

  • src/sas/sasgui/perspectives/fitting/fitpanel.py

    r69363c7 r5251ec6  
    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: 
    400400            for page in self.opened_pages.values(): 
    … …  
    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

    r20fa5fe r5251ec6  
    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

    raba4559 r5251ec6  
    147147        Given an ID create a fitproblem container 
    148148        """ 
    149         if page_id in self.page_finder.iterkeys(): 
     149        if page_id in self.page_finder: 
    150150            del self.page_finder[page_id] 
    151151 
    … …  
    356356            # categories, the updated plugin may be in either the form factor 
    357357            # or the structure factor combo boxes 
    358             for uid, page in self.fit_panel.opened_pages.iteritems(): 
     358            for uid, page in self.fit_panel.opened_pages.items(): 
    359359                pbox = getattr(page, "formfactorbox", None) 
    360360                sbox = getattr(page, "structurebox", None) 
    … …  
    417417                self.fit_panel.SetSelection(current_page_index) 
    418418 
    419         except Exception: 
    420             logger.error("update_custom_combo: %s", sys.exc_value) 
     419        except Exception as exc: 
     420            logger.error("update_custom_combo: %s", exc) 
    421421 
    422422    def set_edit_menu(self, owner): 
    … …  
    642642                            data.list_group_id.append(group_id) 
    643643                        self.add_fit_page(data=[data]) 
    644             except: 
    645                 msg = "Fitting set_data: " + str(sys.exc_value) 
     644            except Exception as exc: 
     645                msg = "Fitting set_data: " + str(exc) 
    646646                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    647647 
    … …  
    654654                _, theory_state = item 
    655655                self.fit_panel.set_model_state(theory_state) 
    656             except Exception: 
     656            except Exception as exc: 
    657657                msg = "Fitting: cannot deal with the theory received" 
    658658                evt = StatusEvent(status=msg, info="error") 
    659                 logger.error("set_theory " + msg + "\n" + str(sys.exc_value)) 
     659                logger.error("set_theory " + msg + "\n" + str(exc)) 
    660660                wx.PostEvent(self.parent, evt) 
    661661 
    … …  
    780780        if fid is None: 
    781781            return 
    782         if uid in self.page_finder.keys(): 
     782        if uid in self.page_finder: 
    783783            self.page_finder[uid].set_weight(flag=flag, is2d=is2d) 
    784784 
    … …  
    793793        :param qmax: maximum  value of the fit range 
    794794        """ 
    795         if uid in self.page_finder.keys(): 
     795        if uid in self.page_finder: 
    796796            self.page_finder[uid].set_range(qmin=qmin, qmax=qmax, fid=fid) 
    797797 
    … …  
    804804        :param uid: the id related to a page containing fitting information 
    805805        """ 
    806         if uid in self.page_finder.keys(): 
     806        if uid in self.page_finder: 
    807807            self.page_finder[uid].schedule_tofit(value) 
    808808 
    … …  
    823823        """ 
    824824        sim_page_id = self.sim_page.uid 
    825         for uid, value in self.page_finder.iteritems(): 
     825        for uid, value in self.page_finder.items(): 
    826826            if uid != sim_page_id and uid != self.batch_page.uid: 
    827827                model_list = value.get_model() 
    … …  
    888888        Stop the fit 
    889889        """ 
    890         if uid in self.fit_thread_list.keys(): 
     890        if uid in self.fit_thread_list: 
    891891            calc_fit = self.fit_thread_list[uid] 
    892892            if calc_fit is not  None and calc_fit.isrunning(): 
    … …  
    900900        batch_flag = self.batch_page is not None and uid == self.batch_page.uid 
    901901        if sim_flag or batch_flag: 
    902             for uid, value in self.page_finder.iteritems(): 
     902            for uid, value in self.page_finder.items(): 
    903903                if value.get_scheduled() == 1: 
    904                     if uid in self.fit_panel.opened_pages.keys(): 
     904                    if uid in self.fit_panel.opened_pages: 
    905905                        panel = self.fit_panel.opened_pages[uid] 
    906906                        panel._on_fit_complete() 
    … …  
    919919        :param draw: Determine if the theory needs to be plot 
    920920        """ 
    921         if uid not in self.page_finder.keys(): 
     921        if uid not in self.page_finder: 
    922922            return 
    923923        self.page_finder[uid].enable_smearing(flag=enable_smearer) 
    … …  
    930930                msg += "Got data = %s .\n" % str(data) 
    931931                return 
    932                 #raise ValueError, msg 
     932                #raise ValueError(msg) 
    933933            model = self.page_finder[uid].get_model(fid=fid) 
    934934            if model is None: 
    … …  
    10321032        list_page_id = [] 
    10331033        fit_id = 0 
    1034         for page_id, page_info in self.page_finder.iteritems(): 
     1034        for page_id, page_info in self.page_finder.items(): 
    10351035            # For simulfit (uid give with None), do for-loop 
    10361036            # if uid is specified (singlefit), do it only on the page. 
    … …  
    10591059 
    10601060                    pars = [str(element[1]) for element in page.param_toFit] 
    1061                     fitproblem_list = page_info.values() 
    1062                     for fitproblem in  fitproblem_list: 
     1061                    for fitproblem in page_info.values(): 
    10631062                        if sim_fitter is None: 
    10641063                            fitter = Fit() 
    … …  
    10791078                wx.PostEvent(self.parent, evt) 
    10801079                return True 
    1081             except: 
     1080            except Exception as exc: 
    10821081                raise 
    1083                 msg = "Fitting error: %s" % str(sys.exc_value) 
     1082                msg = "Fitting error: %s" % exc 
    10841083                evt = StatusEvent(status=msg, info="error", type="stop") 
    10851084                wx.PostEvent(self.parent, evt) 
    … …  
    11381137        :param fid: the id of the fitproblem(data, model, range,etc) 
    11391138        """ 
    1140         if uid not in self.page_finder.keys(): 
     1139        if uid not in self.page_finder: 
    11411140            return 
    11421141        fitproblemList = self.page_finder[uid].get_fit_problem(fid) 
    … …  
    11831182                evt = StatusEvent(status=msg, info="warning") 
    11841183                wx.PostEvent(self.parent, evt) 
    1185         except Exception: 
    1186             msg = "Creating Fit page: %s" % sys.exc_value 
     1184        except Exception as exc: 
     1185            msg = "Creating Fit page: %s" % exc 
    11871186            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    11881187 
    … …  
    12641263        # case that uid is not specified 
    12651264        if uid is None: 
    1266             for page_id in self.page_finder.keys(): 
     1265            for page_id in self.page_finder: 
    12671266                self.page_finder[page_id].schedule_tofit(value) 
    12681267        # when uid is given 
    12691268        else: 
    1270             if uid in self.page_finder.keys(): 
     1269            if uid in self.page_finder: 
    12711270                self.page_finder[uid].schedule_tofit(value) 
    12721271 
    … …  
    13021301        panel = self.plot_panel 
    13031302        if panel is None: 
    1304             raise ValueError, "Fitting:_onSelect: NonType panel" 
     1303            raise ValueError("Fitting:_onSelect: NonType panel") 
    13051304        Plugin.on_perspective(self, event=event) 
    13061305        self.select_data(panel) 
    … …  
    13351334        """ 
    13361335        uid = page_id[0] 
    1337         if uid in self.fit_thread_list.keys(): 
     1336        if uid in self.fit_thread_list: 
    13381337            del self.fit_thread_list[uid] 
    13391338 
    … …  
    13611360                #get all fittable parameters of the current model 
    13621361                for param in  model.getParamList(): 
    1363                     if param  not in batch_outputs.keys(): 
     1362                    if param  not in batch_outputs: 
    13641363                        batch_outputs[param] = [] 
    13651364                for param in model.getDispParamList(): 
    13661365                    if not model.is_fittable(param) and \ 
    1367                         param in batch_outputs.keys(): 
     1366                        param in batch_outputs: 
    13681367                        del batch_outputs[param] 
    13691368                # Add fitted parameters and their error 
    13701369                for param in res.param_list: 
    1371                     if param not in batch_outputs.keys(): 
     1370                    if param not in batch_outputs: 
    13721371                        batch_outputs[param] = [] 
    13731372                    err_param = "error on %s" % str(param) 
    1374                     if err_param not in batch_inputs.keys(): 
     1373                    if err_param not in batch_inputs: 
    13751374                        batch_inputs[err_param] = [] 
    13761375        msg = "" 
    … …  
    15261525        model = fitproblem.get_model() 
    15271526        #fill batch result information 
    1528         if "Data" not in batch_outputs.keys(): 
     1527        if "Data" not in batch_outputs: 
    15291528            batch_outputs["Data"] = [] 
    15301529        cell = BatchCell() 
    … …  
    15551554        cell.object = [data, theory_data] 
    15561555        batch_outputs["Data"].append(cell) 
    1557         for key, value in data.meta_data.iteritems(): 
    1558             if key not in batch_inputs.keys(): 
     1556        for key, value in data.meta_data.items(): 
     1557            if key not in batch_inputs: 
    15591558                batch_inputs[key] = [] 
    15601559            #if key.lower().strip() != "loader": 
    … …  
    15621561        param = "temperature" 
    15631562        if hasattr(data.sample, param): 
    1564             if param not in  batch_inputs.keys(): 
     1563            if param not in  batch_inputs: 
    15651564                batch_inputs[param] = [] 
    15661565            batch_inputs[param].append(data.sample.temperature) 
    … …  
    16331632                    wx.PostEvent(self.parent, evt) 
    16341633 
    1635         except Exception: 
    1636             msg = ("Fit completed but the following error occurred: %s" 
    1637                    % sys.exc_value) 
     1634        except Exception as exc: 
     1635            msg = "Fit completed but the following error occurred: %s" % exc 
    16381636            #msg = "\n".join((traceback.format_exc(), msg)) 
    16391637            evt = StatusEvent(status=msg, info="warning", type="stop") 
    … …  
    17231721        if model is None: 
    17241722            return 
    1725         if uid not in self.page_finder.keys(): 
     1723        if uid not in self.page_finder: 
    17261724            return 
    17271725        # save the name containing the data name with the appropriate model 
    … …  
    20802078                                  source=source) 
    20812079            self.calc_1D.queue() 
    2082         except: 
     2080        except Exception as exc: 
    20832081            msg = " Error occurred when drawing %s Model 1D: " % model.name 
    2084             msg += " %s" % sys.exc_value 
     2082            msg += " %s" % exc 
    20852083            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    20862084 

  • src/sas/sasgui/perspectives/fitting/model_thread.py

    r69363c7 r5251ec6  
    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/resultpanel.py

    r959eb01 r5251ec6  
    5959    def on_plot_results(self, event): 
    6060        self.frame.Show(True) 
    61         result = event.result[0][0] 
     61        result = list(event.result[0])[0] 
    6262        filename = result.data.sas_data.filename 
    6363        current_time = datetime.datetime.now().strftime("%I:%M%p, %B %d, %Y") 

  • src/sas/sasgui/perspectives/fitting/simfitpage.py

    r20fa5fe r5251ec6  
    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') 
    … …  
    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 
    … …  
    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

    r5a405bd r5251ec6  
    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

    r7432acb r5251ec6  
    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 
    … …  
    144144        if data_list is None: 
    145145            data_list = [] 
     146        else: 
     147            data_list = list(data_list)  # force iterator to list 
    146148        if len(data_list) >= 1: 
    147149            if len(data_list) == 1: 
    … …  
    190192                try: 
    191193                    self.compute_helper(data) 
    192                 except: 
    193                     msg = "Invariant Set_data: " + str(sys.exc_value) 
     194                except Exception as exc: 
     195                    msg = "Invariant Set_data: " + str(exc) 
    194196                    wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    195197        else: 
    … …  
    240242            msg = "invariant.save_file: the data being saved is" 
    241243            msg += " not a sas.sascalc.dataloader.data_info.Data1D object" 
    242             raise RuntimeError, msg 
     244            raise RuntimeError(msg) 
    243245 
    244246    def set_state(self, state=None, datainfo=None): 
    … …  
    258260                msg = "invariant.set_state: datainfo parameter cannot" 
    259261                msg += " be None in standalone mode" 
    260                 raise RuntimeError, msg 
     262                raise RuntimeError(msg) 
    261263            # Make sure the user sees the invariant panel after loading 
    262264            # self.parent.set_perspective(self.perspective) 
    … …  
    281283            self.on_set_state_helper(None) 
    282284 
    283         except: 
    284             logger.error("invariant.set_state: %s" % sys.exc_value) 
     285        except Exception as exc: 
     286            logger.error("invariant.set_state: %s" % exc) 
    285287 
    286288    def on_set_state_helper(self, event=None): 
    … …  
    320322        else: 
    321323            msg = "Scale can not be zero." 
    322             raise ValueError, msg 
     324            raise ValueError(msg) 
    323325        if len(new_plot.x) == 0: 
    324326            return 

  • src/sas/sasgui/perspectives/invariant/invariant_details.py

    r20fa5fe r5251ec6  
    22    Invariant panel 
    33""" 
     4import sys 
     5 
    46import wx 
    5 import sys 
    67 
    78from sas.sasgui.guiframe.utils import format_number 
    8 from invariant_widgets import OutputTextCtrl 
     9from .invariant_widgets import OutputTextCtrl 
     10 
    911# Dimensions related to chart 
    1012RECTANGLE_WIDTH = 400.0 
    … …  
    3335 
    3436 
    35 class InvariantContainer(wx.Object): 
     37class InvariantContainer: 
    3638    """ 
    3739    This class stores some values resulting resulting from invariant 

  • src/sas/sasgui/perspectives/invariant/invariant_panel.py

    r44e8f48 r5251ec6  
    319319        background = self.background_tcl.GetValue().lstrip().rstrip() 
    320320        if background == "": 
    321             raise ValueError, "Need a background" 
     321            raise ValueError("Need a background") 
    322322        if check_float(self.background_tcl): 
    323323            return float(background) 
    324324        else: 
    325325            msg = "Receive invalid value for background : %s" % (background) 
    326             raise ValueError, msg 
     326            raise ValueError(msg) 
    327327 
    328328    def get_scale(self): 
    … …  
    332332        scale = self.scale_tcl.GetValue().lstrip().rstrip() 
    333333        if scale == "": 
    334             raise ValueError, "Need a background" 
     334            raise ValueError("Need a background") 
    335335        if check_float(self.scale_tcl): 
    336336            if float(scale) <= 0.0: 
    … …  
    338338                self.scale_tcl.Refresh() 
    339339                msg = "Receive invalid value for scale: %s" % (scale) 
    340                 raise ValueError, msg 
     340                raise ValueError(msg) 
    341341            return float(scale) 
    342342        else: 
    343             raise ValueError, "Receive invalid value for scale : %s" % (scale) 
     343            raise ValueError("Receive invalid value for scale : %s" % (scale)) 
    344344 
    345345    def get_contrast(self): 
    … …  
    386386                self.volume_tcl.SetValue(format_number(v)) 
    387387                self.volume_err_tcl.SetValue(format_number(dv)) 
    388             except: 
     388            except Exception as exc: 
    389389                self.volume_tcl.SetValue(format_number(None)) 
    390390                self.volume_err_tcl.SetValue(format_number(None)) 
    391391                msg = "Error occurred computing volume " 
    392                 msg += " fraction: %s" % sys.exc_value 
     392                msg += " fraction: %s" % exc 
    393393                wx.PostEvent(self.parent, StatusEvent(status=msg, 
    394394                                                      info="error", 
    … …  
    406406                self.surface_tcl.SetValue(format_number(s)) 
    407407                self.surface_err_tcl.SetValue(format_number(ds)) 
    408             except: 
     408            except Exception as exc: 
    409409                self.surface_tcl.SetValue(format_number(None)) 
    410410                self.surface_err_tcl.SetValue(format_number(None)) 
    411411                msg = "Error occurred computing " 
    412                 msg += "specific surface: %s" % sys.exc_value 
     412                msg += "specific surface: %s" % exc 
    413413                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
    414414                                                      type="stop")) 
    … …  
    426426            self.inv_container.qstar_total = qstar_total 
    427427            self.inv_container.qstar_total_err = qstar_total_err 
    428         except: 
     428        except Exception as exc: 
    429429            self.inv_container.qstar_total = "Error" 
    430430            self.inv_container.qstar_total_err = "Error" 
    … …  
    432432            self.invariant_total_err_tcl.SetValue(format_number(None)) 
    433433            msg = "Error occurred computing invariant using" 
    434             msg += " extrapolation: %s" % sys.exc_value 
     434            msg += " extrapolation: %s" % exc 
    435435            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    436436 
    … …  
    450450                self._manager.plot_theory(data=extrapolated_data, 
    451451                                          name="Low-Q extrapolation") 
    452             except: 
     452            except Exception as exc: 
    453453                self.inv_container.qstar_low = "ERROR" 
    454454                self.inv_container.qstar_low_err = "ERROR" 
    455455                self._manager.plot_theory(name="Low-Q extrapolation") 
    456456                msg = "Error occurred computing low-Q " 
    457                 msg += "invariant: %s" % sys.exc_value 
     457                msg += "invariant: %s" % exc 
    458458                wx.PostEvent(self.parent, 
    459459                             StatusEvent(status=msg, type="stop")) 
    … …  
    462462            try: 
    463463                self._manager.plot_theory(name="Low-Q extrapolation") 
    464             except: 
    465                 logger.error(sys.exc_value) 
     464            except Exception as exc: 
     465                logger.error(exc) 
    466466 
    467467    def get_high_qstar(self, inv, high_q=False): 
    … …  
    483483                self._manager.plot_theory(data=high_out_data, 
    484484                                          name="High-Q extrapolation") 
    485             except: 
     485            except Exception as exc: 
    486486                #raise 
    487487                self.inv_container.qstar_high = "ERROR" 
    … …  
    489489                self._manager.plot_theory(name="High-Q extrapolation") 
    490490                msg = "Error occurred computing high-Q " 
    491                 msg += "invariant: %s" % sys.exc_value 
     491                msg += "invariant: %s" % exc 
    492492                wx.PostEvent(self.parent, StatusEvent(status=msg, 
    493493                                                      type="stop")) 
    … …  
    496496            try: 
    497497                self._manager.plot_theory(name="High-Q extrapolation") 
    498             except: 
    499                 logger.error(sys.exc_value) 
     498            except Exception as exc: 
     499                logger.error(exc) 
    500500 
    501501    def get_qstar(self, inv): 
    … …  
    625625            background = self.get_background() 
    626626            scale = self.get_scale() 
    627         except: 
    628             msg = "Invariant Error: %s" % (sys.exc_value) 
     627        except Exception as exc: 
     628            msg = "Invariant Error: %s" % exc 
    629629            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    630630            return 
    … …  
    641641            inv, npts_low = self.set_extrapolation_low(inv=inv, low_q=low_q) 
    642642            inv, npts_high = self.set_extrapolation_high(inv=inv, high_q=high_q) 
    643         except: 
    644             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     643        except Exception as exc: 
     644            msg = "Error occurred computing invariant: %s" % exc 
    645645            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    646646                                                  info="warning", type="stop")) 
    … …  
    652652        try: 
    653653            self.get_qstar(inv=inv) 
    654         except: 
    655             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     654        except Exception as exc: 
     655            msg = "Error occurred computing invariant: %s" % exc 
    656656            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    657657                                                  info="warning", 
    … …  
    674674            porod_const = self.get_porod_const() 
    675675            contrast = self.get_contrast() 
    676         except: 
    677             msg = r_msg + "Error occurred computing invariant: %s" % \ 
    678                                                             sys.exc_value 
     676        except Exception as exc: 
     677            msg = r_msg + "Error occurred computing invariant: %s" % exc 
    679678            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    680679                                                  info="error", 
    … …  
    685684                            extrapolation=extrapolation) 
    686685            #compute surface and set value to txtcrtl 
    687         except: 
    688             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     686        except Exception as exc: 
     687            msg = "Error occurred computing invariant: %s" % exc 
    689688            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    690689                                                  info="warning", 
    … …  
    695694                             extrapolation=extrapolation) 
    696695 
    697         except: 
    698             msg = "Error occurred computing invariant: %s" % sys.exc_value 
     696        except Exception as exc: 
     697            msg = "Error occurred computing invariant: %s" % exc 
    699698            wx.PostEvent(self.parent, StatusEvent(status=msg, 
    700699                                                  info="warning", 
    … …  
    845844            if attr.__class__.__name__ == "StaticText": 
    846845                return 
    847             if value in ["True", "False", True, False]: 
    848                 value = bool(value) 
     846            if value in ["True", True]: 
     847                value = 1 
     848            elif value in ["False", False]: 
     849                value = 0 
    849850            else: 
    850851                value = str(value) 
    851852            attr.SetValue(value) 
    852         except: 
    853             logger.error("Invariant state: %s", sys.exc_value) 
     853        except Exception as exc: 
     854            logger.error("Invariant state: %s", exc) 
    854855 
    855856    def get_bookmark_by_num(self, num=None): 
    … …  
    867868        try: 
    868869            _, _, current_state, comp_state = self.state.bookmark_list[int(num)] 
    869         except: 
    870             logger.error(sys.exc_value) 
    871             raise ValueError, "No such bookmark exists" 
     870        except Exception as exc: 
     871            logger.error(exc) 
     872            raise ValueError("No such bookmark exists") 
    872873 
    873874        # set the parameters 
    … …  
    962963            self.state.state_list[str(self.state.state_num)] = \ 
    963964                    self.state.clone_state() 
    964         except: 
    965             logger.error(sys.exc_value) 
     965        except Exception as exc: 
     966            logger.error(exc) 
    966967 
    967968        self._set_undo_flag(True) 
    … …  
    10061007            try: 
    10071008                del self.state.state_list[str(i)] 
    1008             except: 
    1009                 logger.error(sys.exc_value) 
     1009            except Exception as exc: 
     1010                logger.error(exc) 
    10101011        # Enable the undo button if it was not 
    10111012        self._set_undo_flag(True) 
    … …  
    10711072            try: 
    10721073                del self.state.state_list[str(i)] 
    1073             except: 
    1074                 logger.error(sys.exc_value) 
     1074            except Exception as exc: 
     1075                logger.error(exc) 
    10751076 
    10761077        # try to add new state of the text changes in the state_list 
    … …  
    10861087            self.state.state_num = self.state.saved_state['state_num'] 
    10871088            self.state.state_list[str(self.state.state_num)] = self.state.clone_state() 
    1088         except: 
    1089             logger.error(sys.exc_value) 
     1089        except Exception as exc: 
     1090            logger.error(exc) 
    10901091 
    10911092        self._set_undo_flag(True) 
    … …  
    11081109            self.state.saved_state[name] = str(value) 
    11091110            self.state.state_list[str(self.state.state_num)] = self.state.clone_state() 
    1110         except: 
    1111             logger.error(sys.exc_value) 
     1111        except Exception as exc: 
     1112            logger.error(exc) 
    11121113 
    11131114    def _get_input_list(self): 
    … …  
    11181119        compute_num = self.state.saved_state['compute_num'] 
    11191120        # find values and put into the input list 
    1120         for key1, value1 in self.state.state_list[str(compute_num)].iteritems(): 
    1121             for key, _ in self.state.input_list.iteritems(): 
     1121        for key1, value1 in self.state.state_list[str(compute_num)].items(): 
     1122            for key, _ in self.state.input_list.items(): 
    11221123                if key == key1: 
    11231124                    self.state.input_list[key] = value1 

  • src/sas/sasgui/perspectives/invariant/invariant_state.py

    re9920cd r5251ec6  
    22    State class for the invariant UI 
    33""" 
     4from __future__ import print_function 
    45 
    56# import time 
    … …  
    140141 
    141142        # text ctl general inputs ( excluding extrapolation text ctl) 
    142         for key, value in self.input_list.iteritems(): 
     143        for key, value in self.input_list.items(): 
    143144            if value == '': 
    144145                continue 
    … …  
    166167        low_off = False 
    167168        high_off = False 
    168         for key, value in self.input_list.iteritems(): 
     169        for key, value in self.input_list.items(): 
    169170            key_split = key.split('_') 
    170171            max_ind = len(key_split) - 1 
    … …  
    216217                # other outputs than Q* 
    217218                name = item[0] + "_tcl" 
    218                 if name in self.saved_state.keys(): 
     219                if name in self.saved_state: 
    219220                    value = self.saved_state[name] 
    220221 
    … …  
    301302        top_element.appendChild(state) 
    302303 
    303         for name, value in self.saved_state.iteritems(): 
     304        for name, value in self.saved_state.items(): 
    304305            element = newdoc.createElement(str(name)) 
    305306            element.appendChild(newdoc.createTextNode(str(value))) 
    … …  
    310311        top_element.appendChild(history) 
    311312 
    312         for name, value in self.state_list.iteritems(): 
     313        for name, value in self.state_list.items(): 
    313314            history_element = newdoc.createElement('state_' + str(name)) 
    314             for state_name, state_value in value.iteritems(): 
     315            for state_name, state_value in value.items(): 
    315316                state_element = newdoc.createElement(str(state_name)) 
    316317                child = newdoc.createTextNode(str(state_value)) 
    … …  
    325326        top_element.appendChild(bookmark) 
    326327        item_list = ['time', 'date', 'state', 'comp_state'] 
    327         for name, value_list in self.bookmark_list.iteritems(): 
     328        for name, value_list in self.bookmark_list.items(): 
    328329            element = newdoc.createElement('mark_' + str(name)) 
    329330            _, date, state, comp_state = value_list 
    … …  
    334335            state_list_element = newdoc.createElement('state') 
    335336            comp_state_list_element = newdoc.createElement('comp_state') 
    336             for state_name, state_value in value_list[2].iteritems(): 
     337            for state_name, state_value in value_list[2].items(): 
    337338                state_element = newdoc.createElement(str(state_name)) 
    338339                child = newdoc.createTextNode(str(state_value)) 
    339340                state_element.appendChild(child) 
    340341                state_list_element.appendChild(state_element) 
    341             for comp_name, comp_value in value_list[3].iteritems(): 
     342            for comp_name, comp_value in value_list[3].items(): 
    342343                comp_element = newdoc.createElement(str(comp_name)) 
    343344                comp_element.appendChild(newdoc.createTextNode(str(comp_value))) 
    … …  
    368369            msg = "InvariantSate no longer supports non-CanSAS" 
    369370            msg += " format for invariant files" 
    370             raise RuntimeError, msg 
     371            raise RuntimeError(msg) 
    371372 
    372373        if node.get('version')\ 
    … …  
    383384                try: 
    384385                    timestamp = (entry.get('epoch')) 
    385                 except: 
     386                except Exception as exc: 
    386387                    msg = "InvariantSate.fromXML: Could not read" 
    387                     msg += " timestamp\n %s" % sys.exc_value 
     388                    msg += " timestamp\n %s" % exc 
    388389                    logger.error(msg) 
    389390 
    … …  
    453454        Get the values (strings) from __str__ for report 
    454455        """ 
    455         strings = self.__str__() 
    456  
    457456        # default string values 
    458         for num in range(1, 19): 
    459             exec "s_%s = 'NA'" % str(num) 
    460         lines = strings.split('\n') 
     457        s = {num: 'NA' for num in range(1, 19)} 
    461458        # get all string values from __str__() 
    462         for line in range(0, len(lines)): 
    463             if line == 1: 
    464                 s_1 = lines[1] 
    465             elif line == 2: 
    466                 s_2 = lines[2] 
     459        lines = str(self).split('\n') 
     460        for line_num, line in enumerate(lines): 
     461            if line_num == 1: 
     462                s[1] = line 
     463            elif line_num == 2: 
     464                s[2] = line 
    467465            else: 
    468                 item = lines[line].split(':') 
     466                item = line.split(':') 
    469467                item[0] = item[0].strip() 
    470468                if item[0] == "scale": 
    471                     s_3 = item[1] 
     469                    s[3] = item[1] 
    472470                elif item[0] == "porod constant": 
    473                     s_4 = item[1] 
     471                    s[4] = item[1] 
    474472                elif item[0] == "background": 
    475                     s_5 = item[1] 
     473                    s[5] = item[1] 
    476474                elif item[0] == "contrast": 
    477                     s_6 = item[1] 
     475                    s[6] = item[1] 
    478476                elif item[0] == "Extrapolation": 
    479477                    extra = item[1].split(";") 
    480478                    bool_0 = extra[0].split("=") 
    481479                    bool_1 = extra[1].split("=") 
    482                     s_8 = " " + bool_0[0] + "Q region = " + bool_0[1] 
    483                     s_7 = " " + bool_1[0] + "Q region = " + bool_1[1] 
     480                    s[8] = " " + bool_0[0] + "Q region = " + bool_0[1] 
     481                    s[7] = " " + bool_1[0] + "Q region = " + bool_1[1] 
    484482                elif item[0] == "npts low": 
    485                     s_9 = item[1] 
     483                    s[9] = item[1] 
    486484                elif item[0] == "npts high": 
    487                     s_10 = item[1] 
     485                    s[10] = item[1] 
    488486                elif item[0] == "volume fraction": 
    489487                    val = item[1].split("+-")[0].strip() 
    490488                    error = item[1].split("+-")[1].strip() 
    491                     s_17 = val + " &plusmn; " + error 
     489                    s[17] = val + " &plusmn; " + error 
    492490                elif item[0] == "specific surface": 
    493491                    val = item[1].split("+-")[0].strip() 
    494492                    error = item[1].split("+-")[1].strip() 
    495                     s_18 = val + " &plusmn; " + error 
     493                    s[18] = val + " &plusmn; " + error 
    496494                elif item[0].split("(")[0].strip() == "power low": 
    497                     s_11 = item[0] + " =" + item[1] 
     495                    s[11] = item[0] + " =" + item[1] 
    498496                elif item[0].split("(")[0].strip() == "power high": 
    499                     s_12 = item[0] + " =" + item[1] 
     497                    s[12] = item[0] + " =" + item[1] 
    500498                elif item[0].split("[")[0].strip() == "Q* from low Q extrapolation": 
    501499                    # looks messy but this way the symbols +_ and % work on html 
    … …  
    504502                    err = error.split("%")[0].strip() 
    505503                    percent = error.split("%")[1].strip() 
    506                     s_13 = val + " &plusmn; " + err + "&#37" + percent 
     504                    s[13] = val + " &plusmn; " + err + "&#37" + percent 
    507505                elif item[0].split("[")[0].strip() == "Q* from data": 
    508506                    val = item[1].split("+-")[0].strip() 
    … …  
    510508                    err = error.split("%")[0].strip() 
    511509                    percent = error.split("%")[1].strip() 
    512                     s_14 = val + " &plusmn; " + err + "&#37" + percent 
     510                    s[14] = val + " &plusmn; " + err + "&#37" + percent 
    513511                elif item[0].split("[")[0].strip() == "Q* from high Q extrapolation": 
    514512                    val = item[1].split("+-")[0].strip() 
    … …  
    516514                    err = error.split("%")[0].strip() 
    517515                    percent = error.split("%")[1].strip() 
    518                     s_15 = val + " &plusmn; " + err + "&#37" + percent 
     516                    s[15] = val + " &plusmn; " + err + "&#37" + percent 
    519517                elif item[0].split("[")[0].strip() == "total Q*": 
    520518                    val = item[1].split("+-")[0].strip() 
    521519                    error = item[1].split("+-")[1].strip() 
    522                     s_16 = val + " &plusmn; " + error 
     520                    s[16] = val + " &plusmn; " + error 
    523521                else: 
    524522                    continue 
    525523 
    526         s_1 = self._check_html_format(s_1) 
     524        s[1] = self._check_html_format(s[1]) 
    527525        file_name = self._check_html_format(self.file) 
    528526 
    … …  
    530528        self.set_plot_state(extra_high=bool_0[1], extra_low=bool_1[1]) 
    531529        # get ready for report with setting all the html strings 
    532         self.report_str = str(self.template_str) % (s_1, s_2, 
    533                                                     s_3, s_4, s_5, s_6, s_7, s_8, 
    534                                                     s_9, s_10, s_11, s_12, s_13, s_14, s_15, 
    535                                                     s_16, s_17, s_18, file_name, "%s") 
     530        self.report_str = str(self.template_str) % ( 
     531            s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11], 
     532            s[12], s[13], s[14], s[15], s[16], s[17], s[18], file_name, "%s") 
    536533 
    537534    def _check_html_format(self, name): 
    … …  
    692689                state = InvariantState() 
    693690                state.fromXML(node=nodes[0]) 
    694         except: 
     691        except Exception as exc: 
    695692            msg = "XML document does not contain invariant" 
    696             msg += " information.\n %s" % sys.exc_value 
     693            msg += " information.\n %s" % exc 
    697694            logger.info(msg) 
    698695        return state 
    … …  
    736733                        output.append(sas_entry) 
    737734        else: 
    738             raise RuntimeError, "%s is not a file" % path 
     735            raise RuntimeError("%s is not a file" % path) 
    739736 
    740737        # Return output consistent with the loader's api 
    … …  
    782779            msg = "The cansas writer expects a Data1D" 
    783780            msg += " instance: %s" % str(datainfo.__class__.__name__) 
    784             raise RuntimeError, msg 
     781            raise RuntimeError(msg) 
    785782        # make sure title and data run is filled up. 
    786783        if datainfo.title is None or datainfo.title == '': 

  • src/sas/sasgui/perspectives/invariant/report_dialog.py

    rd0ce666f r5251ec6  
    9292                        # Mac 
    9393                        os.system("open %s" % fName) 
    94                     except: 
     94                    except Exception as exc: 
    9595                        # DO not open 
    96                         logger.error("Could not open file: %s" % sys.exc_value) 
     96                        logger.error("Could not open file: %s" % exc) 
    9797            # delete image file 
    9898            os.remove(pic_fname) 

  • src/sas/sasgui/perspectives/pr/__init__.py

    r959eb01 r5251ec6  
    11PLUGIN_ID = "P(r) plug-in 1.0" 
    2 from pr import * 
     2from .pr import * 

  • src/sas/sasgui/perspectives/pr/explore_dialog.py

    r20fa5fe r5251ec6  
    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 
    … …  
    416416                results.pos_err.append(pos_err) 
    417417                results.osc.append(osc) 
    418             except: 
     418            except Exception as exc: 
    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), exc) 
    422422                logger.error(msg) 
    423423 

  • src/sas/sasgui/perspectives/pr/inversion_panel.py

    rcb62bd5 r5251ec6  
    55__revision__ = "$Revision: 1193 $" 
    66 
    7 import wx 
    87import os 
    98import sys 
    109import logging 
     10 
     11import wx 
    1112from wx.lib.scrolledpanel import ScrolledPanel 
     13 
    1214from sas.sasgui.guiframe.events import StatusEvent 
    1315from 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 
    1816from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     17 
     18from .inversion_state import InversionState 
     19from .pr_widgets import PrTextCtrl 
     20from .pr_widgets import DataFileTextCtrl 
     21from .pr_widgets import OutputTextCtrl 
    1922 
    2023logger = logging.getLogger(__name__) 
    … …  
    752755        except ValueError: 
    753756            logger.error("InversionControl._on_accept_alpha got a value that was not a number: %s" % alpha ) 
    754         except: 
     757        except Exception as exc: 
    755758            # No estimate or bad estimate, either do nothing 
    756             logger.error("InversionControl._on_accept_alpha: %s" % sys.exc_value) 
     759            logger.error("InversionControl._on_accept_alpha: %s" % exc) 
    757760 
    758761    def _on_accept_nterms(self, evt): 
    … …  
    768771        except ValueError: 
    769772            logger.error("InversionControl._on_accept_nterms got a value that was not a number: %s" % nterms ) 
    770         except: 
     773        except Exception as exc: 
    771774            # No estimate or bad estimate, either do nothing 
    772             logger.error("InversionControl._on_accept_nterms: %s" % sys.exc_value) 
     775            logger.error("InversionControl._on_accept_nterms: %s" % exc) 
    773776 
    774777    def clear_panel(self): 
    … …  
    901904                message += "than the number of points" 
    902905                wx.PostEvent(self._manager.parent, StatusEvent(status=message)) 
    903                 raise ValueError, message 
     906                raise ValueError(message) 
    904907            self.nfunc_ctl.SetBackgroundColour(wx.WHITE) 
    905908            self.nfunc_ctl.Refresh() 
    … …  
    957960        Invoke the d_max exploration dialog 
    958961        """ 
    959         from explore_dialog import ExploreDialog 
     962        from .explore_dialog import ExploreDialog 
    960963        if self._manager._last_pr is not None: 
    961964            pr = self._manager._create_plot_pr() 
    … …  
    10081011                self._on_invert(None) 
    10091012                self._set_analysis(True) 
    1010             except: 
    1011                 msg = "InversionControl._change_file: %s" % sys.exc_value 
     1013            except Exception as exc: 
     1014                msg = "InversionControl._change_file: %s" % exc 
    10121015                logger.error(msg) 
    10131016 

  • src/sas/sasgui/perspectives/pr/inversion_state.py

    r2469df7 r5251ec6  
    1818import logging 
    1919from lxml import etree 
     20 
    2021from sas.sasgui.guiframe.dataFitting import Data1D 
    2122from sas.sascalc.dataloader.readers.cansas_reader import Reader as CansasReader 
    … …  
    238239            msg = "InversionState no longer supports non-CanSAS" 
    239240            msg += " format for P(r) files" 
    240             raise RuntimeError, msg 
     241            raise RuntimeError(msg) 
    241242 
    242243        if node.get('version') and node.get('version') == '1.0': 
    … …  
    252253                try: 
    253254                    self.timestamp = float(entry.get('epoch')) 
    254                 except: 
     255                except Exception as exc: 
    255256                    msg = "InversionState.fromXML: Could not read " 
    256                     msg += "timestamp\n %s" % sys.exc_value 
     257                    msg += "timestamp\n %s" % exc 
    257258                    logger.error(msg) 
    258259 
    … …  
    432433                state = InversionState() 
    433434                state.fromXML(node=nodes[0]) 
    434         except: 
     435        except Exception as exc: 
    435436            msg = "XML document does not contain P(r) " 
    436             msg += "information.\n %s" % sys.exc_value 
     437            msg += "information.\n %s" % exc 
    437438            logger.info(msg) 
    438439 
    … …  
    481482                        output.append(sas_entry) 
    482483        else: 
    483             raise RuntimeError, "%s is not a file" % path 
     484            raise RuntimeError("%s is not a file" % path) 
    484485 
    485486        # Return output consistent with the loader's api 
    … …  
    525526            msg = "The cansas writer expects a Data1D " 
    526527            msg += "instance: %s" % str(datainfo.__class__.__name__) 
    527             raise RuntimeError, msg 
     528            raise RuntimeError(msg) 
    528529 
    529530        # Create basic XML document 

  • src/sas/sasgui/perspectives/pr/pr.py

    r2469df7 r5251ec6  
    1818 
    1919import sys 
    20 import wx 
    2120import logging 
    2221import time 
    2322import math 
     23 
     24import wx 
    2425import numpy as np 
    2526import pylab 
     27 
    2628from sas.sasgui.guiframe.gui_manager import MDIFrame 
    2729from sas.sasgui.guiframe.dataFitting import Data1D 
    … …  
    3335import sas.sascalc.dataloader 
    3436 
    35 from pr_widgets import load_error 
    3637from sas.sasgui.guiframe.plugin_base import PluginBase 
     38 
     39from .inversion_state import Reader  # .prv file reader 
     40from .inversion_panel import InversionControl 
     41#from .inversion_panel import HelpDialog 
     42from .inversion_panel import PrDistDialog 
     43from .pr_thread import CalcPr 
     44from .pr_thread import EstimatePr 
     45from .pr_thread import EstimateNT 
     46from .pr_widgets import load_error 
     47from .pr_widgets import DataDialog 
    3748 
    3849logger = logging.getLogger(__name__) 
    … …  
    106117        self.list_plot_id = [] 
    107118 
    108         # Associate the inversion state reader with .prv files 
    109         from inversion_state import Reader 
    110  
    111119        # Create a CanSAS/Pr reader 
    112120        self.state_reader = Reader(self.set_state) 
    … …  
    151159                msg = "Pr.set_state: datainfo parameter cannot " 
    152160                msg += "be None in standalone mode" 
    153                 raise RuntimeError, msg 
     161                raise RuntimeError(msg) 
    154162 
    155163            # Ensuring that plots are coordinated correctly 
    … …  
    184192                                                   title=self.current_plottable.title)) 
    185193            self.control_panel.set_state(state) 
    186         except: 
    187             logger.error("prview.set_state: %s" % sys.exc_value) 
     194        except Exception as exc: 
     195            logger.error("prview.set_state: %s" % exc) 
    188196 
    189197 
    … …  
    195203 
    196204        """ 
    197         from inversion_panel import HelpDialog 
    198205        dialog = HelpDialog(None, -1) 
    199206        if dialog.ShowModal() == wx.ID_OK: 
    … …  
    369376        Redisplay P(r) with a different number of points 
    370377        """ 
    371         from inversion_panel import PrDistDialog 
    372378        dialog = PrDistDialog(None, -1) 
    373379        dialog.set_content(self._pr_npts) 
    … …  
    452458        # Notify the user if we could not read the file 
    453459        if dataread is None: 
    454             raise RuntimeError, "Invalid data" 
     460            raise RuntimeError("Invalid data") 
    455461 
    456462        x = None 
    … …  
    472478                if dataread is None: 
    473479                    return x, y, err 
    474                 raise RuntimeError, "This tool can only read 1D data" 
     480                raise RuntimeError("This tool can only read 1D data") 
    475481 
    476482        self._current_file_data.x = x 
    … …  
    511517                    data_y = np.append(data_y, y) 
    512518                    data_err = np.append(data_err, err) 
    513                 except: 
    514                     logger.error(sys.exc_value) 
     519                except Exception as exc: 
     520                    logger.error(exc) 
    515521 
    516522        if scale is not None: 
    … …  
    562568                        data_y = np.append(data_y, y) 
    563569                        data_err = np.append(data_err, err) 
    564                     except: 
    565                         logger.error(sys.exc_value) 
     570                    except Exception as exc: 
     571                        logger.error(exc) 
    566572                elif line.find("The 6 columns") >= 0: 
    567573                    data_started = True 
    … …  
    720726            Start a calculation thread 
    721727        """ 
    722         from pr_thread import CalcPr 
    723  
    724728        # If a thread is already started, stop it 
    725729        if self.calc_thread is not None and self.calc_thread.isrunning(): 
    … …  
    849853            try: 
    850854                pr = self._create_file_pr(data) 
    851             except: 
    852                 status = "Problem reading data: %s" % sys.exc_value 
     855            except Exception as exc: 
     856                status = "Problem reading data: %s" % exc 
    853857                wx.PostEvent(self.parent, StatusEvent(status=status)) 
    854                 raise RuntimeError, status 
     858                raise RuntimeError(status) 
    855859 
    856860            # If the file contains nothing, just return 
    857861            if pr is None: 
    858                 raise RuntimeError, "Loaded data is invalid" 
     862                raise RuntimeError("Loaded data is invalid") 
    859863 
    860864            self.pr = pr 
    … …  
    906910            msg = "pr.save_data: the data being saved is not a" 
    907911            msg += " sas.data_info.Data1D object" 
    908             raise RuntimeError, msg 
     912            raise RuntimeError(msg) 
    909913 
    910914    def setup_plot_inversion(self, alpha, nfunc, d_max, q_min=None, q_max=None, 
    … …  
    928932                self.pr = pr 
    929933                self.perform_inversion() 
    930         except: 
    931             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     934        except Exception as exc: 
     935            wx.PostEvent(self.parent, StatusEvent(status=exc)) 
    932936 
    933937    def estimate_plot_inversion(self, alpha, nfunc, d_max, 
    … …  
    952956                self.pr = pr 
    953957                self.perform_estimate() 
    954         except: 
    955             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     958        except Exception as exc: 
     959            wx.PostEvent(self.parent, StatusEvent(status=exc)) 
    956960 
    957961    def _create_plot_pr(self, estimate=False): 
    … …  
    10331037                self.pr = pr 
    10341038                self.perform_inversion() 
    1035         except: 
    1036             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     1039        except Exception as exc: 
     1040            wx.PostEvent(self.parent, StatusEvent(status=exc)) 
    10371041 
    10381042    def estimate_file_inversion(self, alpha, nfunc, d_max, data, 
    … …  
    10561060                self.pr = pr 
    10571061                self.perform_estimate() 
    1058         except: 
    1059             wx.PostEvent(self.parent, StatusEvent(status=sys.exc_value)) 
     1062        except Exception as exc: 
     1063            wx.PostEvent(self.parent, StatusEvent(status=exc)) 
    10601064 
    10611065    def _create_file_pr(self, data): 
    … …  
    10851089            self._current_file_data.err = data.dy 
    10861090            x, y, err = data.x, data.y, data.dy 
    1087         except: 
    1088             load_error(sys.exc_value) 
     1091        except Exception as exc: 
     1092            load_error(exc) 
    10891093            return None 
    10901094 
    … …  
    11241128            pr.slit_width = self.slit_width 
    11251129            return pr 
    1126         except: 
    1127             load_error(sys.exc_value) 
     1130        except Exception as exc: 
     1131            load_error(exc) 
    11281132        return None 
    11291133 
    … …  
    11321136            Perform parameter estimation 
    11331137        """ 
    1134         from pr_thread import EstimatePr 
    1135  
    11361138        # If a thread is already started, stop it 
    11371139        if self.estimation_thread is not None and \ 
    … …  
    11621164            Perform parameter estimation 
    11631165        """ 
    1164         from pr_thread import EstimateNT 
    1165  
    11661166        # If a thread is already started, stop it 
    11671167        if self.estimation_thread is not None and self.estimation_thread.isrunning(): 
    … …  
    12391239            Create and return a list of panel objects 
    12401240        """ 
    1241         from inversion_panel import InversionControl 
    1242  
    12431241        self.parent = parent 
    12441242        self.frame = MDIFrame(self.parent, None, 'None', (100, 200)) 
    … …  
    12621260        if data_list is None: 
    12631261            data_list = [] 
     1262        else: 
     1263            data_list = list(data_list)  # force iterator to list 
    12641264        if len(data_list) >= 1: 
    12651265            if len(data_list) == 1: 
    … …  
    12871287                msg += "Please select one.\n" 
    12881288                if len(data_list) > 1: 
    1289                     from pr_widgets import DataDialog 
    12901289                    dlg = DataDialog(data_list=data_1d_list, text=msg) 
    12911290                    if dlg.ShowModal() == wx.ID_OK: 
    … …  
    13061305                    self.data_id = data.id 
    13071306                    self.control_panel._change_file(evt=None, data=data) 
    1308                 except: 
    1309                     msg = "Prview Set_data: " + str(sys.exc_value) 
     1307                except Exception as exc: 
     1308                    msg = "Prview Set_data: " + str(exc) 
    13101309                    wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    13111310            else: 

  • src/sas/sasgui/perspectives/pr/pr_thread.py

    rac07a3a r5251ec6  
    4141            # Thread was interrupted, just proceed 
    4242            pass 
    43         except: 
     43        except Exception as exc: 
    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" % exc) 
    4646 
    4747class EstimatePr(CalcThread): 
    … …  
    6969            # Thread was interrupted, just proceed 
    7070            pass 
    71         except: 
     71        except Exception as exc: 
    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" % exc) 
    7474 
    7575class EstimateNT(CalcThread): 
    … …  
    109109            # Thread was interrupted, just proceed 
    110110            pass 
    111         except: 
     111        except Exception as exc: 
    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" % exc) 

  • src/sas/sasgui/perspectives/simulation/ShapeAdapter.py

    r959eb01 r5251ec6  
    8787            self.sim_canvas._model_changed() 
    8888        else: 
    89             raise ValueError, "SimShapeVisitor: Wrong class for visited object" 
     89            raise ValueError("SimShapeVisitor: Wrong class for visited object") 
    9090         
    9191         
    … …  
    115115            self.sim_canvas._model_changed() 
    116116        else: 
    117             raise ValueError, "SimShapeVisitor: Wrong class for visited object" 
     117            raise ValueError("SimShapeVisitor: Wrong class for visited object") 
    118118         
    119119     
    … …  
    130130            shape.accept_update(self) 
    131131        else: 
    132             raise ValueError, "ShapeAdapter: Shape [%s] not in list" % shape.name 
     132            raise ValueError("ShapeAdapter: Shape [%s] not in list" % shape.name) 
    133133 

  • src/sas/sasgui/perspectives/simulation/ShapeParameters.py

    ra1b8fee r5251ec6  
    1010from __future__ import print_function 
    1111 
     12import sys 
     13from copy import deepcopy 
     14 
    1215import wx 
    13 import sys 
    1416import wx.lib.newevent 
    15 from copy import deepcopy 
    16 import SimCanvas 
     17 
     18from . import SimCanvas 
    1719 
    1820(CreateShapeEvent, EVT_ADD_SHAPE) = wx.lib.newevent.NewEvent() 
    … …  
    201203            n = 1 
    202204            self.parameters = [] 
    203             keys = shape.params.keys() 
    204             keys.sort() 
    205              
    206             for item in keys: 
     205             
     206            for item in sorted(shape.params.keys()): 
    207207                if item in ['contrast', 'order']: 
    208208                    continue 
    … …  
    393393                if not tmp==None: 
    394394                    self.current_shape.params[item[0]] = tmp  
    395         except: 
     395        except Exception as exc: 
    396396            print("Could not create") 
    397             print(sys.exc_value) 
     397            print(exc) 
    398398                 
    399399    def _onCreate(self, evt): 
    … …  
    489489            print("NOT YET IMPLMENTED") 
    490490            print("renaming", self.shape_listbox.GetString(indices[0])) 
    491                  

  • src/sas/sasgui/perspectives/simulation/__init__.py

    r959eb01 r5251ec6  
    11PLUGIN_ID = "Simulation plug-in 1.0" 
    2 from simulation import * 
     2from .simulation import * 

  • src/sas/sasgui/perspectives/simulation/simulation.py

    r7432acb r5251ec6  
    1515 
    1616# Application imports 
    17 import SimCanvas 
    18 import ShapeParameters 
    19 import ShapeAdapter 
     17from sas.sascalc.realspace import VolumeCanvas 
     18from sas.sascalc.data_util.calcthread import CalcThread 
    2019from sas.sasgui.guiframe.dataFitting import Data1D 
    21 # Real-space simulation import 
    22 import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    23  
    24 from sas.sascalc.data_util.calcthread import CalcThread 
    2520from sas.guicomm.events import NewPlotEvent, StatusEvent     
     21 
     22from . import SimCanvas 
     23from . import ShapeParameters 
     24from . import ShapeAdapter 
    2625 
    2726logger = logging.getLogger(__name__) 
Note: See TracChangeset for help on using the changeset viewer.