Changeset fa81e94 in sasview


Ignore:
Timestamp:
Nov 15, 2017 4:33:09 AM (5 years ago)
Author:
Piotr Rozyczko <rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
d4881f6a
Parents:
7c487846
Message:

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

Files:
9 added
66 edited

Legend:

Unmodified
Added
Removed
  • setup.py

    r7fb471d rfa81e94  
    380380    "src", "sas", "qtgui", "Perspectives", "Fitting", "UI") 
    381381packages.extend(["sas.qtgui.Perspectives.Fitting", "sas.qtgui.Perspectives.Fitting.UI"]) 
     382 
     383package_dir["sas.qtgui.Perspectives.Inversion"] = os.path.join( 
     384    "src", "sas", "qtgui", "Perspectives", "Inversion") 
     385package_dir["sas.qtgui.Perspectives.Inversion.UI"] = os.path.join( 
     386    "src", "sas", "qtgui", "Perspectives", "Inversion", "UI") 
     387packages.extend(["sas.qtgui.Perspectives.Inversion", "sas.qtgui.Perspectives.Inversion.UI"]) 
    382388 
    383389## Plotting 
  • src/sas/qtgui/Perspectives/__init__.py

    rb3e8629 rfa81e94  
    44from .Fitting.FittingPerspective import FittingWindow 
    55from .Invariant.InvariantPerspective import InvariantWindow 
     6from .Inversion.InversionPerspective import InversionWindow 
    67 
    78PERSPECTIVES = { 
    89    FittingWindow.name: FittingWindow, 
    910    InvariantWindow.name: InvariantWindow, 
     11    InversionWindow.name: InversionWindow 
    1012} 
  • src/sas/sascalc/fit/models.py

    rb963b20 rfa81e94  
    139139        if type is not None and issubclass(type, py_compile.PyCompileError): 
    140140            print("Problem with", repr(value)) 
    141             raise type, value, tb 
     141            raise (type, value, tb) 
    142142        return 1 
    143143 
  • src/sas/sasgui/guiframe/data_processor.py

    ra1b8fee rfa81e94  
    909909                    msg = "Edit axis doesn't understand this selection.\n" 
    910910                    msg += "Please select only one column" 
    911                     raise ValueError, msg 
     911                    raise (ValueError, msg) 
    912912            for (_, cell_col) in grid.selected_cells: 
    913913                if cell_col != col: 
     
    915915                    msg += "this operation.\n" 
    916916                    msg += "Please select elements of the same col.\n" 
    917                     raise ValueError, msg 
     917                    raise (ValueError, msg) 
    918918 
    919919            # Finally check the highlighted cell if any cells missing 
     
    922922            msg = "No item selected.\n" 
    923923            msg += "Please select only one column or one cell" 
    924             raise ValueError, msg 
     924            raise (ValueError, msg) 
    925925        return grid.selected_cells 
    926926 
     
    13261326            if sentence.strip() == "": 
    13271327                msg = "Select column values for x axis" 
    1328                 raise ValueError, msg 
     1328                raise (ValueError, msg) 
    13291329        except: 
    13301330            msg = "X axis value error." 
     
    13451345            if sentence.strip() == "": 
    13461346                msg = "select value for y axis" 
    1347                 raise ValueError, msg 
     1347                raise (ValueError, msg) 
    13481348        except: 
    13491349            msg = "Y axis value error." 
     
    16311631 
    16321632        # We need to grab a WxMenu handle here, otherwise the next one to grab 
    1633         # the handle will be treated as the Edit Menu handle when checking in 
     1633        # the handle will be treated as the Edi)t Menu handle when checking in 
    16341634        # on_menu_open event handler and thus raise an exception when it hits an  
    16351635        # unitialized object.  Alternative is to comment out that whole section 
  • src/sas/sasgui/guiframe/gui_manager.py

    rb963b20 rfa81e94  
    25192519            wx.PostEvent(self, StatusEvent(status=msg, 
    25202520                                           info="error")) 
    2521             raise ValueError, msg 
     2521            raise (ValueError, msg) 
    25222522        # text = str(data) 
    25232523        text = data.__str__() 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py

    rc416a17 rfa81e94  
    475475            try: 
    476476                self._onEVT_FUNC_PROPERTY() 
    477             except Exception, exc: 
     477            except (Exception, exc): 
    478478                wx.PostEvent(self.parent, 
    479479                             StatusEvent(status="Plotting Error: %s" % str(exc), info="error")) 
     
    492492                    # MAC: forcing to plot 2D avg 
    493493                    self.canvas._onDrawIdle() 
    494             except Exception, exc: 
     494            except (Exception, exc): 
    495495                wx.PostEvent(self.parent, StatusEvent(status=\ 
    496496                    "Plotting Error: %s" % str(exc), info="error")) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

    rcee5c78 rfa81e94  
    232232            msg = "Phi left and phi right are different" 
    233233            msg += " %f, %f" % (self.left_line.phi, self.right_line.phi) 
    234             raise ValueError, msg 
     234            raise (ValueError, msg) 
    235235        params["Phi [deg]"] = self.main_line.theta * 180 / numpy.pi 
    236236        params["Delta_Phi [deg]"] = numpy.fabs(self.left_line.phi * 180 / numpy.pi) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/binder.py

    r463e7ffc rfa81e94  
    187187        # Check that the trigger is valid 
    188188        if trigger not in self._actions: 
    189             raise ValueError, "%s invalid --- valid triggers are %s" \ 
    190                 % (trigger, ", ".join(self.events)) 
     189            raise (ValueError, "%s invalid --- valid triggers are %s" \ 
     190                % (trigger, ", ".join(self.events))) 
    191191        # Register the trigger callback 
    192192        self._actions[trigger][artist] = action 
     
    203203        """ 
    204204        if action not in self.events: 
    205             raise ValueError, "Trigger expects " + ", ".join(self.events) 
     205            raise (ValueError, "Trigger expects " + ", ".join(self.events)) 
    206206        # Tag the event with modifiers 
    207207        for mod in ('alt', 'control', 'shift', 'meta'): 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py

    rcee5c78 rfa81e94  
    136136            if new_slab is None: 
    137137                msg = "post data:cannot average , averager is empty" 
    138                 raise ValueError, msg 
     138                raise (ValueError, msg) 
    139139            self.averager = new_slab 
    140140        if self.direction == "X": 
     
    152152        else: 
    153153            msg = "post data:no Box Average direction was supplied" 
    154             raise ValueError, msg 
     154            raise (ValueError, msg) 
    155155        # # Average data2D given Qx or Qy 
    156156        box = self.averager(x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/plotting.py

    r2d9526d rfa81e94  
    200200 
    201201        msg = "1D Panel of group ID %s could not be created" % str(group_id) 
    202         raise ValueError, msg 
     202        raise (ValueError, msg) 
    203203 
    204204    def create_2d_panel(self, data, group_id): 
     
    218218            return new_panel 
    219219        msg = "2D Panel of group ID %s could not be created" % str(group_id) 
    220         raise ValueError, msg 
     220        raise (ValueError, msg) 
    221221 
    222222    def update_panel(self, data, panel): 
     
    238238            msg += " to panel %s\n" % str(panel.window_caption) 
    239239            msg += "Please edit %s's units, labels" % str(data.name) 
    240             raise ValueError, msg 
     240            raise (ValueError, msg) 
    241241        else: 
    242242            if panel.group_id not in data.list_group_id: 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/sector_mask.py

    r7432acb rfa81e94  
    175175            msg += "different %f, %f" % (self.left_line.phi, 
    176176                                         self.right_line.phi) 
    177             raise ValueError, msg 
     177            raise (ValueError, msg) 
    178178        params["Phi"] = self.main_line.theta 
    179179        params["Delta_Phi"] = math.fabs(self.left_line.phi) 
  • src/sas/sasgui/guiframe/plugin_base.py

    r7432acb rfa81e94  
    277277        """ 
    278278        msg = "%s plugin: does not support import theory" % str(self.sub_menu) 
    279         raise ValueError, msg 
     279        raise (ValueError, msg) 
    280280 
    281281    def on_set_state_helper(self, event): 
  • src/sas/sasgui/guiframe/proxy.py

    ra1b8fee rfa81e94  
    127127            logger.debug("Trying Direct connection to %s..."%self.url) 
    128128            response = urllib2.urlopen(req, timeout=self.timeout) 
    129         except Exception, e: 
     129        except (Exception, e): 
    130130            logger.debug("Failed!") 
    131131            logger.debug(e) 
     
    134134                self._set_proxy() 
    135135                response = urllib2.urlopen(req, timeout=self.timeout) 
    136             except Exception, e: 
     136            except (Exception, e): 
    137137                logger.debug("Failed!") 
    138138                logger.debug(e) 
     
    144144                        self._set_proxy(proxy) 
    145145                        response = urllib2.urlopen(req, timeout=self.timeout) 
    146                     except Exception, e: 
     146                    except (Exception, e): 
    147147                        logger.debug("Failed!") 
    148148                        logger.debug(e) 
  • src/sas/sasgui/perspectives/calculator/__init__.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    • Property mode changed from 100644 to 100755
    rc416a17 rfa81e94  
    6565        if self.data is None: 
    6666            msg = "Compute Calc2D receive data = %s.\n" % str(self.data) 
    67             raise ValueError, msg 
     67            raise ValueError(msg) 
    6868 
    6969        # Define matrix where data will be plotted 
  • src/sas/sasgui/perspectives/fitting/simfitpage.py

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

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

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

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

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

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

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

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

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

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

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

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

    • Property mode changed from 100644 to 100755
    rac07a3a rfa81e94  
    4343        except: 
    4444            if self.error_func is not None: 
    45                 self.error_func("CalcPr.compute: %s" % sys.exc_value) 
     45                self.error_func("CalcPr.compute: %s" % sys.exc_info()[1]) 
    4646 
    4747class EstimatePr(CalcThread): 
     
    7171        except: 
    7272            if self.error_func is not None: 
    73                 self.error_func("EstimatePr.compute: %s" % sys.exc_value) 
     73                self.error_func("EstimatePr.compute: %s" % sys.exc_info()[1]) 
    7474 
    7575class EstimateNT(CalcThread): 
     
    111111        except: 
    112112            if self.error_func is not None: 
    113                 self.error_func("EstimatePr2.compute: %s" % sys.exc_value) 
     113                self.error_func("EstimatePr2.compute: %s" % sys.exc_info()[1]) 
  • src/sas/sasgui/plottools/LineModel.py

    • Property mode changed from 100644 to 100755
    ra26f67f rfa81e94  
    8383        elif x.__class__.__name__ == 'tuple': 
    8484            msg = "Tuples are not allowed as input to BaseComponent models" 
    85             raise ValueError, msg 
     85            raise ValueError(msg) 
    8686        else: 
    8787            return self._line(x) 
     
    105105        elif x.__class__.__name__ == 'tuple': 
    106106            msg = "Tuples are not allowed as input to BaseComponent models" 
    107             raise ValueError, msg 
     107            raise ValueError(msg) 
    108108        else: 
    109109            return self._line(x) 
  • src/sas/sasgui/plottools/PlotPanel.py

    • Property mode changed from 100644 to 100755
    ra1b8fee rfa81e94  
    22    Plot panel. 
    33""" 
    4 from __future__ import print_function 
     4 
    55 
    66import logging 
     
    1616from matplotlib.figure import Figure 
    1717import os 
    18 import transform 
     18from . import transform 
    1919#TODO: make the plottables interactive 
    20 from binder import BindArtist 
     20from .binder import BindArtist 
    2121from matplotlib.font_manager import FontProperties 
    2222DEBUG = False 
    2323 
    24 from plottables import Graph 
    25 from TextDialog import TextDialog 
    26 from LabelDialog import LabelDialog 
     24from .plottables import Graph 
     25from .TextDialog import TextDialog 
     26from .LabelDialog import LabelDialog 
    2727import operator 
    2828 
     
    4444        for a in obj.get_children(): show_tree(a, d + 1) 
    4545 
    46 from convert_units import convert_unit 
     46from .convert_units import convert_unit 
    4747 
    4848 
     
    116116        self.figure = Figure(None, dpi, linewidth=2.0) 
    117117        self.color = '#b3b3b3' 
    118         from canvas import FigureCanvas 
     118        from .canvas import FigureCanvas 
    119119        self.canvas = FigureCanvas(self, -1, self.figure) 
    120120        self.SetColor(color) 
     
    657657        else: 
    658658            plot_dict = plotlist 
    659         from fitDialog import LinearFit 
    660  
    661         if len(plot_dict.keys()) > 0: 
    662             first_item = plot_dict.keys()[0] 
     659        from .fitDialog import LinearFit 
     660 
     661        if len(list(plot_dict.keys())) > 0: 
     662            first_item = list(plot_dict.keys())[0] 
    663663            dlg = LinearFit(parent=None, plottable=first_item, 
    664664                            push_data=self.onFitDisplay, 
     
    691691            return 
    692692        name = menu.GetHelpString(id) 
    693         for plot in self.plots.values(): 
     693        for plot in list(self.plots.values()): 
    694694            if plot.name == name: 
    695695                self.graph.selected_plottable = plot.id 
     
    703703 
    704704        """ 
    705         from fitDialog import LinearFit 
     705        from .fitDialog import LinearFit 
    706706        if self._fit_dialog is not None: 
    707707            return 
     
    733733            self._fit_dialog = None 
    734734        plot_list = self.graph.returnPlottable() 
    735         if len(plot_list.keys()) > 0: 
    736             first_item = plot_list.keys()[0] 
     735        if len(list(plot_list.keys())) > 0: 
     736            first_item = list(plot_list.keys())[0] 
    737737            if first_item.x != []: 
    738                 from PropertyDialog import Properties 
     738                from .PropertyDialog import Properties 
    739739                dial = Properties(self, -1, 'Properties') 
    740740                dial.setValues(self.prevXtrans, self.prevYtrans, self.viewModel) 
     
    956956            hl = sorted(zip(handles, labels), 
    957957                        key=operator.itemgetter(1)) 
    958             handles2, labels2 = zip(*hl) 
     958            handles2, labels2 = list(zip(*hl)) 
    959959            self.line_collections_list = handles2 
    960960            self.legend = self.subplot.legend(handles2, labels2, 
     
    986986        hl = sorted(zip(handles, labels), 
    987987                    key=operator.itemgetter(1)) 
    988         handles2, labels2 = zip(*hl) 
     988        handles2, labels2 = list(zip(*hl)) 
    989989        self.line_collections_list = handles2 
    990990        self.legend = self.subplot.legend(handles2, labels2, 
     
    12471247                hl = sorted(zip(handles, labels), 
    12481248                            key=operator.itemgetter(1)) 
    1249                 handles2, labels2 = zip(*hl) 
     1249                handles2, labels2 = list(zip(*hl)) 
    12501250                self.line_collections_list = handles2 
    12511251                self.legend = ax.legend(handles2, labels2, 
     
    13271327        if id is None: 
    13281328            id = name 
    1329         from plottable_interactor import PointInteractor 
     1329        from .plottable_interactor import PointInteractor 
    13301330        p = PointInteractor(self, self.subplot, zorder=zorder, id=id) 
    13311331        if p.markersize is not None: 
     
    13441344        if id is None: 
    13451345            id = name 
    1346         from plottable_interactor import PointInteractor 
     1346        from .plottable_interactor import PointInteractor 
    13471347        p = PointInteractor(self, self.subplot, zorder=zorder, id=id) 
    13481348        p.curve(x, y, dy=dy, color=color, symbol=symbol, zorder=zorder, 
     
    17541754            self.graph.delete(self.fit_result) 
    17551755            if hasattr(self, 'plots'): 
    1756                 if 'fit' in self.plots.keys(): 
     1756                if 'fit' in list(self.plots.keys()): 
    17571757                    del self.plots['fit'] 
    17581758        self.ly = None 
  • src/sas/sasgui/plottools/__init__.py

    • Property mode changed from 100644 to 100755
    refe730d rfa81e94  
    1 from PlotPanel import PlotPanel 
    2 from plottables import Data1D, Theory1D 
     1from .PlotPanel import PlotPanel 
     2from .plottables import Data1D, Theory1D 
  • src/sas/sasgui/plottools/arrow3d.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    5959            return 
    6060        xs3d, ys3d, zs3d = self._verts3d 
    61         for i in xrange(len(xs3d)): 
     61        for i in range(len(xs3d)): 
    6262            xs, ys, _ = proj3d.proj_transform(xs3d[i], ys3d[i], zs3d[i], renderer.M) 
    6363            self.set_positions((xs[0], ys[0]), (xs[1], ys[1])) 
  • src/sas/sasgui/plottools/binder.py

    • Property mode changed from 100644 to 100755
    ra1b8fee rfa81e94  
    22Extension to MPL to support the binding of artists to key/mouse events. 
    33""" 
    4 from __future__ import print_function 
     4 
    55 
    66import sys 
     
    2828        return self.artist is not other.artist 
    2929 
    30     def __nonzero__(self): 
     30    def __bool__(self): 
    3131        return self.artist is not None 
    3232 
     
    125125            for cid in self._connections: self.canvas.mpl_disconnect(cid) 
    126126        except: 
    127             logger.error("Error disconnection canvas: %s" % sys.exc_value) 
     127            logger.error("Error disconnection canvas: %s" % sys.exc_info()[1]) 
    128128        self._connections = [] 
    129129 
     
    189189        # Check that the trigger is valid 
    190190        if trigger not in self._actions: 
    191             raise ValueError, "%s invalid --- valid triggers are %s"\ 
    192                  % (trigger, ", ".join(self.events)) 
     191            raise ValueError("%s invalid --- valid triggers are %s"\ 
     192                 % (trigger, ", ".join(self.events))) 
    193193 
    194194        # Register the trigger callback 
     
    205205        """ 
    206206        if action not in self.events: 
    207             raise ValueError, "Trigger expects " + ", ".join(self.events) 
     207            raise ValueError("Trigger expects " + ", ".join(self.events)) 
    208208 
    209209        # Tag the event with modifiers 
  • src/sas/sasgui/plottools/canvas.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    9898            dc.DrawBitmap(self.canvas.bitmap, (0, 0)) 
    9999        except: 
    100             logger.error(sys.exc_value) 
     100            logger.error(sys.exc_info()[1]) 
    101101 
    102102    # restore original figure  resolution 
     
    209209                fig.draw(self) 
    210210            except ValueError: 
    211                 logger.error(sys.exc_value) 
     211                logger.error(sys.exc_info()[1]) 
    212212        else: 
    213213            self._isRendered = False 
  • src/sas/sasgui/plottools/convert_units.py

    • Property mode changed from 100644 to 100755
    ra1b8fee rfa81e94  
    33    This is a cleaned up version of unitConverter.py 
    44""" 
    5 from __future__ import print_function 
     5 
    66 
    77import re 
     
    4444                            unit = toks[0] + "^{" + str(powerer) + "}" 
    4545                else: 
    46                     raise ValueError, "missing } in unit expression" 
     46                    raise ValueError("missing } in unit expression") 
    4747        else:  # no powerer 
    4848            if  power != 1: 
    4949                unit = "(" + unit + ")" + "^{" + str(power) + "}" 
    5050    else: 
    51         raise ValueError, "empty unit ,enter a powerer different from zero" 
     51        raise ValueError("empty unit ,enter a powerer different from zero") 
    5252    return unit 
    5353 
  • src/sas/sasgui/plottools/fitDialog.py

    • Property mode changed from 100644 to 100755
    r7432acb rfa81e94  
    11import wx 
    2 from plottables import Theory1D 
     2from .plottables import Theory1D 
    33import math 
    44import numpy as np 
    5 import fittings 
    6 import transform 
     5from . import fittings 
     6from . import transform 
    77import sys 
    88 
     
    8686        self.layout() 
    8787        # Receives the type of model for the fitting 
    88         from LineModel import LineModel 
     88        from .LineModel import LineModel 
    8989        self.model = LineModel() 
    9090        # Display the fittings values 
     
    671671                return x 
    672672            else: 
    673                 raise ValueError, "cannot compute log of a negative number" 
     673                raise ValueError("cannot compute log of a negative number") 
    674674 
    675675    def floatInvTransform(self, x): 
     
    734734        except: 
    735735            msg = "LinearFit.set_fit_region: fit range must be floats" 
    736             raise ValueError, msg 
     736            raise ValueError(msg) 
    737737        self.xminFit.SetValue(format_number(xmin)) 
    738738        self.xmaxFit.SetValue(format_number(xmax)) 
  • src/sas/sasgui/plottools/fittings.py

    • Property mode changed from 100644 to 100755
    ra1b8fee rfa81e94  
    1414 
    1515""" 
    16 from __future__ import print_function 
     16 
    1717 
    1818from scipy import optimize 
     
    101101    # Testing implementation 
    102102    # Fit a Line model 
    103     from LineModel import LineModel 
     103    from .LineModel import LineModel 
    104104    line = LineModel() 
    105105    cstA = Parameter(line, 'A', event.cstA) 
  • src/sas/sasgui/plottools/plottable_interactor.py

    • Property mode changed from 100644 to 100755
    ra1b8fee rfa81e94  
    22    This module allows more interaction with the plot 
    33""" 
    4 from __future__ import print_function 
    5  
    6 from BaseInteractor import _BaseInteractor 
     4 
     5 
     6from .BaseInteractor import _BaseInteractor 
    77 
    88 
  • src/sas/sasgui/plottools/plottables.py

    • Property mode changed from 100644 to 100755
    r2d9526d rfa81e94  
    242242        selected_color = plottable.custom_color 
    243243        selected_plottable = None 
    244         for p in self.plottables.keys(): 
     244        for p in list(self.plottables.keys()): 
    245245            if plottable.id == p.id: 
    246246                selected_plottable = p 
     
    389389 
    390390        """ 
    391         raise NotImplemented, "Not a valid transform" 
     391        raise NotImplemented("Not a valid transform") 
    392392 
    393393    # Related issues 
     
    517517                label_dict[collection[0]] = basename 
    518518            else: 
    519                 for i in xrange(len(collection)): 
     519                for i in range(len(collection)): 
    520520                    label_dict[collection[i]] = "%s %d" % (basename, i) 
    521521        return label_dict 
     
    689689                msg = "Plottable.View: Given x and dx are not" 
    690690                msg += " of the same length" 
    691                 raise ValueError, msg 
     691                raise ValueError(msg) 
    692692            # Check length of y array 
    693693            if not len(y) == len(x): 
    694694                msg = "Plottable.View: Given y " 
    695695                msg += "and x are not of the same length" 
    696                 raise ValueError, msg 
     696                raise ValueError(msg) 
    697697 
    698698            if dy is not None and not len(dy) == 0 and not len(y) == len(dy): 
    699699                msg = "Plottable.View: Given y and dy are not of the same " 
    700700                msg += "length: len(y)=%s, len(dy)=%s" % (len(y), len(dy)) 
    701                 raise ValueError, msg 
     701                raise ValueError(msg) 
    702702            self.x = [] 
    703703            self.y = [] 
     
    734734                msg = "Plottable.View: transformed x " 
    735735                msg += "and y are not of the same length" 
    736                 raise ValueError, msg 
     736                raise ValueError(msg) 
    737737            if has_err_x and not (len(self.x) == len(self.dx)): 
    738738                msg = "Plottable.View: transformed x and dx" 
    739739                msg += " are not of the same length" 
    740                 raise ValueError, msg 
     740                raise ValueError(msg) 
    741741            if has_err_y and not (len(self.y) == len(self.dy)): 
    742742                msg = "Plottable.View: transformed y" 
    743743                msg += " and dy are not of the same length" 
    744                 raise ValueError, msg 
     744                raise ValueError(msg) 
    745745            # Check that negative values are not plot on x and y axis for 
    746746            # log10 transformation 
     
    814814                except: 
    815815                    logger.error("check_data_logX: skipping point x %g", self.x[i]) 
    816                     logger.error(sys.exc_value) 
     816                    logger.error(sys.exc_info()[1]) 
    817817            self.x = tempx 
    818818            self.y = tempy 
     
    844844                except: 
    845845                    logger.error("check_data_logY: skipping point %g", self.y[i]) 
    846                     logger.error(sys.exc_value) 
     846                    logger.error(sys.exc_info()[1]) 
    847847 
    848848            self.x = tempx 
     
    11081108        Plottable.__init__(self) 
    11091109        msg = "Theory1D is no longer supported, please use Data1D and change symbol.\n" 
    1110         raise DeprecationWarning, msg 
     1110        raise DeprecationWarning(msg) 
    11111111 
    11121112class Fit1D(Plottable): 
  • src/sas/sasgui/plottools/transform.py

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