Changeset 5a81885 – SasView

src/sas/sasgui/guiframe/report_dialog.py

-                      r463e7ffc
+                      r69a6897
 if sys.platform == "win32":
     _STATICBOX_WIDTH = 450
     PANEL_WIDTH = 500
+    PANEL_WIDTH = 500
     PANEL_HEIGHT = 700
     FONT_VARIANT = 0
 …
 class BaseReportDialog(wx.Dialog):
     def __init__(self, report_list, *args, **kwds):
         """
         Initialization. The parameters added to Dialog are:
         :param report_list: list of html_str, text_str, image for report
         """
 …
         self.report_list = report_list
         # wild card
+        # pdf supporting only on MAC
+        if self.is_pdf:
+            self.wild_card = ' PDF files (*.pdf)|*.pdf|'
+        if self.is_pdf:  # pdf writer is available
+            self.wild_card = 'PDF files (*.pdf)|*.pdf|'
             self.index_offset = 0
         else:
 …
         """
         hbox = wx.BoxSizer(wx.HORIZONTAL)
         # buttons
         button_close = wx.Button(self, wx.ID_OK, "Close")
 …
                           id=button_print.GetId())
         hbox.Add(button_print)
         button_save = wx.Button(self, wx.NewId(), "Save")
         button_save.SetToolTipString("Save this report.")
         button_save.Bind(wx.EVT_BUTTON, self.onSave, id=button_save.GetId())
         hbox.Add(button_save)
         # panel for report page
         vbox = wx.BoxSizer(wx.VERTICAL)
 …
         # set the html page with the report string
         self.hwindow.SetPage(self.report_html)
         # add panels to boxsizers
         vbox.Add(hbox)
 …
         previewh = html.HtmlEasyPrinting(name="Printing", parentWindow=self)
         previewh.PreviewText(self.report_html)
     def onPrint(self, event=None):
         """
 …
         """
         self.Close()
     def HTML2PDF(self, data, filename):
         """
         Create a PDF file from html source string.
         Returns True is the file creation was successful.
+        Returns True is the file creation was successful.
         : data: html string
         : filename: name of file to be saved
 …
             self.Update()
             return pisaStatus.err
         except:
+        except Exception:
             logger.error("Error creating pdf: %s" % sys.exc_value)
         return False

src/sas/sasgui/perspectives/fitting/report_dialog.py

-                      r78312f7
+                      r69a6897
         fName = dlg.GetPath()
+        basename = os.path.splitext(fName)[0]
         ext_num = dlg.GetFilterIndex()
+        dlg.Destroy()
+        if ext_num == 0 and self.index_offset == 0:  # has pdf
+            ext = ".pdf"
+        elif ext_num == 1 - self.index_offset:
+            ext = ".html"
+        elif ext_num == 2 - self.index_offset:
+            ext = ".txt"
+        else:
+            logger.warn("unknown export format in report dialog")
+            return
+        filename = basename + ext
+        # save figures
+        pictures = []
+        for num in range(self.nimages):
+            pic_name = basename + '_img%s.png' % num
+            # save the image for use with pdf writer
+            self.report_list[2][num].savefig(pic_name)
+            pictures.append(pic_name)
+        # translate png references int html from in-memory name to on-disk name
+        html = self.report_html.replace("memory:img_fit", basename+'_img')
         #set file extensions
         img_ext = []
+        pic_fname = []
+        #PDF
+        if ext_num == (0 + 2 * self.index_offset):
+            # TODO: Sort this case out
+            ext = '.pdf'
+        if ext == ".pdf":
+            # write pdf as a pdf file
+            pdf = self.HTML2PDF(data=html, filename=filename)
+            fName = os.path.splitext(fName)[0] + ext
+            dlg.Destroy()
+            #pic (png) file path/name
+            for num in range(self.nimages):
+                im_ext = '_img%s.png' % num
+                #img_ext.append(im_ext)
+                pic_name = os.path.splitext(fName)[0] + im_ext
+                pic_fname.append(pic_name)
+                # save the image for use with pdf writer
+                self.report_list[2][num].savefig(pic_name)
+            # delete images used to create the pdf
+            for pic_name in pictures:
+                os.remove(pic_name)
+            #put the image path in html string
+            report_frame = self.report_list[0]
+            #put image name strings into the html file
+            #Note:The str for pic_fname shouldn't be removed.
+            if self.nimages == 1:
+                html = report_frame % str(pic_fname[0])
+            elif self.nimages == 2:
+                html = report_frame % (str(pic_fname[0]), str(pic_fname[1]))
+            elif self.nimages == 3:
+                html = report_frame % (str(pic_fname[0]), str(pic_fname[1]),
+                                       str(pic_fname[2]))
+            # make/open file in case of absence
+            f = open(fName, 'w')
+            f.close()
+            # write pdf as a pdf file
+            pdf = self.HTML2PDF(data=html, filename=fName)
+            #open pdf
+            #open pdf viewer
             if pdf:
                 try:
+                    #Windows
+                    os.startfile(str(fName))
+                except Exception:
+                    try:
+                        #Mac
+                    if os.name == 'nt':  # Windows
+                        os.startfile(fName)
+                    elif sys.platform == "darwin":  # Mac
                         os.system("open %s" % fName)
+                    except Exception:
+                        #DO not open
+                        pass
+            #delete image file
+            for num in range(self.nimages):
+                os.remove(pic_fname[num])
+            return
+        #HTML + png(graph)
+        elif ext_num == (1 - self.index_offset):
+            ext = '.html'
+            for num in range(self.nimages):
+                img_ext.append('_img4html%s.png' % num)
+            report_frame = self.report_list[0]
+        #TEXT + pdf(graph)
+        elif ext_num == (2 - self.index_offset):
+            ext = '.txt'
+            # changing the image extension actually changes the image
+            # format on saving
+            for num in range(self.nimages):
+                img_ext.append('_img4txt%s.pdf' % num)
+            report = self.report_list[1]
+        else:
+            return
+                except Exception as exc:
+                    # cannot open pdf
+                    logging.error(str(exc))
         #file name
         fName = os.path.splitext(fName)[0] + ext
         dlg.Destroy()
+        elif ext == ".html":
+            with open(filename, 'w') as f:
+                f.write(html)
+        #pic (png) file path/name
+        for num in range(self.nimages):
+            pic_name = os.path.splitext(fName)[0] + img_ext[num]
+            pic_fname.append(pic_name)
+        #put the image path in html string
+        if ext_num == (1 - self.index_offset):
+            if self.nimages == 1:
+                report = report_frame % os.path.basename(pic_fname[0])
+            elif self.nimages == 2:
+                report = report_frame % (os.path.basename(pic_fname[0]),
+                                         os.path.basename(pic_fname[1]))
+            elif self.nimages == 3:
+                report = report_frame % (os.path.basename(pic_fname[0]),
+                                         os.path.basename(pic_fname[1]),
+                                         os.path.basename(pic_fname[2]))
+        f = open(fName, 'w')
+        f.write(report)
+        f.close()
+        elif ext == ".txt":
+            with open(filename, 'w') as f:
+                f.write(self.report_list[1])
         self.Update()
-        #save png file using pic_fname
-        for num in range(self.nimages):
-            self.report_list[2][num].savefig(pic_fname[num])

build_tools/conda/periodictable/meta.yaml

-                      r55bde35
+                      r36ca21e
 package:
   name: periodictable
   version: !!str 1.4.1
+  version: !!str 1.5.0
 source:
   fn: periodictable-1.4.1.tar.gz
   url: https://pypi.python.org/packages/source/p/periodictable/periodictable-1.4.1.tar.gz
   md5: 7246b63cc0b6b1be6e86b6616f9e866e
+  fn: periodictable-1.5.0.tar.gz
+  url: https://pypi.python.org/packages/source/p/periodictable/periodictable-1.5.0.tar.gz
+  md5: f7e0d8199b0fe829868d24a0a734398e
 #  patches:
    # List any patch files here

build_tools/jenkins_rhel6_build.sh

-                      r243fbc0
+                      r36ca21e
 "$EASY_INSTALL" -d "$WORKSPACE/utils" pyparsing==1.5.5
 "$EASY_INSTALL" -d "$WORKSPACE/utils" bumps==0.7.5.9
 "$EASY_INSTALL" -d "$WORKSPACE/utils" periodictable==1.3.0
+"$EASY_INSTALL" -d "$WORKSPACE/utils" periodictable==1.5.0
 python deps.py
 …
 # Build SasView ###########################################################
 export PYTHONPATH=$PYTHONPATH:$WORKSPACE/$SASVIEW_INSTALL:$WORKSPACE/utils
 python setup.py bdist_egg
+python setup.py bdist_egg

build_tools/requirements.txt

r131d94b	r36ca21e
8	8	lxml==2.3
9	9	#PIL==1.1.7
10		periodictable==1.3.0
	10	periodictable==1.5.0
11	11	bumps==0.7.5.9
12	12	numpy>=1.7.1

check_packages.py

r3e1f417	r36ca21e
27	27	'PIL': {'version': '1.1.7', 'import_name': 'Image', 'test': 'VERSION'},
28	28	'pylint': {'version': None, 'import_name': 'pylint', 'test': None},
29		'periodictable': {'version': '1.3.0', 'import_name': 'periodictable', 'test': '__version__'},
	29	'periodictable': {'version': '1.5.0', 'import_name': 'periodictable', 'test': '__version__'},
30	30	'bumps': {'version': '0.7.5.9', 'import_name': 'bumps', 'test': '__version__'},
31	31	'numpy': {'version': '1.7.1', 'import_name': 'numpy', 'test': '__version__'},

run.py

r2ecb0a5	r0225a3f
	1	#!/usr/bin/env python
1	2	# -- coding: utf-8 --
2		~~#!/usr/bin/env python~~
3	3	"""
4	4	Run sasview in place. This allows sasview to use the python

setup.py

-                      r7152c82
+                      r36ca21e
     #             os.remove(file_path)
+if os.path.exists(SASVIEW_BUILD):
+# Optionally clean before build.
+dont_clean = 'update' in sys.argv
+if dont_clean:
+    sys.argv.remove('update')
+elif os.path.exists(SASVIEW_BUILD):
     print("Removing existing build directory", SASVIEW_BUILD, "for a clean build")
     shutil.rmtree(SASVIEW_BUILD)
 …
 required = [
     'bumps>=0.7.5.9', 'periodictable>=1.3.1', 'pyparsing<2.0.0',
+    'bumps>=0.7.5.9', 'periodictable>=1.5.0', 'pyparsing<2.0.0',
     # 'lxml>=2.2.2',

src/sas/sascalc/calculator/BaseComponent.py

-                      r9a5097c
+                      r574adc7
                 qdist[1].__class__.__name__ != 'ndarray':
                 msg = "evalDistribution expects a list of 2 ndarrays"
                 raise RuntimeError, msg
+                raise RuntimeError(msg)
             # Extract qx and qy for code clarity
 …
             mesg = "evalDistribution is expecting an ndarray of scalar q-values"
             mesg += " or a list [qx,qy] where qx,qy are 2D ndarrays."
             raise RuntimeError, mesg
+            raise RuntimeError(mesg)
 …
                     return
         raise ValueError, "Model does not contain parameter %s" % name
+        raise ValueError("Model does not contain parameter %s" % name)
     def getParam(self, name):
 …
                     return self.params[item]
         raise ValueError, "Model does not contain parameter %s" % name
+        raise ValueError("Model does not contain parameter %s" % name)
     def getParamList(self):
 …
         add
         """
         raise ValueError, "Model operation are no longer supported"
+        raise ValueError("Model operation are no longer supported")
     def __sub__(self, other):
         """
         sub
         """
         raise ValueError, "Model operation are no longer supported"
+        raise ValueError("Model operation are no longer supported")
     def __mul__(self, other):
         """
         mul
         """
         raise ValueError, "Model operation are no longer supported"
+        raise ValueError("Model operation are no longer supported")
     def __div__(self, other):
         """
         div
         """
         raise ValueError, "Model operation are no longer supported"
+        raise ValueError("Model operation are no longer supported")

src/sas/sascalc/calculator/c_extensions/sld2i_module.cpp

-                      rb523c0e
+                      r1d014cb
 #include <stdio.h>
 #include <sld2i.hh>
+#if PY_MAJOR_VERSION < 3
+typedef void (*PyCapsule_Destructor)(PyObject *);
+typedef void (*PyCObject_Destructor)(void *);
+#define PyCapsule_New(pointer, name, destructor) (PyCObject_FromVoidPtr(pointer, (PyCObject_Destructor)destructor))
+#define PyCapsule_GetPointer(capsule, name) (PyCObject_AsVoidPtr(capsule))
+#endif
 // Utilities
 …
  * Delete a GenI object
  */
+void del_sld2i(void *ptr){
+        GenI* sld2i = static_cast<GenI *>(ptr);
+void
+del_sld2i(PyObject *obj){
+        GenI* sld2i = static_cast<GenI *>(PyCapsule_GetPointer(obj, "GenI"));
         delete sld2i;
         return;
 …
         OUTVECTOR(vol_pix_obj, vol_pix, n_x);
         GenI* sld2i = new GenI(n_pix,x_val,y_val,z_val,sldn_val,mx_val,my_val,mz_val,vol_pix,inspin,outspin,stheta);
         return PyCObject_FromVoidPtr(sld2i, del_sld2i);
+        return PyCapsule_New(sld2i, "GenI", del_sld2i);
+}
 …
         // Set the array pointers
         void *temp = PyCObject_AsVoidPtr(gen_obj);
+        void *temp = PyCapsule_GetPointer(gen_obj, "GenI");
         GenI* s = static_cast<GenI *>(temp);
 …
         // Set the array pointers
         void *temp = PyCObject_AsVoidPtr(gen_obj);
+        void *temp = PyCapsule_GetPointer(gen_obj, "GenI");
         GenI* s = static_cast<GenI *>(temp);
 …
 };
+#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
+#define PyMODINIT_FUNC void
+#define MODULE_DOC "Sld2i C Library"
+#define MODULE_NAME "sld2i"
+#define MODULE_INIT2 initsld2i
+#define MODULE_INIT3 PyInit_sld2i
+#define MODULE_METHODS module_methods
+/* ==== boilerplate python 2/3 interface bootstrap ==== */
+#if defined(WIN32) && !defined(__MINGW32__)
+    #define DLL_EXPORT __declspec(dllexport)
+#else
+    #define DLL_EXPORT
 #endif
+PyMODINIT_FUNC
+initsld2i(void)
+{
+    Py_InitModule3("sld2i", module_methods, "Sld2i module");
+}
+#if PY_MAJOR_VERSION >= 3
+  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT3(void)
+  {
+    static struct PyModuleDef moduledef = {
+      PyModuleDef_HEAD_INIT,
+      MODULE_NAME,         /* m_name */
+      MODULE_DOC,          /* m_doc */
+      -1,                  /* m_size */
+      MODULE_METHODS,      /* m_methods */
+      NULL,                /* m_reload */
+      NULL,                /* m_traverse */
+      NULL,                /* m_clear */
+      NULL,                /* m_free */
+    };
+    return PyModule_Create(&moduledef);
+  }
+#else /* !PY_MAJOR_VERSION >= 3 */
+  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT2(void)
+  {
+    Py_InitModule4(MODULE_NAME,
+                 MODULE_METHODS,
+                 MODULE_DOC,
+,
+                 PYTHON_API_VERSION
+                 );
+  }
+#endif /* !PY_MAJOR_VERSION >= 3 */

src/sas/sascalc/calculator/instrument.py

-                      r9a5097c
+                      r574adc7
         """
         # check if the wavelength is in range
+        if min(band) < self.min or\
+                max(band) > self.max:
+            raise
+        if min(band) < self.min or max(band) > self.max:
+            raise ValueError("band out of range")
         self.band = band
 …
         """
         # check if the wavelength is in range
+        if wavelength < min(self.band) or\
+                wavelength > max(self.band):
+            raise
+        if wavelength < min(self.band) or wavelength > max(self.band):
+            raise ValueError("wavelength out of range")
         self.wavelength = wavelength
         validate(wavelength)
 …
             plt.show()
         except:
             raise RuntimeError, "Can't import matplotlib required to plot..."
+            raise RuntimeError("Can't import matplotlib required to plot...")

src/sas/sascalc/calculator/resolution_calculator.py

