docformatter

Author: sbillinge

src/diffpy/srfit/equation/builder.py

@@ -259,9 +259,9 @@ def deRegisterBuilder(self, name):
     def wipeout(self, eq):
         """Invalidate the specified equation and remove it from the factory.
 
-        This will remove the equation from the purview of the factory and
-        also change its formula to return NaN.  This ensures that eq does
-        not observe any object in the factory and thus prevents its indirect
+        This will remove the equation from the purview of the factory and also
+        change its formula to return NaN.  This ensures that eq does not
+        observe any object in the factory and thus prevents its indirect
         pickling with the factory because of observer callback function.
 
         No return value.
@@ -635,8 +635,7 @@ def getBuilder(name):
 
 def __wrapNumpyOperators():
     """Export all numpy operators as OperatorBuilder instances in the module
-    namespace.
-    """
+    namespace."""
     for name in dir(numpy):
         op = getattr(numpy, name)
         if isinstance(op, numpy.ufunc):
@@ -648,8 +647,7 @@ def __wrapNumpyOperators():
 def __wrapSrFitOperators():
     """Export all non-base operators from the
     diffpy.srfit.equation.literals.operators module as OperatorBuilder
-    instances in the module namespace.
-    """
+    instances in the module namespace."""
     opmod = literals.operators
     excluded_types = set((opmod.CustomOperator, opmod.UFuncOperator))
     # check if opmod member should be wrapped as OperatorBuilder

src/diffpy/srfit/equation/equationmod.py

@@ -20,20 +20,12 @@
 Arguments. The non-constant arguments are accessible as attributes of the
 Equation instance and can be passed as arguments to __call__.
 
-Example
-> # make a Literal tree. Here's a simple one
-> add = AdditionOperator()
-> a = Argument(name="a") # Don't forget to name these!
-> b = Argument(name="b")
-> add.addLiteral(a)
-> add.addLiteral(b)
-> # make an Equation instance and pass the root
-> eq = Equation(root = add)
-> eq(a=3, b=4) # returns 7
-> eq(a=2) # remembers b=4, returns 6
-> eq.a.setValue(-3)
-> eq.b.setValue(3)
-> eq() # uses last assignment of a and b, returns 0
+Example > # make a Literal tree. Here's a simple one > add = AdditionOperator()
+> a = Argument(name="a") # Don't forget to name these! > b = Argument(name="b")
+> add.addLiteral(a) > add.addLiteral(b) > # make an Equation instance and pass
+the root > eq = Equation(root = add) > eq(a=3, b=4) # returns 7 > eq(a=2) #
+remembers b=4, returns 6 > eq.a.setValue(-3) > eq.b.setValue(3) > eq() # uses
+last assignment of a and b, returns 0
 
 See the class documentation for more information.
 """
@@ -88,7 +80,6 @@ def __init__(self, name = None, root = None):
         root    --  The root node of the Literal tree (default None). If root
                     is not passed here, you must call the 'setRoot' method to
                     set or change the root node.
-
         """
         # Operator stuff. We circumvent Operator.__init__ since we're using
         # args as a property. We cannot set it, as the Operator tries to do.
@@ -110,8 +101,8 @@ def symbol(self):
     def operation(self, *args, **kw):
         """Evaluate this Equation object.
 
-        Same as the __call__ method.  This method is used via
-        the Operator interface.
+        Same as the __call__ method.  This method is used via the Operator
+        interface.
 
         Return the result of __call__(*args, **kw).
         """
@@ -150,7 +141,6 @@ def setRoot(self, root):
 
         Raises:
         ValueError if errors are found in the Literal tree.
-
         """
 
         # Validate the new root
