Index: sansmodels/src/sans/models/BaseComponent.py
===================================================================
--- sansmodels/src/sans/models/BaseComponent.py	(revision 4ce74b444daa7f28c3e72a0e279f00c4441326fb)
+++ sansmodels/src/sans/models/BaseComponent.py	(revision 7fdb332db7da9478616e379581e7014dc9448a0e)
@@ -32,5 +32,5 @@
         # string containing information about the model such as the equation
         #of the given model, exception or possible use
-        self.description=''
+        self.description = ''
         #list of parameter that can be fitted
         self.fixed = []
@@ -66,8 +66,28 @@
         #return self.params[str(par_name)].is_fittable()
    
-    def run(self, x): return NotImplemented
-    def runXY(self, x): return NotImplemented  
-    def calculate_ER(self): return NotImplemented  
-    def calculate_VR(self): return NotImplemented 
+    def run(self, x): 
+        """
+        run 1d
+        """
+        return NotImplemented
+    
+    def runXY(self, x): 
+        """
+        run 2d
+        """
+        return NotImplemented  
+    
+    def calculate_ER(self): 
+        """
+        Calculate effective radius
+        """
+        return NotImplemented  
+    
+    def calculate_VR(self): 
+        """
+        Calculate volume fraction ratio
+        """
+        return NotImplemented 
+    
     def evalDistribution(self, qdist):
         """
@@ -112,5 +132,6 @@
                 qdist[0].__class__.__name__ != 'ndarray' or \
                 qdist[1].__class__.__name__ != 'ndarray':
-                    raise RuntimeError, "evalDistribution expects a list of 2 ndarrays"
+                msg = "evalDistribution expects a list of 2 ndarrays"
+                raise RuntimeError, msg
                 
             # Extract qx and qy for code clarity
@@ -121,5 +142,5 @@
             q = numpy.sqrt(qx**2+qy**2)
             # vectorize the model function runXY
-            v_model = numpy.vectorize(self.runXY,otypes=[float])
+            v_model = numpy.vectorize(self.runXY, otypes=[float])
             # calculate the scattering
             iq_array = v_model(q)
@@ -128,9 +149,8 @@
                 
         elif qdist.__class__.__name__ == 'ndarray':
-                # We have a simple 1D distribution of q-values
-                v_model = numpy.vectorize(self.runXY,otypes=[float])
-                iq_array = v_model(qdist)
-
-                return iq_array
+            # We have a simple 1D distribution of q-values
+            v_model = numpy.vectorize(self.runXY, otypes=[float])
+            iq_array = v_model(qdist)
+            return iq_array
             
         else:
@@ -246,10 +266,39 @@
     
     # Old-style methods that are no longer used
-    def setParamWithToken(self, name, value, token, member): return NotImplemented
-    def getParamWithToken(self, name, token, member): return NotImplemented
-    def getParamListWithToken(self, token, member): return NotImplemented
-    def __add__(self, other): raise ValueError, "Model operation are no longer supported"
-    def __sub__(self, other): raise ValueError, "Model operation are no longer supported"
-    def __mul__(self, other): raise ValueError, "Model operation are no longer supported"
-    def __div__(self, other): raise ValueError, "Model operation are no longer supported"
-        
+    def setParamWithToken(self, name, value, token, member): 
+        """
+        set Param With Token
+        """
+        return NotImplemented
+    def getParamWithToken(self, name, token, member): 
+        """
+        get Param With Token
+        """
+        return NotImplemented
+    
+    def getParamListWithToken(self, token, member): 
+        """
+        get Param List With Token
+        """
+        return NotImplemented
+    def __add__(self, other): 
+        """
+        add
+        """
+        raise ValueError, "Model operation are no longer supported"
+    def __sub__(self, other): 
+        """
+        sub
+        """
+        raise ValueError, "Model operation are no longer supported"
+    def __mul__(self, other): 
+        """
+        mul
+        """
+        raise ValueError, "Model operation are no longer supported"
+    def __div__(self, other): 
+        """
+        div
+        """
+        raise ValueError, "Model operation are no longer supported"
+        
Index: sansmodels/src/sans/models/MultiplicationModel.py
===================================================================
--- sansmodels/src/sans/models/MultiplicationModel.py	(revision a8a55f2c9d7c85c2e091d40c00494390a05035a6)
+++ sansmodels/src/sans/models/MultiplicationModel.py	(revision 7fdb332db7da9478616e379581e7014dc9448a0e)
@@ -1,7 +1,7 @@
 
 from sans.models.BaseComponent import BaseComponent
-import numpy, math
+#import numpy, math
 import copy
-from sans.models.pluginmodel import Model1DPlugin
+#from sans.models.pluginmodel import Model1DPlugin
 class MultiplicationModel(BaseComponent):
     """