-                      r7432acb
+                      r574adc7
 instrumental parameters.
 """
+from instrument import Sample
+from instrument import Detector
+from instrument import TOF as Neutron
+from instrument import Aperture
+# import math stuffs
+from math import pi
+from math import sqrt
+import sys
+from math import pi, sqrt
 import math
+import logging
 import numpy as np
+import sys
+import logging
+from .instrument import Sample
+from .instrument import Detector
+from .instrument import TOF as Neutron
+from .instrument import Aperture
 logger = logging.getLogger(__name__)
 …
         if wavelength == 0:
             msg = "Can't compute the resolution: the wavelength is zero..."
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         return self.intensity
 …
         if qx_min < self.qx_min:
             self.qx_min = qx_min
             #raise ValueError, msg
+            #raise ValueError(msg)
         if qx_max > self.qx_max:
             self.qx_max = qx_max
             #raise ValueError, msg
+            #raise ValueError(msg)
         if qy_min < self.qy_min:
             self.qy_min = qy_min
             #raise ValueError, msg
+            #raise ValueError(msg)
         if qy_max > self.qy_max:
             self.qy_max = qy_max
             #raise ValueError, msg
+            #raise ValueError(msg)
         if not full_cal:
             return None
 …
         # otherwise
         else:
             raise ValueError, " Improper input..."
+            raise ValueError(" Improper input...")
         # get them squared
         sigma = x_comp * x_comp
 …
             #self.set_wavelength(wavelength)
         else:
             raise
+            raise TypeError("invalid wavlength---should be list or float")
     def set_wave_spread(self, wavelength_spread):
 …
             self.wave.set_wave_spread_list([wavelength_spread])
         else:
             raise
+            raise TypeError("invalid wavelength spread---should be list or float")
     def set_wavelength(self, wavelength):
 …
         """
         if len(size) < 1 or len(size) > 2:
             raise RuntimeError, "The length of the size must be one or two."
+            raise RuntimeError("The length of the size must be one or two.")
         self.aperture.set_source_size(size)
 …
         """
         if len(size) < 1 or len(size) > 2:
             raise RuntimeError, "The length of the size must be one or two."
+            raise RuntimeError("The length of the size must be one or two.")
         self.aperture.set_sample_size(size)
 …
         """
         if len(distance) < 1 or len(distance) > 2:
             raise RuntimeError, "The length of the size must be one or two."
+            raise RuntimeError("The length of the size must be one or two.")
         self.aperture.set_sample_distance(distance)
 …
         """
         if len(distance) < 1 or len(distance) > 2:
             raise RuntimeError, "The length of the size must be one or two."
+            raise RuntimeError("The length of the size must be one or two.")
         self.sample.set_distance(distance)
 …
         """
         if len(distance) < 1 or len(distance) > 2:
             raise RuntimeError, "The length of the size must be one or two."
+            raise RuntimeError("The length of the size must be one or two.")
         self.detector.set_distance(distance)
 …
             pix_y_size = detector_pix_size[1]
         else:
             raise ValueError, " Input value format error..."
+            raise ValueError(" Input value format error...")
         # Sample to detector distance = sample slit to detector
         # minus sample offset

src/sas/sascalc/calculator/sas_gen.py

-                      rf2ea95a
+                      rb58265c3
 from __future__ import print_function
+import sas.sascalc.calculator.core.sld2i as mod
+from sas.sascalc.calculator.BaseComponent import BaseComponent
+import os
+import sys
+import copy
+import logging
 from periodictable import formula
 from periodictable import nsf
 import numpy as np
+import os
+import copy
+import sys
+import logging
+from .core import sld2i as mod
+from .BaseComponent import BaseComponent
 logger = logging.getLogger(__name__)
+if sys.version_info[0] < 3:
+    def decode(s):
+        return s
+else:
+    def decode(s):
+        return s.decode() if isinstance(s, bytes) else s
 MFACTOR_AM = 2.853E-12
 …
         factor = MFACTOR_MT
     else:
         raise ValueError, "Invalid valueunit"
+        raise ValueError("Invalid valueunit")
     sld_m = factor * mag
     return sld_m
 …
         """
         if self.data_vol is None:
             raise
+            raise TypeError("data_vol is missing")
         self.data_vol = volume
 …
             if len(x[1]) > 0:
                 msg = "Not a 1D."
                 raise ValueError, msg
+                raise ValueError(msg)
             i_out = np.zeros_like(x[0])
             # 1D I is found at y =0 in the 2D pattern
 …
         else:
             msg = "Q must be given as list of qx's and qy's"
             raise ValueError, msg
+            raise ValueError(msg)
     def runXY(self, x=0.0):
 …
         else:
             msg = "Q must be given as list of qx's and qy's"
             raise ValueError, msg
+            raise ValueError(msg)
     def evalDistribution(self, qdist):
 …
             mesg = "evalDistribution is expecting an ndarray of "
             mesg += "a list [qx,qy] where qx,qy are arrays."
             raise RuntimeError, mesg
+            raise RuntimeError(mesg)
 class OMF2SLD(object):
 …
                 z_dir2 *= z_dir2
                 mask = (x_dir2 + y_dir2 + z_dir2) <= 1.0
             except:
+            except Exception:
                 logger.error(sys.exc_value)
         self.output = MagSLD(self.pos_x[mask], self.pos_y[mask],
 …
         :Params length: data length
         """
+        msg = "Error: Inconsistent data length."
+        if len(self.pos_x) != length:
+            raise ValueError, msg
+        if len(self.pos_y) != length:
+            raise ValueError, msg
+        if len(self.pos_z) != length:
+            raise ValueError, msg
+        if len(self.mx) != length:
+            raise ValueError, msg
+        if len(self.my) != length:
+            raise ValueError, msg
+        if len(self.mz) != length:
+            raise ValueError, msg
+        parts = (self.pos_x, self.pos_y, self.pos_z, self.mx, self.my, self.mz)
+        if any(len(v) != length for v in parts):
+            raise ValueError("Error: Inconsistent data length.")
     def remove_null_points(self, remove=False, recenter=False):
 …
         try:
             input_f = open(path, 'rb')
             buff = input_f.read()
+            buff = decode(input_f.read())
             lines = buff.split('\n')
             input_f.close()
 …
             valueunit = None
             for line in lines:
                 toks = line.split()
+                line = line.strip()
                 # Read data
+                try:
+                    _mx = float(toks[0])
+                    _my = float(toks[1])
+                    _mz = float(toks[2])
+                    _mx = mag2sld(_mx, valueunit)
+                    _my = mag2sld(_my, valueunit)
+                    _mz = mag2sld(_mz, valueunit)
+                    mx = np.append(mx, _mx)
+                    my = np.append(my, _my)
+                    mz = np.append(mz, _mz)
+                except:
+                    # Skip non-data lines
+                    logger.error(sys.exc_value)
+                if line and not line.startswith('#'):
+                    try:
+                        toks = line.split()
+                        _mx = float(toks[0])
+                        _my = float(toks[1])
+                        _mz = float(toks[2])
+                        _mx = mag2sld(_mx, valueunit)
+                        _my = mag2sld(_my, valueunit)
+                        _mz = mag2sld(_mz, valueunit)
+                        mx = np.append(mx, _mx)
+                        my = np.append(my, _my)
+                        mz = np.append(mz, _mz)
+                    except Exception as exc:
+                        # Skip non-data lines
+                        logger.error(str(exc)+" when processing %r"%line)
                 #Reading Header; Segment count ignored
                 s_line = line.split(":", 1)
 …
                         msg = "Error: \n"
                         msg += "We accept only m as meshunit"
                         raise ValueError, msg
+                        raise ValueError(msg)
                 if s_line[0].lower().count("xbase") > 0:
                     xbase = s_line[1].lstrip()
 …
             output.set_m(mx, my, mz)
             return output
         except:
+        except Exception:
             msg = "%s is not supported: \n" % path
             msg += "We accept only Text format OMF file."
             raise RuntimeError, msg
+            raise RuntimeError(msg)
 class PDBReader(object):
 …
         try:
             input_f = open(path, 'rb')
             buff = input_f.read()
+            buff = decode(input_f.read())
             lines = buff.split('\n')
             input_f.close()
 …
                             float(line[12])
                             atom_name = atom_name[1].upper()
                         except:
+                        except Exception:
                             if len(atom_name) == 4:
                                 atom_name = atom_name[0].upper()
 …
                             vol = 1.0e+24 * atom.mass / atom.density / NA
                             vol_pix = np.append(vol_pix, vol)
                         except:
                             print("Error: set the sld of %s to zero"% atom_name)
+                        except Exception:
+                            logger.error("Error: set the sld of %s to zero"% atom_name)
                             sld_n = np.append(sld_n, 0.0)
                         sld_mx = np.append(sld_mx, 0)
 …
                             try:
                                 int_val = int(val)
                             except:
+                            except Exception:
                                 break
                             if int_val == 0:
 …
                         y_lines.append(y_line)
                         z_lines.append(z_line)
                 except:
+                except Exception:
                     logger.error(sys.exc_value)
 …
             output.sld_unit = '1/A^(2)'
             return output
         except:
             raise RuntimeError, "%s is not a sld file" % path
+        except Exception:
+            raise RuntimeError("%s is not a sld file" % path)
     def write(self, path, data):
 …
                 elif ncols == 7:
                     vol_pix = None
             except:
+            except Exception:
                 # For older version of numpy
                 input_f = open(path, 'rb')
                 buff = input_f.read()
+                buff = decode(input_f.read())
                 lines = buff.split('\n')
                 input_f.close()
 …
                             _vol_pix = float(toks[7])
                             vol_pix = np.append(vol_pix, _vol_pix)
                         except:
+                        except Exception:
                             vol_pix = None
                     except:
+                    except Exception:
                         # Skip non-data lines
                         logger.error(sys.exc_value)
 …
                 output.set_pixel_volumes(vol_pix)
             return output
         except:
             raise RuntimeError, "%s is not a sld file" % path
+        except Exception:
+            raise RuntimeError("%s is not a sld file" % path)
     def write(self, path, data):
 …
         """
         if path is None:
             raise ValueError, "Missing the file path."
+            raise ValueError("Missing the file path.")
         if data is None:
             raise ValueError, "Missing the data to save."
+            raise ValueError("Missing the data to save.")
         x_val = data.pos_x
         y_val = data.pos_y
 …
                 self.ynodes = int(ydist) + 1
                 self.znodes = int(zdist) + 1
             except:
+            except Exception:
                 self.xnodes = None
                 self.ynodes = None
 …
                 self.set_pixel_volumes(vol)
                 self.has_stepsize = True
             except:
+            except Exception:
                 self.xstepsize = None
                 self.ystepsize = None
 …
     reader = SLDReader()
     oreader = OMFReader()
     output = reader.read(tfpath)
     ooutput = oreader.read(ofpath)
+    output = decode(reader.read(tfpath))
+    ooutput = decode(oreader.read(ofpath))
     foutput = OMF2SLD()
     foutput.set_data(ooutput)
 …
             break
     oreader = OMFReader()
     ooutput = oreader.read(ofpath)
+    ooutput = decode(oreader.read(ofpath))
     foutput = OMF2SLD()
     foutput.set_data(ooutput)

src/sas/sascalc/corfunc/corfunc_calculator.py

-                      ra859f99
+                      r574adc7
         # Only process data of the class Data1D
         if not issubclass(data.__class__, Data1D):
             raise ValueError, "Data must be of the type DataLoader.Data1D"
+            raise ValueError("Data must be of the type DataLoader.Data1D")
         # Prepare the data
 …
             err = ("Incorrect transform type supplied, must be 'fourier'",
                 " or 'hilbert'")
             raise ValueError, err
+            raise ValueError(err)
         self._transform_thread.queue()

src/sas/sascalc/data_util/calcthread.py

-                      ra1b8fee
+                      r574adc7
 from __future__ import print_function
-import thread
 import traceback
 import sys
 import logging
+try:
+    import _thread as thread
+except ImportError: # CRUFT: python 2 support
+    import thread
 if sys.platform.count("darwin") > 0:
     import time
     stime = time.time()
     def clock():
         return time.time() - stime
     def sleep(t):
         return time.sleep(t)
 …
     CalcThread.__init__, passing it the keyword arguments for
     yieldtime, worktime, update and complete.
     When defining the compute() method you need to include code which
     allows the GUI to run.  They are as follows: ::
 …
             self._lock.release()
             self._time_for_update += 1e6  # No more updates
             self.updatefn(**kwargs)
             sleep(self.yieldtime)

src/sas/sascalc/data_util/nxsunit.py

-                      r8e9536f
+                      r574adc7
 in the NeXus definition files.
 Unlike other units packages, this package does not carry the units along with
+Unlike other units packages, this package does not carry the units along with
 the value but merely provides a conversion function for transforming values.
 …
     Ack! Allows, e.g., Coulomb and coulomb even though Coulomb is not
     a unit because some NeXus files store it that way!
     Returns a dictionary of names and scales.
     """
 …
                         n=1e-9,p=1e-12,f=1e-15)
     map = {abbr:1}
     map.update([(P+abbr,scale) for (P,scale) in short_prefix.iteritems()])
+    map.update([(P+abbr,scale) for (P,scale) in short_prefix.items()])
     for name in [unit,unit.capitalize()]:
         map.update({name:1,name+'s':1})
         map.update([(P+name,scale) for (P,scale) in prefix.iteritems()])
         map.update([(P+'*'+name,scale) for (P,scale) in prefix.iteritems()])
         map.update([(P+name+'s',scale) for (P,scale) in prefix.iteritems()])