@@ -179,11 +169,10 @@ def __call__(self, *args, **kw):
         """Call the equation.
 
         New Argument values are acceped as arguments or keyword assignments (or
-        both).  The order of accepted arguments is given by the args
-        attribute.  The Equation will remember values set in this way.
+        both).  The order of accepted arguments is given by the args attribute.
+        The Equation will remember values set in this way.
 
-        Raises
-        ValueError when a passed argument cannot be found
+        Raises ValueError when a passed argument cannot be found
         """
         # Process args
         for idx, val in enumerate(args):
@@ -206,7 +195,6 @@ def swap(self, oldlit, newlit):
         """Swap a literal in the equation for another.
 
         Note that this may change the root and the operation interface
-
         """
         newroot = swap(self.root, oldlit, newlit)
         self.setRoot(newroot)

src/diffpy/srfit/equation/literals/__init__.py

@@ -16,13 +16,14 @@
 """Building blocks for defining a lazy evaluation network.
 
 Literals are the building blocks of the evaluation network. An Argument holds
-the name and value of an equation variable. Operators are used to compose
-other Literals to produce a new value.
+the name and value of an equation variable. Operators are used to compose other
+Literals to produce a new value.
 
 Literal networks can be evaluated or have other actions performed on them by
 Visitors (in diffpy.srfit.equation.visitors). The Literal-Visitor relationship
-is that described by the Visitor pattern
-(http://en.wikipedia.org/wiki/Visitor_pattern).
+is that described by the Visitor pattern (
+
+http://en.wikipedia.org/wiki/Visitor_pattern).
 """
 
 __all__ = ["Argument", "Operator", "BinaryOperator", "CustomOperator",

src/diffpy/srfit/equation/literals/abcs.py

@@ -25,7 +25,10 @@
 
 @six.add_metaclass(ABCMeta)
 class LiteralABC(object):
-    """Abstract Base Class for Literal. See Literal for usage."""
+    """Abstract Base Class for Literal.
+
+    See Literal for usage.
+    """
 
     @abstractmethod
     def identify(self, visitor): pass
@@ -39,7 +42,10 @@ def getValue(self): pass
 
 
 class ArgumentABC(LiteralABC):
-    """Abstract Base Class for Argument. See Argument for usage."""
+    """Abstract Base Class for Argument.
+
+    See Argument for usage.
+    """
 
     @abstractmethod
     def setValue(self, value): pass
@@ -51,7 +57,10 @@ def setValue(self, value): pass
 
 
 class OperatorABC(LiteralABC):
-    """Abstract Base Class for Operator. See Operator for usage."""
+    """Abstract Base Class for Operator.
+
+    See Operator for usage.
+    """
 
     @abstractmethod
     def addLiteral(self, literal): pass

src/diffpy/srfit/equation/literals/argument.py

@@ -34,7 +34,6 @@ class Argument(Literal, ArgumentABC):
                 Constants may be given special treatment by the Visitors.
     _value  --  The value of the Argument. Modified with 'setValue'.
     value   --  Property for 'getValue' and 'setValue'.
-
     """
 
     const = None
@@ -58,7 +57,6 @@ def setValue(self, val):
         """Set the value of the Literal.
 
         val --  The value to assign
-
         """
         if isinstance(self._value, ndarray) or isinstance(val, ndarray):
             notequiv = not array_equal(self._value, val)

src/diffpy/srfit/equation/literals/literal.py

@@ -33,7 +33,6 @@ class Literal(Observable,LiteralABC):
     Attributes
     name    --  A name for this Literal (default None).
     _value  --  The value of the Literal.
-
     """
 
     name = None

src/diffpy/srfit/equation/literals/operators.py

@@ -21,8 +21,9 @@
 
 The Operator class contains all the information necessary to be identified and
 evaluated by a Visitor. Thus, a single onOperator method exists in the Visitor
-base class. Other Operators can be derived from Operator (see AdditionOperator),
-but they all identify themselves with the Visitor.onOperator method.
+base class. Other Operators can be derived from Operator (see
+AdditionOperator), but they all identify themselves with the Visitor.onOperator
+method.
 """
 
 __all__ = ["Operator", "AdditionOperator", "SubtractionOperator",
@@ -103,7 +104,6 @@ def addLiteral(self, literal):
         leftmost argument. The last is the rightmost.
 
         Raises ValueError if the literal causes a self-reference.
-
         """
         # Make sure we don't have self-reference
         self._loopCheck(literal)
@@ -134,8 +134,7 @@ def _loopCheck(self, literal):
 
 
 class UnaryOperator(Operator):
-    """
-    Abstract class for an unary operator with one input and one result.
+    """Abstract class for an unary operator with one input and one result.
 
     This base class defines the `nin` and `nout` attributes.  The derived
     concrete operator must provide the remaining abstract attributes
@@ -148,8 +147,7 @@ class UnaryOperator(Operator):
 
 
 class BinaryOperator(Operator):
-    """
-    Abstract class for a binary operator with two inputs and one result.
+    """Abstract class for a binary operator with two inputs and one result.
 
     This base class defines the `nin` and `nout` attributes.  The derived
     concrete operator must define the remaining abstract attributes
@@ -162,8 +160,7 @@ class BinaryOperator(Operator):
 
 
 class CustomOperator(Operator):
-    """
-    Concrete class for a user-defined Operator.
+    """Concrete class for a user-defined Operator.
 
     Use the `makeOperator` factory function to create an instance.
     """

src/diffpy/srfit/equation/visitors/__init__.py

@@ -19,8 +19,9 @@
 (diffpy.srfit.equation.literals). Visitors are used to validate, print and
 extracting Arguments from Literal networks.
 
-The Literal-Visitor relationship is that described by the Visitor pattern
-(http://en.wikipedia.org/wiki/Visitor_pattern).
+The Literal-Visitor relationship is that described by the Visitor pattern (
+
+http://en.wikipedia.org/wiki/Visitor_pattern).
 """
 
 from __future__ import print_function

src/diffpy/srfit/equation/visitors/argfinder.py

@@ -29,7 +29,6 @@ class ArgFinder(Visitor):
     Attributes
     args    --  The list of collected Arguments
     getconsts  --  Flag indicating whether to grab constant arguments.
-
     """
 
     def __init__(self, getconsts = True):
@@ -38,7 +37,6 @@ def __init__(self, getconsts = True):
         Arguments
         getconsts   --  Flag indicating whether to grap constant arguments
                         (default True).
-
         """
         self.args = []
         self.getconsts = getconsts

src/diffpy/srfit/equation/visitors/swapper.py

@@ -13,8 +13,7 @@
 #
 ##############################################################################
 
-"""Swapper for replacing a Literal in an equation with another Literals.
-"""
+"""Swapper for replacing a Literal in an equation with another Literals."""
 
 __all__ = ["Swapper"]
 
@@ -29,7 +28,6 @@ class Swapper(Visitor):
     Attributes:
     newlit  --  The literal to be placed into the literal tree.
     oldlit  --  The literal to be replaced.
-
     """
 
     def __init__(self, oldlit, newlit):
@@ -38,7 +36,6 @@ def __init__(self, oldlit, newlit):
         oldlit  --  The literal to be replaced.
         newlit  --  The literal to be placed into the literal tree. See the
                     class for how the replacement takes place.
-
         """
 
         self.newlit = newlit
@@ -52,7 +49,6 @@ def onArgument(self, arg):
         """Process an Argument node.
 
         Tell the parent to swap the old Argument with the replacement Literal.
-
         """
 
         if arg is self.oldlit:
@@ -64,7 +60,6 @@ def onOperator(self, op):
         """Process an Operator node.
 
         Tell the parent to swap the old Operator with the replacement Literal.
-
         """
 
         # Check to see if we need to swap out this Operator. If so, then we
@@ -122,7 +117,6 @@ def onEquation(self, eq):
         """Process an Equation node.
 
         This looks at the equation itself as well as the root.
-
         """
         if eq is self.oldlit:
             self._swap = True