@@ -17,12 +17,12 @@
         BaseComponent.__init__(self)
         """
-            @param p_model: form factor, P(Q)
-            @param s_model: structure factor, S(Q)
+        :param p_model: form factor, P(Q)
+        :param s_model: structure factor, S(Q)
         """
 
         ## Setting  model name model description
-        self.description=""
+        self.description = ""
         self.name = p_model.name +" * "+ s_model.name
-        self.description= self.name+"\n"
+        self.description= self.name + "\n"
         self.fill_description(p_model, s_model)
 
@@ -34,6 +34,6 @@
         
         ##models 
-        self.p_model= p_model
-        self.s_model= s_model        
+        self.p_model = p_model
+        self.s_model = s_model        
        
         ## dispersion
@@ -100,5 +100,5 @@
         ##set dispersion only from p_model 
         for name , value in self.p_model.dispersion.iteritems():
-            self.dispersion[name]= value 
+            self.dispersion[name] = value 
                                       
     def getProfile(self):
@@ -111,5 +111,5 @@
         """
         try:
-            x,y = self.p_model.getProfile()
+            x, y = self.p_model.getProfile()
         except:
             x = None
@@ -126,10 +126,10 @@
         for name , value in self.p_model.params.iteritems():
             if not name in self.params.keys() and name != 'scale':
-                self.params[name]= value
+                self.params[name] = value
             
         for name , value in self.s_model.params.iteritems():
             #Remove the effect_radius from the (P*S) model parameters.
             if not name in self.params.keys() and name != 'effect_radius':
-                self.params[name]= value
+                self.params[name] = value
                 
         # Set "scale and effec_radius to P and S model as initializing
@@ -143,11 +143,11 @@
             this model details 
         """
-        for name ,detail in self.p_model.details.iteritems():
+        for name, detail in self.p_model.details.iteritems():
             if name != 'scale':
-                self.details[name]= detail
+                self.details[name] = detail
             
         for name , detail in self.s_model.details.iteritems():
             if not name in self.details.keys() or name != 'effect_radius':
-                self.details[name]= detail
+                self.details[name] = detail
     
     def _set_scale_factor(self):
@@ -159,5 +159,5 @@
             factor = self.p_model.calculate_VR()
             if factor == None or factor == NotImplemented or factor == 0.0:
-                val= value
+                val = value
             else:
                 val = value / factor
@@ -174,12 +174,12 @@
         #Reset the effective_radius of s_model just before the run
         if effective_radius != None and effective_radius != NotImplemented:
-            self.s_model.setParam('effect_radius',effective_radius)
+            self.s_model.setParam('effect_radius', effective_radius)
                 
     def setParam(self, name, value):
         """ 
-            Set the value of a model parameter
-        
-            @param name: name of the parameter
-            @param value: value of the parameter
+        Set the value of a model parameter
+        
+        :param name: name of the parameter
+        :param value: value of the parameter
         """
         # set param to P*S model
@@ -237,12 +237,14 @@
                 
     def run(self, x = 0.0):