+        map.update([(P+name,scale) for (P,scale) in prefix.items()])
+        map.update([(P+'*'+name,scale) for (P,scale) in prefix.items()])
+        map.update([(P+name+'s',scale) for (P,scale) in prefix.items()])
     return map
 …
     """
     map = {}
     map.update([(name,scale) for name,scale in kw.iteritems()])
     map.update([(name+'s',scale) for name,scale in kw.iteritems()])
+    map.update([(name,scale) for name,scale in kw.items()])
+    map.update([(name+'s',scale) for name,scale in kw.items()])
     return map
 …
     * WARNING * this will incorrect transform 10^3 to 103.
     """
     s.update((k.replace('^',''),v)
              for k,v in s.items()
+    s.update((k.replace('^',''),v)
+             for k, v in list(s.items())
              if '^' in k)
 …
     temperature.update(_build_metric_units('Celcius', 'C'))
     temperature.update(_build_metric_units('celcius', 'C'))
     charge = _build_metric_units('coulomb','C')
     charge.update({'microAmp*hour':0.0036})
     sld = { '10^-6 Angstrom^-2': 1e-6, 'Angstrom^-2': 1 }
     Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1,
+    Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1,
           '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8, '1/m': 1e-10,
           'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 }
 …
 def _check(expect,get):
+    if expect != get: raise ValueError, "Expected %s but got %s"%(expect,get)
+    if expect != get:
+        raise ValueError("Expected %s but got %s"%(expect, get))
      #print expect,"==",get
 …
     _check(123,Converter('a.u.')(123,units='s')) # arbitrary units always returns the same value
     _check(123,Converter('a.u.')(123,units='')) # arbitrary units always returns the same value
+    try: Converter('help')
+    except KeyError: pass
+    else: raise Exception("unknown unit did not raise an error")
+    try:
+        Converter('help')
+    except KeyError:
+        pass
+    else:
+        raise Exception("unknown unit did not raise an error")
     # TODO: more tests

src/sas/sascalc/data_util/odict.py

-                      rb699768
+                      r574adc7
     """
     A class of dictionary that keeps the insertion order of keys.
     All appropriate methods return keys, items, or values in an ordered way.
     All normal dictionary methods are available. Update and comparison is
     restricted to other OrderedDict objects.
     Various sequence methods are available, including the ability to explicitly
     mutate the key ordering.
     __contains__ tests:
     >>> d = OrderedDict(((1, 3),))
     >>> 1 in d
 …
     >>> 4 in d
     __getitem__ tests:
     >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[2]
 …
     Traceback (most recent call last):
     KeyError: 4
     __len__ tests:
     >>> len(OrderedDict())
     >>> len(OrderedDict(((1, 3), (3, 2), (2, 1))))
     get tests:
     >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
     >>> d.get(1)
 …
     >>> d
     OrderedDict([(1, 3), (3, 2), (2, 1)])
     has_key tests:
     >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
     >>> d.has_key(1)
 …
         Create a new ordered dictionary. Cannot init from a normal dict,
         nor from kwargs, since items order is undefined in those cases.
         If the ``strict`` keyword argument is ``True`` (``False`` is the
         default) then when doing slice assignment - the ``OrderedDict`` you are
         assigning from *must not* contain any keys in the remaining dict.
         >>> OrderedDict()
         OrderedDict([])
 …
         """
         Used for __repr__ and __str__
         >>> r1 = repr(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f'))))
         >>> r1
 …
         >>> d
         OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)])
         >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)), strict=True)
         >>> a[3] = 4
 …
         >>> a
         OrderedDict([(3, 4), (2, 3), (1, 2), (0, 1)])
         >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
         >>> d[:1] = 3
         Traceback (most recent call last):
         TypeError: slice assignment requires an OrderedDict
         >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
         >>> d[:1] = OrderedDict([(9, 8)])
 …
         """
         Implemented so that access to ``sequence`` raises a warning.
         >>> d = OrderedDict()
         >>> d.sequence
 …
         """
         To allow deepcopy to work with OrderedDict.
         >>> from copy import deepcopy
         >>> a = OrderedDict([(1, 1), (2, 2), (3, 3)])
 …
     def items(self):
         """
         ``items`` returns a list of tuples representing all the
+        ``items`` returns a list of tuples representing all the
         ``(key, value)`` pairs in the dictionary.
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.items()
 …
         """
         Return a list of keys in the ``OrderedDict``.
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.keys()
 …
         """
         Return a list of all the values in the OrderedDict.
         Optionally you can pass in a list of values, which will replace the
         current list. The value list must be the same len as the OrderedDict.
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.values()
 …
         """
         No dict.pop in Python 2.2, gotta reimplement it
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.pop(3)
 …
         """
         if len(args) > 1:
             raise TypeError, ('pop expected at most 2 arguments, got %s' %
+            raise TypeError('pop expected at most 2 arguments, got %s' %
                 (len(args) + 1))
         if key in self:
 …
         Delete and return an item specified by index, not a random one as in
         dict. The index is -1 by default (the last item).
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.popitem()
 …
         """
         Update from another OrderedDict or sequence of (key, value) pairs
         >>> d = OrderedDict(((1, 0), (0, 1)))
         >>> d.update(OrderedDict(((1, 3), (3, 2), (2, 1))))
 …
         """
         Rename the key for a given value, without modifying sequence order.
         For the case where new_key already exists this raise an exception,
         since if new_key exists, it is ambiguous as to what happens to the
         associated values, and the position of new_key in the sequence.
         >>> od = OrderedDict()
         >>> od['a'] = 1
 …
             raise ValueError("New key already exists: %r" % new_key)
         # rename sequence entry
         value = self[old_key]
+        value = self[old_key]
         old_idx = self._sequence.index(old_key)
         self._sequence[old_idx] = new_key
 …
         """
         This method allows you to set the items in the dict.
         It takes a list of tuples - of the same sort returned by the ``items``
         method.
         >>> d = OrderedDict()
         >>> d.setitems(((3, 1), (2, 3), (1, 2)))
 …
         replace the current set. This must contain the same set of keys, but
         need not be in the same order.
         If you pass in new keys that don't match, a ``KeyError`` will be
         raised.
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.keys()
 …
         You can pass in a list of values, which will replace the
         current list. The value list must be the same len as the OrderedDict.
         (Or a ``ValueError`` is raised.)
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.setvalues((1, 2, 3))
 …
         """
         Return the position of the specified key in the OrderedDict.
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.index(3)
 …
         """
         Takes ``index``, ``key``, and ``value`` as arguments.
         Sets ``key`` to ``value``, so that ``key`` is at position ``index`` in
         the OrderedDict.
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.insert(0, 4, 0)
 …
         """
         Reverse the order of the OrderedDict.
         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
         >>> d.reverse()
 …
         """
         Sort the key order in the OrderedDict.
         This method takes the same arguments as the ``list.sort`` method on
         your version of Python.
         >>> d = OrderedDict(((4, 1), (2, 2), (3, 3), (1, 4)))
         >>> d.sort()
 …
     """
     Custom object for accessing the keys of an OrderedDict.
     Can be called like the normal ``OrderedDict.keys`` method, but also
     supports indexing and sequence methods.
 …
         You cannot assign to keys, but you can do slice assignment to re-order
         them.
         You can only do slice assignment if the new set of keys is a reordering
         of the original set.
 …
     """
     Custom object for accessing the items of an OrderedDict.
     Can be called like the normal ``OrderedDict.items`` method, but also
     supports indexing and sequence methods.
 …
     """
     Custom object for accessing the values of an OrderedDict.
     Can be called like the normal ``OrderedDict.values`` method, but also
     supports indexing and sequence methods.
 …
         """
         Set the value at position i to value.
         You can only do slice assignment to values if you supply a sequence of
         equal length to the slice you are replacing.
 …
     Experimental version of OrderedDict that has a custom object for ``keys``,
     ``values``, and ``items``.
     These are callable sequence objects that work as methods, or can be
     manipulated directly as sequences.
     Test for ``keys``, ``items`` and ``values``.
     >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
     >>> d
 …
     >>> d
     SequenceOrderedDict([(1, 1), (2, 2), (3, 3)])
     >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
     >>> d

src/sas/sascalc/data_util/registry.py

r5a8cdbb	rdc8d1c2
101	101	extlist = [ext for ext in self.extensions() if path.endswith(ext)]
102	102	# Sort matching extensions by decreasing order of length
103		extlist.sort(~~lambda a,b: len(a)<len(b)~~)
	103	extlist.sort(key=len)
104	104	# Combine loaders for matching extensions into one big list
105	105	loaders = []

src/sas/sascalc/data_util/uncertainty.py

-                      r9a5097c
+                      r574adc7
 Uncertainty propagation class for arithmetic, log and exp.
 Based on scalars or numpy vectors, this class allows you to store and
+Based on scalars or numpy vectors, this class allows you to store and
 manipulate values+uncertainties, with propagation of gaussian error for
 addition, subtraction, multiplication, division, power, exp and log.
 Storage properties are determined by the numbers used to set the value
 and uncertainty.  Be sure to use floating point uncertainty vectors
+and uncertainty.  Be sure to use floating point uncertainty vectors
 for inplace operations since numpy does not do automatic type conversion.
 Normal operations can use mixed integer and floating point.  In place
 …
 import numpy as np
+import err1d
+from formatnum import format_uncertainty
+from .import err1d
+from .formatnum import format_uncertainty
 __all__ = ['Uncertainty']
 …
     # Make standard deviation available
     def _getdx(self): return np.sqrt(self.variance)
     def _setdx(self,dx):
+    def _setdx(self,dx):
         # Direct operation
         #    variance = dx**2
 …
     # Constructor
     def __init__(self, x, variance=None):
         self.x, self.variance = x, variance
+        self.x, self.variance = x, variance
     # Numpy array slicing operations
     def __len__(self):
+    def __len__(self):
         return len(self.x)
     def __getitem__(self,key):
+    def __getitem__(self,key):
         return Uncertainty(self.x[key],self.variance[key])
     def __setitem__(self,key,value):
 …
     def __idiv__(self, other): return self.__itruediv__(other)
     # Unary ops
     def __neg__(self):
 …
             return format_uncertainty(self.x,np.sqrt(self.variance))
         else:
             return [format_uncertainty(v,dv)
+            return [format_uncertainty(v,dv)
                     for v,dv in zip(self.x,np.sqrt(self.variance))]
     def __repr__(self):
 …
     z = a/4
     assert z.x == 5./4 and z.variance == 3./4**2
     # Reverse scalar operations
     z = 4+a
 …
     z = 4/a
     assert z.x == 4./5 and abs(z.variance - 3./5**4 * 4**2) < 1e-15
     # Power operations
     z = a**2
 …
     assert z.x == 5./4 and abs(z.variance - (3./5**2 + 2./4**2)*(5./4)**2) < 1e-15
     # ===== Inplace operations =====
+    # ===== Inplace operations =====
     # Scalar operations
     y = a+0; y += 4
 …
     assert (z.x == 5./4).all()
     assert (abs(z.variance - (3./5**2 + 2./4**2)*(5./4)**2) < 1e-15).all()
     # printing; note that sqrt(3) ~ 1.7
     assert str(Uncertainty(5,3)) == "5.0(17)"

src/sas/sascalc/dataloader/init.py

rb699768	r574adc7
1		from data_info import *
2		from manipulations import *
3		from readers import *
	1	from .data_info import *
	2	from .manipulations import *
	3	from .readers import *

src/sas/sascalc/dataloader/data_info.py

-                      rdeaa0c6
+                      r9e6aeaf
                 self.y_unit = '1/cm'
         except: # the data is not recognized/supported, and the user is notified
             raise(TypeError, 'data not recognized, check documentation for supported 1D data formats')
+            raise TypeError('data not recognized, check documentation for supported 1D data formats')
     def __str__(self):
 …
                 len(self.y) != len(other.y):
                 msg = "Unable to perform operation: data length are not equal"
                 raise ValueError, msg
+                raise ValueError(msg)
             # Here we could also extrapolate between data points
             TOLERANCE = 0.01
 …
                 if math.fabs((self.x[i] - other.x[i])/self.x[i]) > TOLERANCE:
                     msg = "Incompatible data sets: x-values do not match"
                     raise ValueError, msg
+                    raise ValueError(msg)
             # Check that the other data set has errors, otherwise
 …
         if not isinstance(other, Data1D):
             msg = "Unable to perform operation: different types of data set"
             raise ValueError, msg
+            raise ValueError(msg)
         return True
 …
         if len(self.detector) > 0:
             raise RuntimeError, "Data2D: Detector bank already filled at init"
+            raise RuntimeError("Data2D: Detector bank already filled at init")
     def __str__(self):
 …
                 len(self.qy_data) != len(other.qy_data):
                 msg = "Unable to perform operation: data length are not equal"
                 raise ValueError, msg
+                raise ValueError(msg)
             for ind in range(len(self.data)):
                 if math.fabs((self.qx_data[ind] - other.qx_data[ind])/self.qx_data[ind]) > TOLERANCE:
                     msg = "Incompatible data sets: qx-values do not match: %s %s" % (self.qx_data[ind], other.qx_data[ind])
                     raise ValueError, msg
+                    raise ValueError(msg)
                 if math.fabs((self.qy_data[ind] - other.qy_data[ind])/self.qy_data[ind]) > TOLERANCE:
                     msg = "Incompatible data sets: qy-values do not match: %s %s" % (self.qy_data[ind], other.qy_data[ind])
                     raise ValueError, msg
+                    raise ValueError(msg)
             # Check that the scales match
 …
         if not isinstance(other, Data2D):
             msg = "Unable to perform operation: different types of data set"
             raise ValueError, msg
+            raise ValueError(msg)
         return True

src/sas/sascalc/dataloader/file_reader_base_class.py

-                      rdeaa0c6
+                      r9e6aeaf
 import os
+import sys
 import re
 import logging
+from abc import abstractmethod
 import numpy as np
+from abc import abstractmethod
+from loader_exceptions import NoKnownLoaderException, FileContentsException,\
+from .loader_exceptions import NoKnownLoaderException, FileContentsException,\
     DataReaderException, DefaultReaderException
 from data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\
+from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\
     combine_data_info_with_plottable
 logger = logging.getLogger(__name__)
+if sys.version_info[0] < 3:
+    def decode(s):
+        return s
+else:
+    def decode(s):
+        return s.decode() if isinstance(s, bytes) else s
 class FileReader(object):
 …
         # Return a list of parsed entries that data_loader can manage
         return self.output
+    def nextline(self):
+        """
+        Returns the next line in the file as a string.
+        """
+        #return self.f_open.readline()
+        return decode(self.f_open.readline())
+    def nextlines(self):
+        """
+        Returns the next line in the file as a string.
+        """
+        for line in self.f_open:
+            #yield line
+            yield decode(line)
+    def readall(self):
+        """
+        Returns the entire file as a string.
+        """
+        #return self.f_open.read()
+        return decode(self.f_open.read())
     def handle_error_message(self, msg):

src/sas/sascalc/dataloader/loader.py

-                      rdcb91cf
+                      rdc8d1c2
 import time
 from zipfile import ZipFile
 from sas.sascalc.data_util.registry import ExtensionRegistry
 # Default readers are defined in the readers sub-module
 import readers
 from loader_exceptions import NoKnownLoaderException, FileContentsException,\
+from . import readers
+from .loader_exceptions import NoKnownLoaderException, FileContentsException,\
     DefaultReaderException
 from readers import ascii_reader
 from readers import cansas_reader
 from readers import cansas_reader_HDF5
+from .readers import ascii_reader
+from .readers import cansas_reader
+from .readers import cansas_reader_HDF5
 logger = logging.getLogger(__name__)
 …
         try:
             return super(Registry, self).load(path, format=format)
+        #except Exception: raise  # for debugging, don't use fallback loader
         except NoKnownLoaderException as nkl_e:
             pass  # Try the ASCII reader
 …
         extlist = [ext for ext in self.extensions() if path.endswith(ext)]
         # Sort matching extensions by decreasing order of length
         extlist.sort(lambda a, b: len(a) < len(b))
+        extlist.sort(key=len)
         # Combine loaders for matching extensions into one big list
         writers = []
 …
         # Raise an error if there are no matching extensions
         if len(writers) == 0:
             raise ValueError, "Unknown file type for " + path
+            raise ValueError("Unknown file type for " + path)
         # All done
         return writers
 …
             try:
                 return fn(path, data)
             except:
+            except Exception:
                 pass  # give other loaders a chance to succeed
         # If we get here it is because all loaders failed

src/sas/sascalc/dataloader/manipulations.py

r324e0bf	r574adc7
26	26
27	27	#from data_info import plottable_2D
28		from data_info import Data1D
	28	from .data_info import Data1D
29	29
30	30

src/sas/sascalc/dataloader/readers/init.py

r488f3a5	raaa801e
1	1	# Method to associate extensions to default readers
2		from associations import read_associations
	2	from .associations import read_associations

src/sas/sascalc/dataloader/readers/abs_reader.py

-                      rffb6474
+                      r1efbc190
 import logging
 import numpy as np
+from sas.sascalc.dataloader.file_reader_base_class import FileReader
 from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D, Data1D,\
     Detector
 from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\
     DefaultReaderException
+from sas.sascalc.data_util.nxsunit import Converter
+from ..file_reader_base_class import FileReader
+from ..data_info import DataInfo, plottable_1D, Data1D, Detector
+from ..loader_exceptions import FileContentsException, DefaultReaderException
 logger = logging.getLogger(__name__)
 …
     # List of allowed extensions
     ext = ['.abs']
     def get_file_contents(self):
         """
+        """
         Get the contents of the file
         :raise RuntimeError: when the file can't be opened
         :raise ValueError: when the length of the data vectors are inconsistent
         """
         buff = self.f_open.read()
+        buff = self.readall()
         filepath = self.f_open.name
         lines = buff.splitlines()
-        self.has_converter = True
-        try:
-            from sas.sascalc.data_util.nxsunit import Converter
-        except:
-            self.has_converter = False
         self.output = []
         self.current_datainfo = DataInfo()
 …
                 try:
                     value = float(line_toks[1])
+                    if self.has_converter and \
+                            self.current_datainfo.source.wavelength_unit != 'A':
+                    if self.current_datainfo.source.wavelength_unit != 'A':
                         conv = Converter('A')
                         self.current_datainfo.source.wavelength = conv(value,
 …
                 try:
                     value = float(line_toks[3])
                     if self.has_converter and detector.distance_unit != 'm':
+                    if detector.distance_unit != 'm':
                         conv = Converter('m')
                         detector.distance = conv(value,
 …
                     else:
                         detector.distance = value
                 except:
+                except Exception:
                     msg = "ABSReader cannot read SDD from %s" % filepath
                     self.current_datainfo.errors.append(msg)
 …
                 # Sample thickness in mm
                 try:
+                    value = float(line_toks[5][:-1])
+                    if self.has_converter and \
+                            self.current_datainfo.sample.thickness_unit != 'cm':
+                    # ABS writer adds 'C' with no space to the end of the
+                    # thickness column.  Remove it if it is there before
+                    # converting the thickness.
+                    if line_toks[5][-1] not in '012345679.':
+                        value = float(line_toks[5][:-1])
+                    else:
+                        value = float(line_toks[5])
+                    if self.current_datainfo.sample.thickness_unit != 'cm':
                         conv = Converter('cm')
                         self.current_datainfo.sample.thickness = conv(value,
 …
                 # Bin size
                 if self.has_converter and detector.pixel_size_unit != 'mm':
+                if detector.pixel_size_unit != 'mm':
                     conv = Converter('mm')
                     detector.pixel_size.x = conv(5.08,
 …
                 # Store beam center in distance units
                 # Det 640 x 640 mm
                 if self.has_converter and detector.beam_center_unit != 'mm':
+                if detector.beam_center_unit != 'mm':
                     conv = Converter('mm')
                     detector.beam_center.x = conv(center_x * 5.08,
                                      units=detector.beam_center_unit)
                     detector.beam_center.y = conv(center_y * 5.08,
                                     units=detector.beam_center_unit)
+                                     units=detector.beam_center_unit)
                 else:
                     detector.beam_center.x = center_x * 5.08

src/sas/sascalc/dataloader/readers/anton_paar_saxs_reader.py

rfafe52a	ra5bd87a
63	63	## Reinitialize the class when loading a new data file to reset all class variables
64	64	self.reset_state()
65		buff = self.~~f_open.read~~()
	65	buff = self.readall()
66	66	self.raw_data = buff.splitlines()
67	67	self.read_data()

src/sas/sascalc/dataloader/readers/ascii_reader.py

-                      r7b07fbe
+                      r9e6aeaf
         """
         buff = self.f_open.read()
+        buff = self.readall()
         filepath = self.f_open.name
         lines = buff.splitlines()
 …
                 # Reset # of lines of data candidates
                 candidate_lines = 0
         if not is_data:
             self.set_all_to_none()

src/sas/sascalc/dataloader/readers/associations.py

-                      rce8c7bd
+                      r574adc7
     """
     # For each FileType entry, get the associated reader and extension
     for ext, reader in settings.iteritems():
+    for ext, reader in settings.items():
         if reader is not None and ext is not None:
             # Associate the extension with a particular reader
 …
             # and remove the extra line below.
             try:
                 exec "import %s" % reader
                 exec "loader.associate_file_type('%s', %s)" % (ext.lower(),
                                                                 reader)
                 exec "loader.associate_file_type('%s', %s)" % (ext.upper(),
                                                                 reader)
+                exec("from . import %s" % reader)
+                exec("loader.associate_file_type('%s', %s)"
+                     % (ext.lower(), reader))
+                exec("loader.associate_file_type('%s', %s)"
+                     % (ext.upper(), reader))
             except:
                 msg = "read_associations: skipping association"

src/sas/sascalc/dataloader/readers/cansas_reader.py

-                      r62160509
+                      r9e6aeaf
 import logging
-import numpy as np
 import os
 import sys
 import datetime
 import inspect
+# For saving individual sections of data
+from sas.sascalc.dataloader.data_info import Data1D, Data2D, DataInfo, \
+    plottable_1D, plottable_2D
+from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, \
+    Detector, Process, Aperture
+from sas.sascalc.dataloader.data_info import \
+    combine_data_info_with_plottable as combine_data
+import sas.sascalc.dataloader.readers.xml_reader as xml_reader
+from sas.sascalc.dataloader.readers.xml_reader import XMLreader
+from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants, CurrentLevel
+from sas.sascalc.dataloader.loader_exceptions import FileContentsException, \
+    DefaultReaderException, DataReaderException
+import numpy as np
 # The following 2 imports *ARE* used. Do not remove either.
 …
 from lxml import etree
+from sas.sascalc.data_util.nxsunit import Converter
+# For saving individual sections of data
+from ..data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D, \
+    Collimation, TransmissionSpectrum, Detector, Process, Aperture, \
+    combine_data_info_with_plottable as combine_data
+from ..loader_exceptions import FileContentsException, DefaultReaderException, \
+    DataReaderException
+from . import xml_reader
+from .xml_reader import XMLreader
+from .cansas_constants import CansasConstants, CurrentLevel
 logger = logging.getLogger(__name__)
 …
 INVALID_XML = "\n\nThe loaded xml file, {0} does not fully meet the CanSAS v1.x specification. SasView loaded " + \
               "as much of the data as possible.\n\n"
-HAS_CONVERTER = True
-try:
-    from sas.sascalc.data_util.nxsunit import Converter
-except ImportError:
-    HAS_CONVERTER = False
 CONSTANTS = CansasConstants()
 …
                 raise fc_exc
         except Exception as e: # Convert all other exceptions to FileContentsExceptions
             raise FileContentsException(e.message)
+            raise FileContentsException(str(e))
         finally:
             if not self.f_open.closed:
 …
                 else:
                     save_in = "current_datainfo"
+                exec "default_unit = self.{0}.{1}".format(save_in, unitname)
+                if local_unit and default_unit and local_unit.lower() != default_unit.lower() \
+                        and local_unit.lower() != "none":
+                    if HAS_CONVERTER == True:
+                        # Check local units - bad units raise KeyError
+                        data_conv_q = Converter(local_unit)
+                        value_unit = default_unit
+                        node_value = data_conv_q(node_value, units=default_unit)
+                    else:
+                        value_unit = local_unit
+                        err_msg = "Unit converter is not available.\n"
+                default_unit = getattrchain(self, '.'.join((save_in, unitname)))
+                if (local_unit and default_unit
+                        and local_unit.lower() != default_unit.lower()
+                        and local_unit.lower() != "none"):
+                    # Check local units - bad units raise KeyError
+                    #print("loading", tagname, node_value, local_unit, default_unit)
+                    data_conv_q = Converter(local_unit)
+                    value_unit = default_unit
+                    node_value = data_conv_q(node_value, units=default_unit)
                 else:
                     value_unit = local_unit
 …
                     err_msg += "expecting [{0}]".format(default_unit)
                 value_unit = local_unit
             except:
+            except Exception:
                 err_msg = "CanSAS reader: unknown error converting "
                 err_msg += "\"{0}\" unit [{1}]"
 …
         doc, _ = self._to_xml_doc(datainfo)
         # Write the file
         file_ref = open(filename, 'w')
+        file_ref = open(filename, 'wb')
         if self.encoding is None:
             self.encoding = "UTF-8"
 …
         point = self.create_element("Idata")
         node.append(point)
         qx = ','.join([str(datainfo.qx_data[i]) for i in xrange(len(datainfo.qx_data))])
         qy = ','.join([str(datainfo.qy_data[i]) for i in xrange(len(datainfo.qy_data))])
         intensity = ','.join([str(datainfo.data[i]) for i in xrange(len(datainfo.data))])
+        qx = ','.join(str(v) for v in datainfo.qx_data)
+        qy = ','.join(str(v) for v in datainfo.qy_data)
+        intensity = ','.join(str(v) for v in datainfo.data)
         self.write_node(point, "Qx", qx,
 …
                         {'unit': datainfo._zunit})
         if datainfo.err_data is not None:
+            err = ','.join([str(datainfo.err_data[i]) for i in
+                            xrange(len(datainfo.err_data))])
+            err = ','.join(str(v) for v in datainfo.err_data)
             self.write_node(point, "Idev", err,
                             {'unit': datainfo._zunit})
         if datainfo.dqy_data is not None:
+            dqy = ','.join([str(datainfo.dqy_data[i]) for i in
+                            xrange(len(datainfo.dqy_data))])
+            dqy = ','.join(str(v) for v in datainfo.dqy_data)
             self.write_node(point, "Qydev", dqy,
                             {'unit': datainfo._yunit})
         if datainfo.dqx_data is not None:
+            dqx = ','.join([str(datainfo.dqx_data[i]) for i in
+                            xrange(len(datainfo.dqx_data))])
+            dqx = ','.join(str(v) for v in datainfo.dqx_data)
             self.write_node(point, "Qxdev", dqx,
                             {'unit': datainfo._xunit})
         if datainfo.mask is not None:
+            mask = ','.join(
+                ["1" if datainfo.mask[i] else "0"
+                 for i in xrange(len(datainfo.mask))])
+            mask = ','.join("1" if v else "0" for v in datainfo.mask)
             self.write_node(point, "Mask", mask)
 …
         try:
             value = float(entry.text)
         except:
+        except ValueError:
             value = None
 …
             if units is not None:
                 toks = variable.split('.')
                 local_unit = None
                 exec "local_unit = storage.%s_unit" % toks[0]
+                # TODO: why split() when accessing unit, but not when setting value?
+                local_unit = getattr(storage, toks[0]+"_unit")
                 if local_unit is not None and units.lower() != local_unit.lower():
+                    if HAS_CONVERTER == True:
+                        try:
+                            conv = Converter(units)
+                            exec "storage.%s = %g" % \
+                                (variable, conv(value, units=local_unit))
+                        except:
+                            _, exc_value, _ = sys.exc_info()
+                            err_mess = "CanSAS reader: could not convert"
+                            err_mess += " %s unit [%s]; expecting [%s]\n  %s" \
+                                % (variable, units, local_unit, exc_value)
+                            self.errors.add(err_mess)
+                            if optional:
+                                logger.info(err_mess)
+                            else:
+                                raise ValueError, err_mess
+                    else:
+                        err_mess = "CanSAS reader: unrecognized %s unit [%s];"\
+                        % (variable, units)
+                        err_mess += " expecting [%s]" % local_unit
+                    try:
+                        conv = Converter(units)
+                        setattrchain(storage, variable, conv(value, units=local_unit))
+                    except Exception:
+                        _, exc_value, _ = sys.exc_info()
+                        err_mess = "CanSAS reader: could not convert"
+                        err_mess += " %s unit [%s]; expecting [%s]\n  %s" \
+                            % (variable, units, local_unit, exc_value)
                         self.errors.add(err_mess)
                         if optional:
                             logger.info(err_mess)
                         else:
                             raise ValueError, err_mess
+                            raise ValueError(err_mess)
                 else:
                     exec "storage.%s = value" % variable
+                    setattrchain(storage, variable, value)
             else:
                 exec "storage.%s = value" % variable
+                setattrchain(storage, variable, value)
     # DO NOT REMOVE - used in saving and loading panel states.
 …
         entry = get_content(location, node)
         if entry is not None and entry.text is not None:
             exec "storage.%s = entry.text.strip()" % variable
+            setattrchain(storage, variable, entry.text.strip())
 # DO NOT REMOVE Called by outside packages:
 …
         return True
     return False
+def getattrchain(obj, chain, default=None):
+    """Like getattr, but the attr may contain multiple parts separated by '.'"""
+    for part in chain.split('.'):
+        if hasattr(obj, part):
+            obj = getattr(obj, part, None)
+        else:
+            return default
+    return obj
+def setattrchain(obj, chain, value):
+    """Like setattr, but the attr may contain multiple parts separated by '.'"""
+    parts = list(chain.split('.'))
+    for part in parts[-1]:
+        obj = getattr(obj, part, None)
+        if obj is None:
+            raise ValueError("missing parent object "+part)
+    setattr(obj, value)

src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

-                      rcd57c7d4
+                      r7b50f14
 import sys
 from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\
+from ..data_info import plottable_1D, plottable_2D,\
     Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \
     TransmissionSpectrum, Detector
+from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable
+from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DefaultReaderException
+from sas.sascalc.dataloader.file_reader_base_class import FileReader
+from ..data_info import combine_data_info_with_plottable
+from ..loader_exceptions import FileContentsException, DefaultReaderException
+from ..file_reader_base_class import FileReader, decode
+def h5attr(node, key, default=None):
+    return decode(node.attrs.get(key, default))
 class Reader(FileReader):
 …
             # Get all information for the current key
             value = data.get(key)
+            if value.attrs.get(u'canSAS_class') is not None:
+                class_name = value.attrs.get(u'canSAS_class')
+            else:
+                class_name = value.attrs.get(u'NX_class')
+            class_name = h5attr(value, u'canSAS_class')
+            if class_name is None:
+                class_name = h5attr(value, u'NX_class')
             if class_name is not None:
                 class_prog = re.compile(class_name)
 …
                 for data_point in data_set:
+                    if data_point.dtype.char == 'S':
+                        data_point = decode(bytes(data_point))
                     # Top Level Meta Data
                     if key == u'definition':
 …
                         self.current_datainfo.run.append(data_point)
                         try:
                             run_name = value.attrs['name']
+                            run_name = h5attr(value, 'name')
                             run_dict = {data_point: run_name}
                             self.current_datainfo.run_name = run_dict
                         except:
+                        except Exception:
                             pass
                     elif key == u'title':
 …
         :return: unit for the value passed to the method
         """
         unit = value.attrs.get(u'units')
+        unit = h5attr(value, u'units')
         if unit is None:
             unit = value.attrs.get(u'unit')
+            unit = h5attr(value, u'unit')
         # Convert the unit formats
         if unit == "1/A":

src/sas/sascalc/dataloader/readers/danse_reader.py

-                      ra78a02f
+                      raf3e9f5
 import math
 import os
+import logging
 import numpy as np
+import logging
 from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector
 from sas.sascalc.dataloader.manipulations import reader2D_converter
 from sas.sascalc.dataloader.file_reader_base_class import FileReader
 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException
+from ..data_info import plottable_2D, DataInfo, Detector
+from ..manipulations import reader2D_converter
+from ..file_reader_base_class import FileReader
+from ..loader_exceptions import FileContentsException, DataReaderException
 logger = logging.getLogger(__name__)
 …
         data_start_line = 1
         while read_on:
             line = self.f_open.readline()
+            line = self.nextline()
             data_start_line += 1
             if line.find("DATA:") >= 0:
 …
             raise FileContentsException(msg)
         for line_num, data_str in enumerate(self.f_open.readlines()):
+        for line_num, data_str in enumerate(self.nextlines()):
             toks = data_str.split()
             try:

src/sas/sascalc/dataloader/readers/red2d_reader.py

-                      r2f85af7
+                      rc8321cfc
 ######################################################################
 import os
+import math
+import time
 import numpy as np
+import math
+from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector
+from sas.sascalc.dataloader.file_reader_base_class import FileReader
+from sas.sascalc.dataloader.loader_exceptions import FileContentsException
+# Look for unit converter
+has_converter = True
+try:
+    from sas.sascalc.data_util.nxsunit import Converter
+except:
+    has_converter = False
+from sas.sascalc.data_util.nxsunit import Converter
+from ..data_info import plottable_2D, DataInfo, Detector
+from ..file_reader_base_class import FileReader
+from ..loader_exceptions import FileContentsException
 …
     try:
         return float(x_point)
     except:
+    except Exception:
         return 0
 …
         :param data: data2D
         """
-        import time
         # Write the file
         try:
 …
     def get_file_contents(self):
         # Read file
         buf = self.f_open.read()
+        buf = self.readall()
         self.f_open.close()
         # Instantiate data object
 …
                 try:
                     wavelength = float(line_toks[1])
+                    # Units
+                    if has_converter == True and \
+                    self.current_datainfo.source.wavelength_unit != 'A':
+                    # Wavelength is stored in angstroms; convert if necessary
+                    if self.current_datainfo.source.wavelength_unit != 'A':
                         conv = Converter('A')
                         wavelength = conv(wavelength,
                                           units=self.current_datainfo.source.wavelength_unit)
+                except:
+                    #Not required
+                    pass
+                # Distance in mm
+                except Exception:
+                    pass  # Not required
                 try:
                     distance = float(line_toks[3])
                     # Units
                     if has_converter == True and self.current_datainfo.detector[0].distance_unit != 'm':
+                    # Distance is stored in meters; convert if necessary
+                    if self.current_datainfo.detector[0].distance_unit != 'm':
                         conv = Converter('m')
                         distance = conv(distance,
                             units=self.current_datainfo.detector[0].distance_unit)
+                except:
+                    #Not required
+                    pass
+                # Distance in meters
+                except Exception:
+                    pass  # Not required
                 try:
                     transmission = float(line_toks[4])
+                except:
+                    #Not required
+                    pass
+                except Exception:
+                    pass  # Not required
             if line.count("LAMBDA") > 0:
 …
             ## Read and get data.
             if data_started == True:
+            if data_started:
                 line_toks = line.split()
                 if len(line_toks) == 0:
 …
                 col_num = len(line_toks)
                 break
         # Make numpy array to remove header lines using index
         lines_array = np.array(lines)
 …
         # Change it(string) into float
         #data_list = map(float,data_list)
         data_list1 = map(check_point, data_list)
+        data_list1 = list(map(check_point, data_list))
         # numpy array form
 …
         try:
             data_point = data_array.reshape(row_num, col_num).transpose()
         except:
+        except Exception:
             msg = "red2d_reader can't read this file: Incorrect number of data points provided."
             raise FileContentsException(msg)
 …
         # Units of axes
         self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}')
         self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}')
         self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}")
+        self.current_dataset.xaxis(r"\rm{Q_{x}}", 'A^{-1}')
+        self.current_dataset.yaxis(r"\rm{Q_{y}}", 'A^{-1}')
+        self.current_dataset.zaxis(r"\rm{Intensity}", "cm^{-1}")
         # Store loading process information

src/sas/sascalc/dataloader/readers/sesans_reader.py

-                      rbe43448
+                      r849094a
     Jurrian Bakker
 """
+import os
 import numpy as np
+import os
 from sas.sascalc.dataloader.file_reader_base_class import FileReader
 from sas.sascalc.dataloader.data_info import plottable_1D, DataInfo
 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException
+from ..file_reader_base_class import FileReader
+from ..data_info import plottable_1D, DataInfo
+from ..loader_exceptions import FileContentsException, DataReaderException
 # Check whether we have a converter available
 …
         self.output = []
         line = self.f_open.readline()
+        line = self.nextline()
         params = {}
         while not line.startswith("BEGIN_DATA"):
 …
             if len(terms) >= 2:
                 params[terms[0]] = " ".join(terms[1:])
             line = self.f_open.readline()
+            line = self.nextline()
         self.params = params
 …
                                "handled by other software.")
         headers = self.f_open.readline().split()