-        """ Evaluate the model
-            @param x: input q-value (float or [float, float] as [r, theta])
-            @return: (scattering function value)
+        """ 
+        Evaluate the model
+        :param x: input q-value (float or [float, float] as [r, theta])
+        :return: (scattering function value)
         """
         # set effective radius and scaling factor before run
         self._set_effect_radius()
         self._set_scale_factor()
-        return self.params['scale_factor']*self.p_model.run(x)*self.s_model.run(x)
+        return self.params['scale_factor'] * self.p_model.run(x) * \
+                            self.s_model.run(x)
 
     def runXY(self, x = 0.0):
@@ -254,28 +256,33 @@
         self._set_effect_radius()
         self._set_scale_factor()
-        return self.params['scale_factor']*self.p_model.runXY(x)* self.s_model.runXY(x)
+        out = self.params['scale_factor'] * self.p_model.runXY(x) * \
+                        self.s_model.runXY(x)
+        return out
     
     ## Now (May27,10) directly uses the model eval function 
     ## instead of the for-loop in Base Component.
     def evalDistribution(self, x = []):
-        """ Evaluate the model in cartesian coordinates
-            @param x: input q[], or [qx[], qy[]]
-            @return: scattering function P(q[])
+        """ 
+        Evaluate the model in cartesian coordinates
+        :param x: input q[], or [qx[], qy[]]
+        :return: scattering function P(q[])
         """
         # set effective radius and scaling factor before run
         self._set_effect_radius()
         self._set_scale_factor()
-        return self.params['scale_factor']*self.p_model.evalDistribution(x)* self.s_model.evalDistribution(x)
+        out = self.params['scale_factor'] * self.p_model.evalDistribution(x) * \
+                        self.s_model.evalDistribution(x)
+        return out
 
     def set_dispersion(self, parameter, dispersion):
         """
-            Set the dispersion object for a model parameter
-            @param parameter: name of the parameter [string]
-            @dispersion: dispersion object of type DispersionModel
-        """
-        value= None
+        Set the dispersion object for a model parameter
+        :param parameter: name of the parameter [string]
+        :dispersion: dispersion object of type DispersionModel
+        """
+        value = None
         try:
             if parameter in self.p_model.dispersion.keys():
-                value= self.p_model.set_dispersion(parameter, dispersion)
+                value = self.p_model.set_dispersion(parameter, dispersion)
             self._set_dispersion()
             return value
@@ -288,9 +295,14 @@
         """
         description = ""
-        description += "Note:1) The effect_radius (effective radius) of %s \n"% (s_model.name)
-        description +="             is automatically calculated from size parameters (radius...).\n"
-        description += "         2) For non-spherical shape, this approximation is valid \n"
-        description += "            only for limited systems. Thus, use it at your own risk.\n"
-        description +="See %s description and %s description \n"%( p_model.name, s_model.name )
+        description += "Note:1) The effect_radius (effective radius) of %s \n"%\
+                                                                (s_model.name)
+        description += "             is automatically calculated "
+        description += "from size parameters (radius...).\n"
+        description += "         2) For non-spherical shape, "
+        description += "this approximation is valid \n"
+        description += "            only for limited systems. "
+        description += "Thus, use it at your own risk.\n"
+        description += "See %s description and %s description \n"% \
+                                                ( p_model.name, s_model.name )
         description += "        for details of individual models."
         self.description += description
Index: sansmodels/src/sans/models/UnifiedPowerRgModel.py
===================================================================
--- sansmodels/src/sans/models/UnifiedPowerRgModel.py	(revision eace08eb07c76dcd6039d2aa82a85ba2f9ce4336)
+++ sansmodels/src/sans/models/UnifiedPowerRgModel.py	(revision 7fdb332db7da9478616e379581e7014dc9448a0e)
@@ -1,3 +1,2 @@
-   
 from sans.models.BaseComponent import BaseComponent
 from math import exp, sqrt
@@ -13,10 +12,12 @@
         BaseComponent.__init__(self)
         """
-        :param multfactor: number of levels in the model, assumes 0<= level# <=5.
+        :param multfactor: number of levels in the model, 
+            assumes 0<= level# <=5.
         """
 
         ## Setting  model name model description
         self.name = "UnifiedPowerRg"