+        headers = self.nextline().split()
         self._insist_header(headers, "SpinEchoLength")

src/sas/sascalc/dataloader/readers/tiff_reader.py

-                      r959eb01
+                      r574adc7
 #This software was developed by the University of Tennessee as part of the
 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
 #project funded by the US National Science Foundation.
+#project funded by the US National Science Foundation.
 #See the license text in license.txt
 #copyright 2008, University of Tennessee
 …
     ## Extension
     ext = ['.tif', '.tiff']
     def read(self, filename=None):
         """
         Open and read the data in a file
         :param file: path of the file
         """
 …
         except:
             msg = "tiff_reader: could not load file. Missing Image module."
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         # Instantiate data object
         output = Data2D()
         output.filename = os.path.basename(filename)
         # Read in the image
         try:
             im = Image.open(filename)
         except:
             raise  RuntimeError, "cannot open %s"%(filename)
+            raise  RuntimeError("cannot open %s"%(filename))
         data = im.getdata()
 …
         output.err_data = np.zeros([im.size[0], im.size[1]])
         output.mask = np.ones([im.size[0], im.size[1]], dtype=bool)
         # Initialize
         x_vals = []
 …
         for i_x in range(im.size[0]):
             x_vals.append(i_x)
         itot = 0
         for i_y in range(im.size[1]):
 …
                 logger.error("tiff_reader: had to skip a non-float point")
                 continue
             # Get bin number
             if math.fmod(itot, im.size[0]) == 0:
 …
             else:
                 i_x += 1
             output.data[im.size[1] - 1 - i_y][i_x] = value
             itot += 1
         output.xbins = im.size[0]
         output.ybins = im.size[1]
 …
         output.ymin = 0
         output.ymax = im.size[0] - 1
         # Store loading process information
         output.meta_data['loader'] = self.type_name

src/sas/sascalc/dataloader/readers/xml_reader.py

-                      rcd57c7d4
+                      r7b50f14
 import logging
 from lxml import etree
 from lxml.builder import E
+from sas.sascalc.dataloader.file_reader_base_class import FileReader
+from ..file_reader_base_class import FileReader, decode
 logger = logging.getLogger(__name__)
 …
         Converts an etree element into a string
         """
         return etree.tostring(elem, pretty_print=pretty_print, \
                               encoding=encoding)
+        return decode(etree.tostring(elem, pretty_print=pretty_print,
+                                     encoding=encoding))
     def break_processing_instructions(self, string, dic):

src/sas/sascalc/file_converter/c_ext/bsl_loader.c

-                      r2ab9c432
+                      rd5aeaa3
 #include <Python.h>
 //#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #include <numpy/arrayobject.h>
 #include <stdio.h>
 …
 static void CLoader_dealloc(CLoader *self) {
     free(self->params.filename);
     self->ob_type->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
+}
 …
 static PyTypeObject CLoaderType = {
+    PyObject_HEAD_INIT(NULL)
+,                         /*ob_size*/
+    //PyObject_HEAD_INIT(NULL)
+    //0,                         /*ob_size*/
+    PyVarObject_HEAD_INIT(NULL, 0)
     "CLoader",             /*tp_name*/
     sizeof(CLoader),             /*tp_basicsize*/
 …
 };
+PyMODINIT_FUNC
+initbsl_loader(void)
+/**
+ * Function used to add the model class to a module
+ * @param module: module to add the class to
+ */
+void addCLoader(PyObject *module)
+{
-    PyObject *module;
-    module = Py_InitModule("bsl_loader", NULL);
-    import_array();
     if (PyType_Ready(&CLoaderType) < 0)
         return;
     Py_INCREF(&CLoaderType);
     PyModule_AddObject(module, "CLoader", (PyObject *)&CLoaderType);
+}
+#define MODULE_DOC "C module for loading bsl."
+#define MODULE_NAME "bsl_loader"
+#define MODULE_INIT2 initbsl_loader
+#define MODULE_INIT3 PyInit_bsl_loader
+#define MODULE_METHODS module_methods
+/* ==== boilerplate python 2/3 interface bootstrap ==== */
+#if defined(WIN32) && !defined(__MINGW32__)
+    #define DLL_EXPORT __declspec(dllexport)
+#else
+    #define DLL_EXPORT
+#endif
+#if PY_MAJOR_VERSION >= 3
+  static PyMethodDef module_methods[] = {
+      {NULL}
+  };
+  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT3(void)
+  {
+    static struct PyModuleDef moduledef = {
+      PyModuleDef_HEAD_INIT,
+      MODULE_NAME,         /* m_name */
+      MODULE_DOC,          /* m_doc */
+      -1,                  /* m_size */
+      MODULE_METHODS,      /* m_methods */
+      NULL,                /* m_reload */
+      NULL,                /* m_traverse */
+      NULL,                /* m_clear */
+      NULL,                /* m_free */
+    };
+    PyObject* m = PyModule_Create(&moduledef);
+    import_array();
+    addCLoader(m);
+    return m;
+  }
+#else /* !PY_MAJOR_VERSION >= 3 */
+  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT2(void)
+  {
+    PyObject* m = Py_InitModule(MODULE_NAME, NULL);
+    import_array();
+    addCLoader(m);
+  }
+#endif /* !PY_MAJOR_VERSION >= 3 */

src/sas/sascalc/file_converter/cansas_writer.py

r7432acb	r574adc7
32	32	valid_class = all([issubclass(data.__class__, Data1D) for data in frame_data])
33	33	if not valid_class:
34		raise RuntimeError, ("The cansas writer expects an array of "
	34	raise RuntimeError("The cansas writer expects an array of "
35	35	"Data1D instances")
36	36

src/sas/sascalc/file_converter/nxcansas_writer.py

r5e906207	r574adc7
166	166	'wavelength_max': 'wavelength_max',
167	167	'wavelength_spread': 'incident_wavelength_spread' }
168		for sasname, nxname in wavelength_keys.ite~~rite~~ms():
	168	for sasname, nxname in wavelength_keys.items():
169	169	value = getattr(data_info.source, sasname)
170	170	units = getattr(data_info.source, sasname + '_unit')

src/sas/sascalc/fit/AbstractFitEngine.py

r50fcb09	r574adc7
251	251	msg = "FitData1D: invalid error array "
252	252	msg += "%d <> %d" % (np.shape(self.dy), np.size(fx))
253		raise RuntimeError~~, msg~~
	253	raise RuntimeError(msg)
254	254	return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
255	255

src/sas/sascalc/fit/Loader.py

-                      ra1b8fee
+                      r574adc7
         self.dy = dy
         self.filename = None
     def set_filename(self, path=None):
         """
         Store path into a variable.If the user doesn't give
+        Store path into a variable.If the user doesn't give
         a path as a parameter a pop-up
         window appears to select the file.
         :param path: the path given by the user
         """
         self.filename = path
     def get_filename(self):
         """ return the file's path"""
         return self.filename
     def set_values(self):
         """ Store the values loaded from file in local variables"""
 …
             self.x = []
             self.y = []
             self.dx = []
+            self.dx = []
             self.dy = []
             for line in lines:
 …
                     y = float(toks[1])
                     dy = float(toks[2])
                     self.x.append(x)
                     self.y.append(y)
 …
             # Sanity check
             if not len(self.x) == len(self.dx):
                 raise ValueError, "x and dx have different length"
+                raise ValueError("x and dx have different length")
             if not len(self.y) == len(self.dy):
                 raise ValueError, "y and dy have different length"
+                raise ValueError("y and dy have different length")
     def get_values(self):
         """ Return x, y, dx, dy"""
         return self.x, self.y, self.dx, self.dy
     def load_data(self, data):
         """ Return plottable"""
 …
         #Load its View class
         #plottable.reset_view()
 if __name__ == "__main__":
+if __name__ == "__main__":
     load = Load()
     load.set_filename("testdata_line.txt")
     print(load.get_filename())
+    print(load.get_filename())
     load.set_values()
     print(load.get_values())

src/sas/sascalc/fit/MultiplicationModel.py

-                      r7432acb
+                      r574adc7
         """
         ##set dispersion only from p_model
         for name , value in self.p_model.dispersion.iteritems():
+        for name , value in self.p_model.dispersion.items():
             self.dispersion[name] = value
 …
         """
         for name , value in self.p_model.params.iteritems():
+        for name , value in self.p_model.params.items():
             if not name in self.params.keys() and name not in self.excluded_params:
                 self.params[name] = value
         for name , value in self.s_model.params.iteritems():
+        for name , value in self.s_model.params.items():
             #Remove the radius_effective from the (P*S) model parameters.
             if not name in self.params.keys() and name not in self.excluded_params:
 …
         this model's details
         """
         for name, detail in self.p_model.details.iteritems():
+        for name, detail in self.p_model.details.items():
             if name not in self.excluded_params:
                 self.details[name] = detail
         for name , detail in self.s_model.details.iteritems():
+        for name , detail in self.s_model.details.items():
             if not name in self.details.keys() or name not in self.exluded_params:
                 self.details[name] = detail
 …
                     return
         raise ValueError, "Model does not contain parameter %s" % name
+        raise ValueError("Model does not contain parameter %s" % name)

src/sas/sascalc/fit/expression.py

-                      ra1b8fee
+                      r574adc7
     occur multiple times.  The return value is a set with the elements in
     no particular order.
     This is the first step in computing a dependency graph.
     """
 …
         offset = end
     pieces.append(expr[offset:])
     # Join the pieces and return them
     return "".join(pieces)
 …
     """
     Returns a list of pair-wise dependencies from the parameter expressions.
     For example, if p3 = p1+p2, then find_dependencies([p1,p2,p3]) will
     return [(p3,p1),(p3,p2)].  For base expressions without dependencies,
 …
     """
     Find the parameter substitution we need so that expressions can
     be evaluated without having to traverse a chain of
+    be evaluated without having to traverse a chain of
     model.layer.parameter.value
     """
 …
     return definition, substitution
 def no_constraints():
+def no_constraints():
     """
     This parameter set has no constraints between the parameters.
 …
     Parameter names are assumed to contain only _.a-zA-Z0-9#[]
     Both names are provided for inverse functions, e.g., acos and arccos.
     Should try running the function to identify syntax errors before
     running it in a fit.
     Use help(fn) to see the code generated for the returned function fn.
     dis.dis(fn) will show the corresponding python vm instructions.
 …
         if independent == emptyset:
             cycleset = ", ".join(str(s) for s in left)
             raise ValueError,"Cyclic dependencies amongst %s"%cycleset
+            raise ValueError("Cyclic dependencies amongst %s"%cycleset)
         # The possibly resolvable items are those that depend on the independents
 …
         n.sort()
         items = list(items); items.sort()
         raise Exception,"%s expect %s to contain %s for %s"%(msg,n,items,pairs)
+        raise ValueError("%s expect %s to contain %s for %s"%(msg,n,items,pairs))
     for lo,hi in pairs:
         if lo in n and hi in n and n.index(lo) >= n.index(hi):
             raise Exception,"%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs)
+            raise ValueError("%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs))
 def test_deps():
 …
     # Cycle test
     pairs = [(1,4),(4,3),(4,5),(5,1)]
+    try: n = order_dependencies(pairs)
+    except ValueError: pass
+    else: raise Exception,"test3 expect ValueError exception for %s"%(pairs,)
+    try:
+        n = order_dependencies(pairs)
+    except ValueError:
+        pass
+    else:
+        raise ValueError("test3 expect ValueError exception for %s"%(pairs,))
     # large test for gross speed check
 …
     import inspect, dis
     import math
     symtab = {'a.b.x':1, 'a.c':2, 'a.b':3, 'b.x':4}
     expr = 'a.b.x + sin(4*pi*a.c) + a.b.x/a.b'
     # Check symbol lookup
     assert _symbols(expr, symtab) == set([1,2,3])
 …
     expected = 2*math.pi*math.sin(5/.1875) + 6
     assert p2.value == expected,"Value was %s, not %s"%(p2.value,expected)
     # Check empty dependency set doesn't crash
     fn = compile_constraints(*world(p1,p3))
 …
     fn()
     assert p5.value == 2.07,"Value for %s was %s"%(p5.expression,p5.value)
     # Verify that we capture invalid expressions
     for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',
+    for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',
                  'piddle',
                  '5; import sys; print "p0wned"',

src/sas/sascalc/fit/pagestate.py

-                      r0315b63
+                      r9e6aeaf
         if len(self.disp_obj_dict) > 0:
             for k, v in self.disp_obj_dict.iteritems():
+            for k, v in self.disp_obj_dict.items():
                 obj.disp_obj_dict[k] = v
         if len(self.disp_cb_dict) > 0:
             for k, v in self.disp_cb_dict.iteritems():
+            for k, v in self.disp_cb_dict.items():
                 obj.disp_cb_dict[k] = v
         if len(self.values) > 0:
             for k, v in self.values.iteritems():
+            for k, v in self.values.items():
                 obj.values[k] = v
         if len(self.weights) > 0:
             for k, v in self.weights.iteritems():
+            for k, v in self.weights.items():
                 obj.weights[k] = v
         obj.enable_smearer = copy.deepcopy(self.enable_smearer)
 …
         obj.version = copy.deepcopy(self.version)
         for name, state in self.saved_states.iteritems():
+        for name, state in self.saved_states.items():
             copy_name = copy.deepcopy(name)
             copy_state = state.clone()
 …
         """
         p_map = []
         for name, info in params.iteritems():
+        for name, info in params.items():
             if ".fittable" in name or ".std" in name or ".upper" in name or \
                             ".lower" in name or ".units" in name:
 …
             formfactor, str_params = convert.convert_model(
                 self.formfactorcombobox, str_pars, False, self.version)
             for key, value in str_params.iteritems():
+            for key, value in str_params.items():
                 params[key] = value
 …
             element = newdoc.createElement(item[0])
             value_list = getattr(self, item[1])
             for key, value in value_list.iteritems():
+            for key, value in value_list.items():
                 sub_element = newdoc.createElement(key)
                 sub_element.setAttribute('name', str(key))
 …
             element = newdoc.createElement(tagname)
             value_list = getattr(self, varname)
             for key, value in value_list.iteritems():
+            for key, value in value_list.items():
                 sub_element = newdoc.createElement(key)
                 sub_element.setAttribute('name', str(key))
 …
             msg = "PageState no longer supports non-CanSAS"
             msg += " format for fitting files"
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         if node.get('version'):
 …
             else:
                 self.call_back(format=ext)
                 raise RuntimeError, "%s is not a file" % path
+                raise RuntimeError("%s is not a file" % path)
             # Return output consistent with the loader's api

src/sas/sascalc/fit/pluginmodel.py

-                      r5213d22
+                      r574adc7
             return self.function(x_val)*self.function(y_val)
         elif x.__class__.__name__ == 'tuple':
             raise ValueError, "Tuples are not allowed as input to BaseComponent models"
+            raise ValueError("Tuples are not allowed as input to BaseComponent models")
         else:
             return self.function(x)
 …
             return self.function(x[0])*self.function(x[1])
         elif x.__class__.__name__ == 'tuple':
             raise ValueError, "Tuples are not allowed as input to BaseComponent models"
+            raise ValueError("Tuples are not allowed as input to BaseComponent models")
         else:
             return self.function(x)

src/sas/sascalc/invariant/invariant.py

-                      rb1f20d1
+                      r574adc7
         if not issubclass(data.__class__, LoaderData1D):
             #Process only data that inherited from DataLoader.Data_info.Data1D
             raise ValueError, "Data must be of type DataLoader.Data1D"
+            raise ValueError("Data must be of type DataLoader.Data1D")
         #from copy import deepcopy
         new_data = (self._scale * data) - self._background
 …
             msg = "Length x and y must be equal"
             msg += " and greater than 1; got x=%s, y=%s" % (len(data.x), len(data.y))
             raise ValueError, msg
+            raise ValueError(msg)
         else:
             # Take care of smeared data
 …
                 #iterate between for element different
                 #from the first and the last
                 for i in xrange(1, n - 1):
+                for i in range(1, n - 1):
                     dxi = (data.x[i + 1] - data.x[i - 1]) / 2
                     total += gx[i] * data.y[i] * dxi
 …
             msg = "Length of data.x and data.y must be equal"
             msg += " and greater than 1; got x=%s, y=%s" % (len(data.x), len(data.y))
             raise ValueError, msg
+            raise ValueError(msg)
         else:
             #Create error for data without dy error
 …
                 #iterate between for element different
                 #from the first and the last
                 for i in xrange(1, n - 1):
+                for i in range(1, n - 1):
                     dxi = (data.x[i + 1] - data.x[i - 1]) / 2
                     total += (gx[i] * dy[i] * dxi) ** 2
 …
         range = range.lower()
         if range not in ['high', 'low']:
             raise ValueError, "Extrapolation range should be 'high' or 'low'"
+            raise ValueError("Extrapolation range should be 'high' or 'low'")
         function = function.lower()
         if function not in ['power_law', 'guinier']:
             msg = "Extrapolation function should be 'guinier' or 'power_law'"
             raise ValueError, msg
+            raise ValueError(msg)
         if range == 'high':
             if function != 'power_law':
                 msg = "Extrapolation only allows a power law at high Q"
                 raise ValueError, msg
+                raise ValueError(msg)
             self._high_extrapolation_npts = npts
             self._high_extrapolation_power = power
 …
         """
         if contrast <= 0:
             raise ValueError, "The contrast parameter must be greater than zero"
+            raise ValueError("The contrast parameter must be greater than zero")
         # Make sure Q star is up to date
 …
         if self._qstar <= 0:
             msg = "Invalid invariant: Invariant Q* must be greater than zero"
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         # Compute intermediate constant
 …
         if discrim < 0:
             msg = "Could not compute the volume fraction: negative discriminant"
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         elif discrim == 0:
             return 1 / 2
 …
                 return volume2
             msg = "Could not compute the volume fraction: inconsistent results"
             raise RuntimeError, msg
+            raise RuntimeError(msg)
     def get_qstar_with_error(self, extrapolation=None):

src/sas/sascalc/pr/c_extensions/Cinvertor.c

-                      rcb62bd5
+                      rd04ac05
     invertor_dealloc(&(self->params));
     self->ob_type->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
 …
 static PyTypeObject CinvertorType = {
+    PyObject_HEAD_INIT(NULL)
+,                         /*ob_size*/
+    //PyObject_HEAD_INIT(NULL)
+    //0,                         /*ob_size*/
+    PyVarObject_HEAD_INIT(NULL, 0)
     "Cinvertor",             /*tp_name*/
     sizeof(Cinvertor),             /*tp_basicsize*/
 …
+#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
+#define PyMODINIT_FUNC void
+#define MODULE_DOC "C extension module for inversion to P(r)."
+#define MODULE_NAME "pr_inversion"
+#define MODULE_INIT2 initpr_inversion
+#define MODULE_INIT3 PyInit_pr_inversion
+#define MODULE_METHODS module_methods
+/* ==== boilerplate python 2/3 interface bootstrap ==== */
+#if defined(WIN32) && !defined(__MINGW32__)
+    #define DLL_EXPORT __declspec(dllexport)
+#else
+    #define DLL_EXPORT
 #endif
+PyMODINIT_FUNC
+initpr_inversion(void)
+{
+    PyObject* m;
+    m = Py_InitModule3("pr_inversion", module_methods,
+                       "C extension module for inversion to P(r).");
+    addCinvertor(m);
+}
+#if PY_MAJOR_VERSION >= 3
+  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT3(void)
+  {
+    static struct PyModuleDef moduledef = {
+      PyModuleDef_HEAD_INIT,
+      MODULE_NAME,         /* m_name */
+      MODULE_DOC,          /* m_doc */
+      -1,                  /* m_size */
+      MODULE_METHODS,      /* m_methods */
+      NULL,                /* m_reload */
+      NULL,                /* m_traverse */
+      NULL,                /* m_clear */
+      NULL,                /* m_free */
+    };
+        PyObject* m = PyModule_Create(&moduledef);
+        addCinvertor(m);
+        return m;
+  }
+#else /* !PY_MAJOR_VERSION >= 3 */
+  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT2(void)
+  {
+    PyObject* m = Py_InitModule4(MODULE_NAME,
+                 MODULE_METHODS,
+                 MODULE_DOC,
+,
+                 PYTHON_API_VERSION
+                 );
+        addCinvertor(m);
+  }
+#endif /* !PY_MAJOR_VERSION >= 3 */

src/sas/sascalc/pr/fit/AbstractFitEngine.py

r50fcb09	r574adc7
251	251	msg = "FitData1D: invalid error array "
252	252	msg += "%d <> %d" % (np.shape(self.dy), np.size(fx))
253		raise RuntimeError~~, msg~~
	253	raise RuntimeError(msg)
254	254	return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
255	255

src/sas/sascalc/pr/fit/Loader.py

-                      ra1b8fee
+                      r574adc7
         self.dy = dy
         self.filename = None
     def set_filename(self, path=None):
         """
         Store path into a variable.If the user doesn't give
+        Store path into a variable.If the user doesn't give
         a path as a parameter a pop-up
         window appears to select the file.
         :param path: the path given by the user
         """
         self.filename = path
     def get_filename(self):
         """ return the file's path"""
         return self.filename
     def set_values(self):
         """ Store the values loaded from file in local variables"""
 …
             self.x = []
             self.y = []
             self.dx = []
+            self.dx = []
             self.dy = []
             for line in lines:
 …
                     y = float(toks[1])
                     dy = float(toks[2])
                     self.x.append(x)
                     self.y.append(y)
 …
             # Sanity check
             if not len(self.x) == len(self.dx):
                 raise ValueError, "x and dx have different length"
+                raise ValueError("x and dx have different length")
             if not len(self.y) == len(self.dy):
                 raise ValueError, "y and dy have different length"
+                raise ValueError("y and dy have different length")
     def get_values(self):
         """ Return x, y, dx, dy"""
         return self.x, self.y, self.dx, self.dy
     def load_data(self, data):
         """ Return plottable"""
 …
         #Load its View class
         #plottable.reset_view()
 if __name__ == "__main__":
+if __name__ == "__main__":
     load = Load()
     load.set_filename("testdata_line.txt")
     print(load.get_filename())
+    print(load.get_filename())
     load.set_values()
     print(load.get_values())

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

-                      ra1b8fee
+                      r574adc7
     occur multiple times.  The return value is a set with the elements in
     no particular order.
     This is the first step in computing a dependency graph.
     """
 …
         offset = end
     pieces.append(expr[offset:])
     # Join the pieces and return them
     return "".join(pieces)
 …
     """
     Returns a list of pair-wise dependencies from the parameter expressions.
     For example, if p3 = p1+p2, then find_dependencies([p1,p2,p3]) will
     return [(p3,p1),(p3,p2)].  For base expressions without dependencies,
 …
     """
     Find the parameter substitution we need so that expressions can
     be evaluated without having to traverse a chain of
+    be evaluated without having to traverse a chain of
     model.layer.parameter.value
     """
 …
     return definition, substitution
 def no_constraints():
+def no_constraints():
     """
     This parameter set has no constraints between the parameters.
 …
     Parameter names are assumed to contain only _.a-zA-Z0-9#[]
     Both names are provided for inverse functions, e.g., acos and arccos.
     Should try running the function to identify syntax errors before
     running it in a fit.
     Use help(fn) to see the code generated for the returned function fn.
     dis.dis(fn) will show the corresponding python vm instructions.
 …
         if independent == emptyset:
             cycleset = ", ".join(str(s) for s in left)
             raise ValueError,"Cyclic dependencies amongst %s"%cycleset
+            raise ValueError("Cyclic dependencies amongst %s"%cycleset)
         # The possibly resolvable items are those that depend on the independents
 …
         n.sort()
         items = list(items); items.sort()
         raise Exception,"%s expect %s to contain %s for %s"%(msg,n,items,pairs)
+        raise ValueError("%s expect %s to contain %s for %s"%(msg,n,items,pairs))
     for lo,hi in pairs:
         if lo in n and hi in n and n.index(lo) >= n.index(hi):
             raise Exception,"%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs)
+            raise ValueError("%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs))
 def test_deps():
 …
     # Cycle test
     pairs = [(1,4),(4,3),(4,5),(5,1)]
+    try: n = order_dependencies(pairs)
+    except ValueError: pass
+    else: raise Exception,"test3 expect ValueError exception for %s"%(pairs,)
+    try:
+        n = order_dependencies(pairs)
+    except ValueError:
+        pass
+    else:
+        raise Exception("test3 expect ValueError exception for %s"%(pairs,))
     # large test for gross speed check
 …
     import inspect, dis
     import math
     symtab = {'a.b.x':1, 'a.c':2, 'a.b':3, 'b.x':4}
     expr = 'a.b.x + sin(4*pi*a.c) + a.b.x/a.b'
     # Check symbol lookup
     assert _symbols(expr, symtab) == set([1,2,3])
 …
     expected = 2*math.pi*math.sin(5/.1875) + 6
     assert p2.value == expected,"Value was %s, not %s"%(p2.value,expected)
     # Check empty dependency set doesn't crash
     fn = compile_constraints(*world(p1,p3))
 …
     fn()
     assert p5.value == 2.07,"Value for %s was %s"%(p5.expression,p5.value)
     # Verify that we capture invalid expressions
     for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',
+    for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',
                  'piddle',
                  '5; import sys; print "p0wned"',

src/sas/sascalc/pr/invertor.py

-                      rcb62bd5
+                      rd04ac05
                 msg = "Invertor: one of your q-values is zero. "
                 msg += "Delete that entry before proceeding"
                 raise ValueError, msg
+                raise ValueError(msg)
             return self.set_x(value)
         elif name == 'y':
 …
                 msg = "Invertor: d_max must be greater than zero."
                 msg += "Correct that entry before proceeding"
                 raise ValueError, msg
+                raise ValueError(msg)
             return self.set_dmax(value)
         elif name == 'q_min':
 …
                 return self.set_est_bck(0)
             else:
                 raise ValueError, "Invertor: est_bck can only be True or False"
+                raise ValueError("Invertor: est_bck can only be True or False")
         return Cinvertor.__setattr__(self, name, value)
 …
         if self.is_valid() <= 0:
             msg = "Invertor.invert: Data array are of different length"
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         p = np.ones(nfunc)
 …
         if self.is_valid() <= 0:
             msg = "Invertor.invert: Data arrays are of different length"
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         p = np.ones(nfunc)
 …
         if self.is_valid() < 0:
             msg = "Invertor: invalid data; incompatible data lengths."
             raise RuntimeError, msg
+            raise RuntimeError(msg)
         self.nfunc = nfunc
 …
         try:
             self._get_matrix(nfunc, nq, a, b)
         except:
             raise RuntimeError, "Invertor: could not invert I(Q)\n  %s" % sys.exc_value
+        except Exception as exc:
+            raise RuntimeError("Invertor: could not invert I(Q)\n  %s" % str(exc))
         # Perform the inversion (least square fit)
 …
             except:
                 msg = "Invertor.from_file: corrupted file\n%s" % sys.exc_value
                 raise RuntimeError, msg
+                raise RuntimeError(msg)
         else:
             msg = "Invertor.from_file: '%s' is not a file" % str(path)
             raise RuntimeError, msg
+            raise RuntimeError(msg)

src/sas/sasgui/guiframe/config.py

-                      rb963b20
+                      r1efbc190
 UPDATE_TIMEOUT = 2
-# Time out for updating sasview
-UPDATE_TIMEOUT = 2
 def printEVT(message):
     if __EVT_DEBUG__:

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

-                      r24d9e84
+                      r0a3c740
                 save_id = self._format_id(save_id)
                 if save_id == model_id:
-                    model_map[saved_model.pop('fit_page_source')] = \
-                        model[3].name
-                    check = bool(saved_model.pop('checked'))
-                    self.model_list[i][0].SetValue(check)
                     inter_id = str(i)*5
                     init_map[saved_model.pop('fit_page_source')] = inter_id

src/sas/sasview/sasview.py

-                      rb277220
+                      r0225a3f
 import logging
+reload(sys)
+sys.setdefaultencoding("iso-8859-1")
+try:
+    reload(sys)
+    sys.setdefaultencoding("iso-8859-1")
+except NameError:
+    # On python 3 sys.setdefaultencoding does nothing, so pass.
+    # We know we are in python 3 at this point since reload is no longer in
+    # builtins, but instead has been moved to importlib, hence the NameError.
+    pass
 import sas
 …
     setup_mpl(backend='WXAgg' if os.name == 'nt' else None)
     setup_sasmodels()
     if len(sys.argv) == 1:
+    if len(sys.argv) == 1 or sys.argv[1] == '-i':
         # Run sasview as an interactive python interpreter
         try:
 …
             import code
             code.interact(local={'exit': sys.exit})
+    elif sys.argv[1] == '-c':
+        exec(sys.argv[2])
     else:
-        # Run sasview as a python script interpreter
-        ## Run sasview as an interactive python interpreter
-        # if sys.argv[1] == "-i":
-        #    sys.argv = ["ipython", "--pylab"]
-        #    from IPython import start_ipython
-        #    sys.exit(start_ipython())
         thing_to_run = sys.argv[1]
         sys.argv = sys.argv[1:]

test/run_one.py

Property mode changed from 100644 to 100755

test/sascalculator/test/utest_sas_gen.py

-                      r959eb01
+                      r1d014cb
 class sas_gen_test(unittest.TestCase):
     def setUp(self):
         self.sldloader = sas_gen.SLDReader()
         self.pdbloader = sas_gen.PDBReader()
         self.omfloader = sas_gen.OMFReader()
     def test_sldreader(self):
         """
         Test .sld file loaded
+        Test .sld file loaded
         """
         f = self.sldloader.read("sld_file.sld")
 …
         self.assertEqual(f.pos_y[0], -13.5)
         self.assertEqual(f.pos_z[0], -13.5)
     def test_pdbreader(self):
         """
         Test .pdb file loaded
+        Test .pdb file loaded
         """
         f = self.pdbloader.read("c60.pdb")
 …
         self.assertEqual(f.pos_y[0], -1.008)
         self.assertEqual(f.pos_z[0], 3.326)
     def test_omfreader(self):
         """
         Test .omf file loaded
+        Test .omf file loaded
         """
         f = self.omfloader.read("A_Raw_Example-1.omf")

test/sascalculator/test/utest_sld.py

-                      r959eb01
+                      ra50da82
 from periodictable.constants import avogadro_number
 from  periodictable.nsf import neutron_scattering, neutron_sld
 def calculate_xray_sld(element, density, molecule_formula):
 …
     element_formula = formula(str(element))
     if len(element_formula.atoms) != 1:
         return
     element = element_formula.atoms.keys()[0]
+        return
+    element = next(iter(element_formula.atoms))  # only one element...
     energy = xray_energy(element.K_alpha)
     atom = molecule_formula.atoms
 …
     Sld calculator test for H2O
     """
     def setUp(self):
         """Inititialze variables"""
         self.compound = "H2O"
         self.density = 1.0
         self.wavelength = 6.0
         self.sld_formula = formula(self.compound, density=self.density)
     def test_neutron_sld(self):
         """
         test sld
+        test sld
         """
         #Compute incoherence , absorption, and incoherence
         (sld_real,sld_im,sld_inc), (coh,abs,incoh), length = neutron_scattering(self.compound,
                                        density=self.density, wavelength=self.wavelength)
+                                       density=self.density, wavelength=self.wavelength)
         cu_real, cu_im = calculate_xray_sld(element="Cu", density=self.density,
                                   molecule_formula=self.sld_formula)
         mo_real, mo_im = calculate_xray_sld(element="Mo", density=self.density,
                                   molecule_formula=self.sld_formula)
         #test sld
+        #test sld
         self.assertAlmostEquals(sld_real * _SCALE, -5.6e-7, 1)
         self.assertAlmostEquals(sld_im * _SCALE, 0)
 …
         self.assertAlmostEquals(mo_real * _SCALE, 9.43e-6)
         self.assertAlmostEquals(mo_im * _SCALE, 5.65e-7,1)
 class TestD2O(unittest.TestCase):
     """
     Sld calculator test for D2O
     """
     def setUp(self):
         """Inititialze variables"""
         self.compound = "D2O"
         self.density = 1.1
         self.wavelength = 6.0
         self.sld_formula = formula(self.compound, density=self.density)
     def test_neutron_sld(self):
         """
         test sld
+        test sld
         """
         #Compute incoherence , absorption, and incoherence
         (sld_real,sld_im,sld_inc), (coh,abs,incoh), length = neutron_scattering(self.compound,
                                        density=self.density, wavelength=self.wavelength)
+                                       density=self.density, wavelength=self.wavelength)
         cu_real, cu_im = calculate_xray_sld(element="Cu", density=self.density,
                                   molecule_formula=self.sld_formula)
         mo_real, mo_im = calculate_xray_sld(element="Mo", density=self.density,
                                   molecule_formula=self.sld_formula)
         #test sld