-        self.description="""Multiple Levels of Unified Exponential/Power-law Method.
+        self.description = """
+        Multiple Levels of Unified Exponential/Power-law Method.
         Up to Level 6 is provided.
         Note; the additional Level 0 is an inverse linear function, 
@@ -53,7 +54,7 @@
         
         ## functional multiplicity of the model
-        self.multiplicity_info = [max_level_n,"Level No.:",[],[]]
-    
-    def _unifiedpowerrg(self,x):
+        self.multiplicity_info = [max_level_n, "Level No.:", [], []]
+    
+    def _unifiedpowerrg(self, x):
         """
         Scattering function
@@ -73,23 +74,24 @@
             return answer
         # rearrange the parameters for the given label no.
-        for ind in range(1,l_num+1):
+        for ind in range(1, l_num+1):
             # get exp term
-            exp_now = exp(-power(x*self.params['Rg%s'% ind],2)/3.0)
+            exp_now = exp(-power(x*self.params['Rg%s'% ind], 2)/3.0)
             # get erf term
             erf_now = erf(x*self.params['Rg%s'% ind]/sqrt(6.0))
             # get power term
-            pow_now = power((erf_now*erf_now*erf_now/x),self.params['power%s'% ind])
+            pow_now = power((erf_now*erf_now*erf_now/x), 
+                            self.params['power%s'% ind])
             # get next exp term only if it exists
             try:
-                exp_next = exp(-power(x*self.params['Rg%s'% (ind+1)],2)/3.0)
+                exp_next = exp(-power(x*self.params['Rg%s'% (ind+1)], 2)/3.0)
             except:
                 exp_next = 1.0
             # get to the calculation
-            answer += self.params['G%s'% ind]*exp_now + self.params['B%s'% ind]* \
-                            exp_next * pow_now
+            answer += self.params['G%s'% ind]*exp_now + \
+                            self.params['B%s'% ind] * exp_next * pow_now
         # take care of the singular point
         if x == 0.0:
             answer = 0.0
-            for ind in range(1,l_num+1):
+            for ind in range(1, l_num+1):
                 answer += self.params['G%s'% ind]
         # get scaled
@@ -117,5 +119,5 @@
         l_num = self.level_num
         # rearrange the parameters for the given label no.
-        for ind in range(0,l_num+1):
+        for ind in range(0, l_num+1):
             if ind == 0:
                 continue
@@ -128,9 +130,9 @@
             # Set reasonably define default values that consistent 
             # w/NIST for label #1
-            self.params['G%s'% ind] = 0.3*mult*pow(10, \
+            self.params['G%s'% ind] = 0.3 * mult * pow(10, \
                             (l_num+1 - float('%s'% ind)))
-            self.params['Rg%s'% ind] = 21.0/mult*pow(10, \
+            self.params['Rg%s'% ind] = 21.0 / mult * pow(10, \
                               (l_num - float('%s'% ind)))
-            self.params['B%s'% ind] = 6e-03/mult*pow(10, \
+            self.params['B%s'% ind] = 6e-03/mult * pow(10, \
                            -(l_num+1 - float('%s'% ind)))
             self.params['power%s'% ind] = 2.0 * mul_pow
@@ -146,5 +148,5 @@
         self.details['scale'] = ['', None, None]
         # rearrange the parameters for the given label no.
-        for ind in range(0,self.level_num+1):
+        for ind in range(0, self.level_num+1):
             if ind == 0:
                 continue
@@ -215,5 +217,6 @@
             return self._unifiedpowerrg(x)
         elif x.__class__.__name__ == 'tuple':
-            raise ValueError, "Tuples are not allowed as input to BaseComponent models"
+            msg = "Tuples are not allowed as input to BaseComponent models"
+            raise ValueError, msg
         else:
             return self._unifiedpowerrg(x)
@@ -233,5 +236,6 @@
             return self._unifiedpowerrg(x)
         elif x.__class__.__name__ == 'tuple':
-            raise ValueError, "Tuples are not allowed as input to BaseComponent models"
+            msg = "Tuples are not allowed as input to BaseComponent models"
+            raise ValueError, msg
         else:
             return self._unifiedpowerrg(x)