+        #test sld
         self.assertAlmostEquals(sld_real * _SCALE, 6.33e-6, 1)
         self.assertAlmostEquals(sld_im * _SCALE, 0)
 …
         self.assertAlmostEquals(mo_real * _SCALE, 9.33e-6)
         self.assertAlmostEquals(mo_im * _SCALE, 5.59e-9,1)
 class TestCd(unittest.TestCase):
     """
     Sld calculator test for Cd
     """
     def setUp(self):
         """Inititialze variables"""
 …
         self.wavelength = 6.0
         self.sld_formula = formula(self.compound, density=self.density)
     def test_neutron_sld(self):
         """
         test sld
+        test sld
         """
         #Compute incoherence , absorption, and incoherence
         (sld_real,sld_im,sld_inc), (coh,abs,incoh), length = neutron_scattering(self.compound,
                                 density=self.density, wavelength=self.wavelength)
+                                density=self.density, wavelength=self.wavelength)
         cu_real, cu_im = calculate_xray_sld(element="Cu", density=self.density,
                                   molecule_formula=self.sld_formula)
         mo_real, mo_im = calculate_xray_sld(element="Mo", density=self.density,
                                   molecule_formula=self.sld_formula)
         #test sld
+        #test sld
         self.assertAlmostEquals(sld_real * _SCALE, 1.04e-6, 1)
         self.assertAlmostEquals(sld_im * _SCALE, -1.5e-7, 1)
 …
         self.assertAlmostEquals(mo_real * _SCALE, 2.84e-5, 1)
         self.assertAlmostEquals(mo_im * _SCALE, 7.26e-7,1)
 if __name__ == '__main__':
     unittest.main()

test/sasdataloader/test/utest_abs_reader.py

-                      rae69c690
+                      r574adc7
                 _found2 = True
+        if _found1 == False or _found2 == False:
+            raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2)
+        if not _found1 or not _found2:
+            raise RuntimeError("Could not find all data %s %s"
+                               % (_found1, _found2))
         # Detector
 …
                     _found_term1 = True
+        if _found_term1 == False or _found_term2 == False:
+            raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2)
+        if not _found_term1 or not _found_term2:
+            raise RuntimeError("Could not find all process terms %s %s"
+                               % (_found_term1, _found_term2))
     def test_writer(self):

test/sasdataloader/test/utest_cansas.py

-                      r17e257b5
+                      rf00072f
     Unit tests for the new recursive cansas reader
 """
+import os
+import sys
+import unittest
+import logging
+import warnings
+if sys.version_info[0] >= 3:
+    from io import StringIO
+else:
+    from StringIO import StringIO
+from lxml import etree
+from lxml.etree import XMLSyntaxError
+from xml.dom import minidom
 import sas.sascalc.dataloader.readers.cansas_reader as cansas
+from sas.sascalc.dataloader.file_reader_base_class import decode
 from sas.sascalc.dataloader.loader import Loader
 from sas.sascalc.dataloader.data_info import Data1D, Data2D
 …
 from sas.sascalc.dataloader.readers.cansas_reader import Reader
 from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants
-import os
-import sys
-import urllib2
-import StringIO
-import pylint as pylint
-import unittest
-import numpy as np
-import logging
-import warnings
-from lxml import etree
-from lxml.etree import XMLSyntaxError
-from xml.dom import minidom
 logger = logging.getLogger(__name__)
 …
         Should fail gracefully and send a message to logger.info()
         """
         invalid = StringIO.StringIO('<a><c></b></a>')
+        invalid = StringIO('<a><c></b></a>')
         self.assertRaises(XMLSyntaxError, lambda: XMLreader(invalid))
 …
         string += "\t</xsd:complexType>\n"
         string += "</xsd:schema>"
         f = StringIO.StringIO(string)
+        f = StringIO(string)
         xmlschema_doc = etree.parse(f)
         xmlschema = etree.XMLSchema(xmlschema_doc)
         valid = etree.parse(StringIO.StringIO('<a><b></b></a>'))
         invalid = etree.parse(StringIO.StringIO('<a><c></c></a>'))
+        valid = etree.parse(StringIO('<a><b></b></a>'))
+        invalid = etree.parse(StringIO('<a><c></c></a>'))
         self.assertTrue(xmlschema.validate(valid))
         self.assertFalse(xmlschema.validate(invalid))
 …
             # find the processing instructions and make into a dictionary
             dic = self.get_processing_instructions(reader)
             self.assertTrue(dic == {'xml-stylesheet': \
                                     'type="text/xsl" href="cansas1d.xsl" '})
+            self.assertEqual(dic, {'xml-stylesheet':
+                                   'type="text/xsl" href="cansas1d.xsl" '})
             xml = "<test><a><b><c></c></b></a></test>"
 …
             attr = {}
             pi_name = ""
             pi_string = etree.tostring(pi)
+            pi_string = decode(etree.tostring(pi))
             if isinstance(pi_string, str):
                 pi_string = pi_string.replace("<?", "").replace("?>", "")
 …
 if __name__ == '__main__':
     unittest.main()
+    unittest.main()

test/sasrealspace/test/utest_oriented.py

-                      raaf5e49
+                      r1cdbcd8
 # Disable "missing docstring" complaint
 # pylint: disable-msg=C0111
 # Disable "too many methods" complaint
 # pylint: disable-msg=R0904
 # Disable "could be a function" complaint
+# Disable "too many methods" complaint
+# pylint: disable-msg=R0904
+# Disable "could be a function" complaint
 # pylint: disable-msg=R0201
 # pylint: disable-msg=W0702
+try:
+    import VolumeCanvas
     print("Testing local version")
+except:
     print(sys.exc_value)
+    #testing the version that is working on
+    print("Testing installed version")
+    import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas
+from sasmodels.sasview_model import _make_standard_model
+EllipsoidModel = _make_standard_model('ellipsoid')
+SphereModel = _make_standard_model('sphere')
+CylinderModel = _make_standard_model('cylinder')
+CoreShellModel = _make_standard_model('core_shell_sphere')
+import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas
 class TestSphere(unittest.TestCase):
     """ Tests for oriented (2D) systems """
     def setUp(self):
         """
             Set up canvas
         """
-        from sas.models.SphereModel import SphereModel
         self.model = VolumeCanvas.VolumeCanvas()
         handle = self.model.add('sphere')
         radius = 10
         density = .1
         ana = SphereModel()
         ana.setParam('scale', 1.0)
-        ana.setParam('contrast', 1.0)
         ana.setParam('background', 0.0)
+        ana.setParam('sld', 1.0)
+        ana.setParam('sld_solvent', 0.0)
         ana.setParam('radius', radius)
         self.ana = ana
         self.model.setParam('lores_density', density)
+        self.model.setParam('scale' , 1.0)
+        self.model.setParam('background' , 0.0)
+        self.model.setParam('%s.contrast' % handle, 1.0)
         self.model.setParam('%s.radius' % handle, radius)
+        self.model.setParam('scale' , 1.0)
+        self.model.setParam('%s.contrast' % handle, 1.0)
+        self.model.setParam('background' , 0.0)
     def testdefault(self):
         """ Testing sphere """
 …
         sim_val = self.model.getIq2D(0.1, 0.1)
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 )
 class TestCylinderAddObject(unittest.TestCase):
     """ Tests for oriented (2D) systems """
     def setUp(self):
         """ Set up cylinder model """
-        from sas.models.CylinderModel import CylinderModel
         radius = 5
         length = 40
         density = 20
         # Analytical model
         self.ana = CylinderModel()
         self.ana.setParam('scale', 1.0)
-        self.ana.setParam('contrast', 1.0)
         self.ana.setParam('background', 0.0)
+        self.ana.setParam('sld', 1.0)
+        self.ana.setParam('sld_solvent', 0.0)
         self.ana.setParam('radius', radius)
         self.ana.setParam('length', length)
         # Simulation model
         self.model = VolumeCanvas.VolumeCanvas()
 …
         self.handle = self.model.addObject(cyl)
         self.model.setParam('lores_density', density)
+        self.model.setParam('scale' , 1.0)
+        self.model.setParam('background' , 0.0)
+        self.model.setParam('%s.contrast' % self.handle, 1.0)
         self.model.setParam('%s.radius' % self.handle, radius)
         self.model.setParam('%s.length' % self.handle, length)
+        self.model.setParam('scale' , 1.0)
+        self.model.setParam('%s.contrast' % self.handle, 1.0)
+        self.model.setParam('background' , 0.0)
     def testalongY(self):
         """ Testing cylinder along Y axis """
         self.ana.setParam('cyl_theta', math.pi/2.0)
         self.ana.setParam('cyl_phi', math.pi/2.0)
+        self.ana.setParam('theta', math.pi/2.0)
+        self.ana.setParam('phi', math.pi/2.0)
         self.model.setParam('%s.orientation' % self.handle, [0,0,0])
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.model.getIq2D(0.1, 0.2)
         #print ana_val, sim_val, sim_val/ana_val
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        ana_val = self.ana.runXY([0.1, 0.2])
+        sim_val = self.model.getIq2D(0.1, 0.2)
+        #print ana_val, sim_val, sim_val/ana_val
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
 class TestCylinder(unittest.TestCase):
     """ Tests for oriented (2D) systems """
     def setUp(self):
         """ Set up cylinder model """
-        from sas.models.CylinderModel import CylinderModel
         radius = 5
         length = 40
         density = 20
         # Analytical model
         self.ana = CylinderModel()
         self.ana.setParam('scale', 1.0)
-        self.ana.setParam('contrast', 1.0)
         self.ana.setParam('background', 0.0)
+        self.ana.setParam('sld', 1.0)
+        self.ana.setParam('sld_solvent', 0.0)
         self.ana.setParam('radius', radius)
         self.ana.setParam('length', length)
         # Simulation model
         self.model = VolumeCanvas.VolumeCanvas()
         self.handle = self.model.add('cylinder')
         self.model.setParam('lores_density', density)
+        self.model.setParam('scale' , 1.0)
+        self.model.setParam('background' , 0.0)
         self.model.setParam('%s.radius' % self.handle, radius)
         self.model.setParam('%s.length' % self.handle, length)
-        self.model.setParam('scale' , 1.0)
         self.model.setParam('%s.contrast' % self.handle, 1.0)
+        self.model.setParam('background' , 0.0)
     def testalongY(self):
         """ Testing cylinder along Y axis """
         self.ana.setParam('cyl_theta', math.pi/2.0)
         self.ana.setParam('cyl_phi', math.pi/2.0)
+        self.ana.setParam('theta', math.pi/2.0)
+        self.ana.setParam('phi', math.pi/2.0)
         self.model.setParam('%s.orientation' % self.handle, [0,0,0])
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.model.getIq2D(0.1, 0.2)
         #print ana_val, sim_val, sim_val/ana_val
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        ana_val = self.ana.runXY([0.1, 0.2])
+        sim_val = self.model.getIq2D(0.1, 0.2)
+        #print ana_val, sim_val, sim_val/ana_val
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
     def testalongZ(self):
         """ Testing cylinder along Z axis """
         self.ana.setParam('cyl_theta', 0)
         self.ana.setParam('cyl_phi', 0)
+        self.ana.setParam('theta', 0)
+        self.ana.setParam('phi', 0)
         self.model.setParam('%s.orientation' % self.handle, [90,0,0])
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.model.getIq2D(0.1, 0.2)
         #print ana_val, sim_val, sim_val/ana_val
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        ana_val = self.ana.runXY([0.1, 0.2])
+        sim_val = self.model.getIq2D(0.1, 0.2)
+        #print ana_val, sim_val, sim_val/ana_val
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
     def testalongX(self):
         """ Testing cylinder along X axis """
         self.ana.setParam('cyl_theta', 1.57)
         self.ana.setParam('cyl_phi', 0)
+        self.ana.setParam('theta', 1.57)
+        self.ana.setParam('phi', 0)
         self.model.setParam('%s.orientation' % self.handle, [0,0,90])
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.model.getIq2D(0.1, 0.2)
         #print ana_val, sim_val, sim_val/ana_val
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        ana_val = self.ana.runXY([0.1, 0.2])
+        sim_val = self.model.getIq2D(0.1, 0.2)
+        #print ana_val, sim_val, sim_val/ana_val
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
 class TestEllipsoid(unittest.TestCase):
     """ Tests for oriented (2D) systems """
     def setUp(self):
         """ Set up ellipsoid """
+        from sas.models.EllipsoidModel import EllipsoidModel
         radius_a = 60
         radius_b = 10
         density = 30
         self.ana = EllipsoidModel()
         self.ana.setParam('scale', 1.0)
-        self.ana.setParam('contrast', 1.0)
         self.ana.setParam('background', 0.0)
+        self.ana.setParam('radius_a', radius_a)
+        self.ana.setParam('radius_b', radius_b)
+        self.ana.setParam('sld', 1.0)
+        self.ana.setParam('sld_solvent', 0.0)
+        self.ana.setParam('radius_polar', radius_a)
+        self.ana.setParam('radius_equatorial', radius_b)
         # Default orientation is there=1.57, phi=0
         # Radius_a is along the x direction
         canvas = VolumeCanvas.VolumeCanvas()
+        self.handle = canvas.add('ellipsoid')
         canvas.setParam('lores_density', density)
+        self.handle = canvas.add('ellipsoid')
+        canvas.setParam('scale' , 1.0)
+        canvas.setParam('background' , 0.0)
         canvas.setParam('%s.radius_x' % self.handle, radius_a)
         canvas.setParam('%s.radius_y' % self.handle, radius_b)
         canvas.setParam('%s.radius_z' % self.handle, radius_b)
-        canvas.setParam('scale' , 1.0)
         canvas.setParam('%s.contrast' % self.handle, 1.0)
+        canvas.setParam('background' , 0.0)
+        self.canvas = canvas
+        self.canvas = canvas
     def testalongX(self):
         """ Testing ellipsoid along X """
         self.ana.setParam('axis_theta', 1.57)
         self.ana.setParam('axis_phi', 0)
+        self.ana.setParam('theta', 1.57)
+        self.ana.setParam('phi', 0)
         self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.canvas.getIq2D(0.1, 0.2)
         #print ana_val, sim_val, sim_val/ana_val
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
     def testalongZ(self):
         """ Testing ellipsoid along Z """
         self.ana.setParam('axis_theta', 0)
         self.ana.setParam('axis_phi', 0)
+        self.ana.setParam('theta', 0)
+        self.ana.setParam('phi', 0)
         self.canvas.setParam('%s.orientation' % self.handle, [0,90,0])
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.canvas.getIq2D(0.1, 0.2)
         #print ana_val, sim_val, sim_val/ana_val
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
     def testalongY(self):
         """ Testing ellipsoid along Y """
         self.ana.setParam('axis_theta', math.pi/2.0)
         self.ana.setParam('axis_phi', math.pi/2.0)
+        self.ana.setParam('theta', math.pi/2.0)
+        self.ana.setParam('phi', math.pi/2.0)
         self.canvas.setParam('%s.orientation' % self.handle, [0,0,90])
         ana_val = self.ana.runXY([0.05, 0.15])
         sim_val = self.canvas.getIq2D(0.05, 0.15)
         #print ana_val, sim_val, sim_val/ana_val
         try:
             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except:
+        except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
             raise sys.exc_type, sys.exc_value
+            raise
 class TestCoreShell(unittest.TestCase):
     """ Tests for oriented (2D) systems """
     def setUp(self):
         """ Set up zero-SLD-average core-shell model """
+        from sas.models.CoreShellModel import CoreShellModel
         radius = 15
         thickness = 5
         density = 20
         core_vol = 4.0/3.0*math.pi*radius*radius*radius
         self.outer_radius = radius+thickness
 …
         self.density = density
         # Core-shell
         sphere = CoreShellModel()
+        sphere.setParam('scale', 1.0)
+        sphere.setParam('background', 0.0)
         # Core radius
         sphere.setParam('radius', radius)
         # Shell thickness
         sphere.setParam('thickness', thickness)
+        sphere.setParam('core_sld', 1.0)
+        sphere.setParam('shell_sld', self.shell_sld)
+        sphere.setParam('solvent_sld', 0.0)
+        sphere.setParam('background', 0.0)
+        sphere.setParam('scale', 1.0)
+        sphere.setParam('sld_core', 1.0)
+        sphere.setParam('sld_shell', self.shell_sld)
+        sphere.setParam('sld_solvent', 0.0)
         self.ana = sphere
         canvas = VolumeCanvas.VolumeCanvas()
+        canvas = VolumeCanvas.VolumeCanvas()
         canvas.setParam('lores_density', self.density)
+        canvas.setParam('scale' , 1.0)
+        canvas.setParam('background' , 0.0)
         handle = canvas.add('sphere')
         canvas.setParam('%s.radius' % handle, self.outer_radius)
         canvas.setParam('%s.contrast' % handle, self.shell_sld)
         handle2 = canvas.add('sphere')
         canvas.setParam('%s.radius' % handle2, radius)
         canvas.setParam('%s.contrast' % handle2, 1.0)
+        canvas.setParam('scale' , 1.0)
+        canvas.setParam('background' , 0.0)
+        self.canvas = canvas
+        self.canvas = canvas
     def testdefault(self):
         """ Testing default core-shell orientation """
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
 class TestCoreShellError(unittest.TestCase):
     """ Tests for oriented (2D) systems """
     def setUp(self):
         """ Set up zero-SLD-average core-shell model """
+        from sas.models.CoreShellModel import CoreShellModel
         radius = 15
         thickness = 5
         density = 5
         core_vol = 4.0/3.0*math.pi*radius*radius*radius
         self.outer_radius = radius+thickness
 …
         self.density = density
         # Core-shell
         sphere = CoreShellModel()
+        sphere.setParam('scale', 1.0)
+        sphere.setParam('background', 0.0)
         # Core radius
         sphere.setParam('radius', radius)
         # Shell thickness
         sphere.setParam('thickness', thickness)
+        sphere.setParam('core_sld', 1.0)
+        sphere.setParam('shell_sld', self.shell_sld)
+        sphere.setParam('solvent_sld', 0.0)
+        sphere.setParam('background', 0.0)
+        sphere.setParam('scale', 1.0)
+        sphere.setParam('sld_core', 1.0)
+        sphere.setParam('sld_shell', self.shell_sld)
+        sphere.setParam('sld_solvent', 0.0)
         self.ana = sphere
         canvas = VolumeCanvas.VolumeCanvas()
+        canvas = VolumeCanvas.VolumeCanvas()
         canvas.setParam('lores_density', self.density)
+        canvas.setParam('scale' , 1.0)
+        canvas.setParam('background' , 0.0)
         handle = canvas.add('sphere')
         canvas.setParam('%s.radius' % handle, self.outer_radius)
         canvas.setParam('%s.contrast' % handle, self.shell_sld)
         handle2 = canvas.add('sphere')
         canvas.setParam('%s.radius' % handle2, radius)
         canvas.setParam('%s.contrast' % handle2, 1.0)
+        canvas.setParam('scale' , 1.0)
+        canvas.setParam('background' , 0.0)
+        self.canvas = canvas
+        self.canvas = canvas
     def testdefault(self):
         """ Testing default core-shell orientation """
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
         self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err )
 …
     def setUp(self):
         """ Set up ellipsoid """
+        from sas.models.EllipsoidModel import EllipsoidModel
         radius_a = 10
         radius_b = 15
         density = 5
         self.ana = EllipsoidModel()
         self.ana.setParam('scale', 1.0)
-        self.ana.setParam('contrast', 1.0)
         self.ana.setParam('background', 0.0)
+        self.ana.setParam('radius_a', radius_a)
+        self.ana.setParam('radius_b', radius_b)
+        self.ana.setParam('sld', 1.0)
+        self.ana.setParam('sld_solvent', 1.0)
+        self.ana.setParam('radius_polar', radius_a)
+        self.ana.setParam('radius_equatorial', radius_b)
         canvas = VolumeCanvas.VolumeCanvas()
+        self.handle = canvas.add('ellipsoid')
         canvas.setParam('lores_density', density)
+        self.handle = canvas.add('ellipsoid')
+        canvas.setParam('scale' , 1.0)
+        canvas.setParam('background' , 0.0)
         canvas.setParam('%s.radius_x' % self.handle, radius_a)
         canvas.setParam('%s.radius_y' % self.handle, radius_b)
         canvas.setParam('%s.radius_z' % self.handle, radius_b)
-        canvas.setParam('scale' , 1.0)
         canvas.setParam('%s.contrast' % self.handle, 1.0)
+        canvas.setParam('background' , 0.0)
+        self.canvas = canvas
+        self.ana.setParam('axis_theta', 1.57)
+        self.ana.setParam('axis_phi', 0)
+        self.canvas = canvas
+        self.ana.setParam('theta', 1.57)
+        self.ana.setParam('phi', 0)
         self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
     def testRunXY_List(self):
 …
         sim_val = self.canvas.runXY([0.1, 0.2])
         #print ana_val, sim_val, sim_val/ana_val
         try:
             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except:
+        except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
             raise sys.exc_type, sys.exc_value
+            raise
     def testRunXY_float(self):
 …
         sim_val = self.canvas.runXY(0.1)
         #print ana_val, sim_val, sim_val/ana_val
         try:
             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except:
+        except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
             raise sys.exc_type, sys.exc_value
+            raise
     def testRun_float(self):
 …
         sim_val = self.canvas.run(0.1)
         #print ana_val, sim_val, sim_val/ana_val
         try:
             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except:
+        except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
             raise sys.exc_type, sys.exc_value
+            raise
     def testRun_list(self):
 …
         sim_val = self.canvas.run([0.1, 33.0])
         #print ana_val, sim_val, sim_val/ana_val
         try:
             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except:
+        except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
             raise sys.exc_type, sys.exc_value
+            raise
 class TestParamChange(unittest.TestCase):
     """ Tests for oriented (2D) systems """
     def setUp(self):
         """ Set up cylinder model """
-        from sas.models.CylinderModel import CylinderModel
         radius = 5
         length = 40
         density = 20
         # Analytical model
         self.ana = CylinderModel()
         self.ana.setParam('scale', 1.0)
-        self.ana.setParam('contrast', 1.0)
         self.ana.setParam('background', 0.0)
+        self.ana.setParam('sld', 1.0)
+        self.ana.setParam('sld_solvent', 0.0)
         self.ana.setParam('radius', radius)
         self.ana.setParam('length', length)
         self.ana.setParam('cyl_theta', math.pi/2.0)
         self.ana.setParam('cyl_phi', math.pi/2.0)
+        self.ana.setParam('theta', math.pi/2.0)
+        self.ana.setParam('phi', math.pi/2.0)
         # Simulation model
         self.model = VolumeCanvas.VolumeCanvas()
         self.handle = self.model.add('cylinder')
         self.model.setParam('lores_density', density)
+        self.model.setParam('scale' , 1.0)
+        self.model.setParam('background' , 0.0)
         self.model.setParam('%s.radius' % self.handle, radius)
         self.model.setParam('%s.length' % self.handle, length)
-        self.model.setParam('scale' , 1.0)
         self.model.setParam('%s.contrast' % self.handle, 1.0)
-        self.model.setParam('background' , 0.0)
         self.model.setParam('%s.orientation' % self.handle, [0,0,0])
     def testalongY(self):
         """ Test that a parameter change forces the generation
 …
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.model.getIq2D(0.1, 0.2)
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
         # Change the radius a re-evaluate
         self.ana.setParam('radius', 10)
         self.model.setParam('%s.radius' % self.handle, 10)
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.model.getIq2D(0.1, 0.2)
 …
 if __name__ == '__main__':
     unittest.main()
+    unittest.main()

test/sasrealspace/test/utest_realspace.py

-                      raaf5e49
+                      r1cdbcd8
 # Disable "missing docstring" complaint
 # pylint: disable-msg=C0111
 # Disable "too many methods" complaint
 # pylint: disable-msg=R0904
 # Disable "could be a function" complaint
+# Disable "too many methods" complaint
+# pylint: disable-msg=R0904
+# Disable "could be a function" complaint
 # pylint: disable-msg=R0201
+try:
+    import VolumeCanvas
+    print("Testing local version")
+except:
+    import sys
+    print(sys.exc_value)
+    #testing the version that is working on
+    print("Testing installed version")
+    import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas
+from sasmodels.sasview_model import _make_standard_model
+EllipsoidModel = _make_standard_model('ellipsoid')
+SphereModel = _make_standard_model('sphere')
+CylinderModel = _make_standard_model('cylinder')
+CoreShellModel = _make_standard_model('core_shell_sphere')
+import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas
 class TestRealSpaceModel(unittest.TestCase):
     """ Unit tests for sphere model """
     def setUp(self):
         self.model = VolumeCanvas.VolumeCanvas()
 …
         self.model.add('ellipsoid', 'elli')
         self.model.add('singlehelix', 'shelix')
     def testAdding(self):
         self.assertEqual('cyl', self.model.add('cylinder', 'cyl'))
+        self.assertEqual('cyl', self.model.add('cylinder', 'cyl'))
     def testDeleting(self):
 …
         #print "pr is calculated", self.model.hasPr
         result = self.model.getIq(0.1)
         #print "I(0.1) is calculated: ", result
+        #print "I(0.1) is calculated: ", result
 class TestSphere(unittest.TestCase):
 …
     def setUp(self):
         self.canvas = VolumeCanvas.VolumeCanvas()
     def testSetQmax(self):
         old_value = self.canvas.getParam('q_max')
         new_value = old_value + 0.1
         self.canvas.setParam('q_max', new_value)
         self.assertEqual(self.canvas.getParam("Q_MAx"), new_value)
     def testSetDensity(self):
+        self.assertEqual(self.canvas.getParam("Q_MAx"), new_value)
+    def testSetDensity(self):
         self.canvas.setParam('lores_density', 0.1)
         handle = self.canvas.add('sphere')
 …
         npts_1 = vol/0.1
         value_1 = self.canvas.getIq(0.001)
         # Change density, the answer should be the same
         self.canvas.setParam('lores_density', 0.2)
         npts_2 = vol/0.2
         value_2 = self.canvas.getIq(0.001)
         self.assert_( (value_1-value_2)/value_1 < 0.1)
     def testSetDensityTiming(self):
+        self.assert_( (value_1-value_2)/value_1 < 0.1)
+    def testSetDensityTiming(self):
         """Testing change in computation time with density"""
         handle = self.canvas.add('sphere')
         self.canvas.setParam("%s.radius" % handle, 15.0)
         self.canvas.setParam('lores_density', 0.6)
         t_0 = time.time()
         self.canvas.getIq(0.001)
         t_1 = time.time()-t_0
         # Change density, the answer should be the same
         self.canvas.setParam('lores_density', 0.1)
 …
         self.canvas.getIq(0.001)
         t_2 = time.time()-t_0
         self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2)
+        self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2)
     def testGetParamList(self):
         """ Test GetParamList on empty canvas"""
         self.assert_('lores_density' in self.canvas.getParamList())
         handle = self.canvas.add('sphere')
     def testGetParamListWithShape(self):
         """ Test GetParamList on filled canvas"""
         self.canvas.add('sphere')
         self.assert_('lores_density' in self.canvas.getParamList())
     def testAdd(self):
         handle = "s1"
         self.assertEqual(handle, self.canvas.add('sphere', handle))
         #TODO: test for current list of shape
         self.assertEqual( [handle] , self.canvas.getShapeList())
     def testSetRadius(self):
         handle = self.canvas.add('sphere')
         self.canvas.setParam("%s.rAdius" % handle, 24.0)
         self.assertEqual(self.canvas.getParam("%s.rAdius" % handle), 24.0)
+        self.canvas.setParam("%s.radius" % handle, 24.0)
+        self.assertEqual(self.canvas.getParam("%s.radius" % handle), 24.0)
     def testGetIq(self):
         """ Test the output of I(q) to the analytical solution
             If the normalization is wrong, we will have to fix it.
             getIq() should call getPr() behind the scenes so that
             the user doesnt have to do it if he doesn't need to.
         """
-        from sas.models.SphereModel import SphereModel
         sphere = SphereModel()
+        sphere.setParam('scale', 1.0)
+        sphere.setParam('background', 0.0)
+        sphere.setParam('sld', 1.0)
+        sphere.setParam('sld_solvent', 0.0)
         sphere.setParam('radius', 10.0)
+        sphere.setParam('contrast', 1.0)
+        sphere.setParam('background', 0.0)
+        sphere.setParam('scale', 1.0)
         handle = self.canvas.add('sphere')
         self.canvas.setParam('%s.radius' % handle, 10.0)
         self.canvas.setParam('%s.contrast' % handle, 1.0)
         sim_1 = self.canvas.getIq(0.001)
         ana_1 = sphere.run(0.001)
         sim_2 = self.canvas.getIq(0.01)
         ana_2 = sphere.run(0.01)
         # test the shape of the curve (calculate relative error
+        # test the shape of the curve (calculate relative error
         # on the output and it should be compatible with zero
         # THIS WILL DEPEND ON THE NUMBER OF SPACE POINTS:
         # that why we need some error analysis.
         self.assert_( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1)
         # test the absolute amplitude
         self.assert_( math.fabs(sim_2-ana_2)/ana_2 < 0.1)
     def testGetIq2(self):
         """ Test two different q values
 …
         handle = self.canvas.add('sphere')
         self.canvas.setParam('%s.radius' % handle, 10.0)
         sim_1 = self.canvas.getIq(0.001)
         sim_2 = self.canvas.getIq(0.01)
         self.assertNotAlmostEqual(sim_2, sim_1, 3)
     def testGetIq_Identical(self):
         """ Test for identical model / no param change
 …
         handle = self.canvas.add('sphere')
         self.canvas.setParam('%s.radius' % handle, 10.0)
         sim_1 = self.canvas.getIq(0.01)
         sim_2 = self.canvas.getIq(0.01)
         self.assertEqual(sim_2, sim_1)
     def testGetIq_Identical2(self):
         """ Test for identical model after a parameter change
 …
         handle = self.canvas.add('sphere')
         self.canvas.setParam('%s.radius' % handle, 10.0)
         self.canvas.setParam('lores_density', 0.1)
         sim_1 = self.canvas.getIq(0.01)
         # Try to fool the code by changing to a different value
         self.canvas.setParam('lores_density', 0.2)
         self.canvas.getIq(0.01)
         self.canvas.setParam('lores_density', 0.1)
         sim_2 = self.canvas.getIq(0.01)
+        self.canvas.setParam('lores_density', 0.1)
+        sim_2 = self.canvas.getIq(0.01)
         self.assert_((sim_2-sim_1)/sim_1<0.05)
     def testGetIq_time(self):
         """ Time profile
 …
         handle = self.canvas.add('sphere')
         self.canvas.setParam('%s.radius' % handle, 15.0)
         self.canvas.setParam('lores_density', 0.1)
         t_0 = time.time()
         sim_1 = self.canvas.getIq(0.01)
         delta_1 = time.time()-t_0
         self.canvas.setParam('lores_density', 0.1)
+        self.canvas.setParam('lores_density', 0.1)
         t_0 = time.time()
         sim_2 = self.canvas.getIq(0.01)
         delta_2 = time.time()-t_0
         self.assert_((delta_2-delta_1)/delta_1<0.05)
     def testGetPr(self):
         """Compare the output of P(r) to the theoretical value"""
 …
             get the right output after changing a parameter
         """
         handle = self.canvas.add('sphere')
         self.canvas.setParam('%s.radius' % handle, 10.0)
 …

Changeset 5a81885 in sasview

Legend: