Remove all parametric test machinery, which is super fragile.

Also, turn empty module exceptions into a function call so we can
gradually refactor that out and allow for empty modules.

Author: fperez

brainx/modularity.py

@@ -29,6 +29,15 @@
 # Our own modules
 import util
 
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+def empty_module(msg='Empty module'):
+    """Raise an exception if an empty module is found"""
+
+    raise ValueError(msg)
+
+
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
@@ -348,9 +357,9 @@ def apply_module_split(self, m, n1, n2, split_modules, e_new, a_new):
 
         # For now, rather than renumbering, just check if this ever happens
         if len(self.index[m1])<1:
-            raise ValueError('Empty module after module split, old mod')
+            empty_module('Empty module after module split, old mod')
         if len(self.index[m2])<1:
-            raise ValueError('Empty module after module split, new mod')
+            empty_module('Empty module after module split, new mod')
 
     def node_update(self, n, m1, m2):
         """Moves a single node within or between modules
@@ -452,7 +461,7 @@ def apply_node_update(self, n, m1, m2, node_moved_mods, e_new, a_new):
 
         # This checks whether there is an empty module. If so, renames the keys.
         if len(self.index[m1])<1:
-            raise ValueError('Empty module after node move')
+            empty_module('Empty module after node move')
             #self.index.pop(m1)
             #rename_keys(self.index,m1)
             #if m1 < m2:
@@ -1005,9 +1014,9 @@ def mutual_information(d1, d2):
     # the entire partitions, we look for this problem at this stage, and bail
     # if there was an empty module.
 ##     if (nsum_row==0).any():
-##         raise ValueError("Empty module in second partition.")
+##         empty_module("Empty module in second partition.")
 ##     if (nsum_col==0).any():
-##         raise ValueError("Empty module in first partition.")
+##         empty_module("Empty module in first partition.")
 
     # nn is the total number of nodes
     nn = nsum_row.sum()
@@ -1136,7 +1145,7 @@ def simulated_annealing(g, p0=None, temperature = 50, temp_scaling = 0.995, tmin
                                             graph_partition.modularity(), 11)
                     for mod in graph_partition.index:
                         if len(graph_partition.index[mod]) < 1:
-                            raise ValueError('Empty module after module %s,SA' % (movetype))
+                            empty_module('Empty module after module %s,SA' % (movetype))
 
 
                 #maybe store the best one here too?
@@ -1206,7 +1215,7 @@ def simulated_annealing(g, p0=None, temperature = 50, temp_scaling = 0.995, tmin
 
                         for mod in graph_partition.index:
                             if len(graph_partition.index[mod]) < 1:
-                                raise ValueError('Empty module after ndoe move,SA')
+                                empty_module('Empty module after ndoe move,SA')
 
 
                 #else:
@@ -1264,7 +1273,7 @@ def simulated_annealing(g, p0=None, temperature = 50, temp_scaling = 0.995, tmin
 
         for mod in graph_part_final.index:
             if len(graph_part_final.index[mod]) < 1:
-                raise ValueError('LAST CHECK: Empty module after module %s,SA' % (movetype))
+                empty_module('LAST CHECK: Empty module after module %s,SA' % (movetype))
 
     if extra_info:
         extra_dict = dict(energy = energy_array, temp = temp_array)

brainx/recarrutil.py

@@ -126,7 +126,8 @@ def op(a1, a2, out=None):
 # For methods in the array interface that take an axis argument, the pattern is
 # always the same: extrude, operate, intrude.  So we just auto-generate these
 # functions here.
-binops = [('add',np.add), ('subtract',np.subtract), ('multiply',np.multiply), ('divide',np.divide) ]
+binops = [('add', np.add), ('subtract', np.subtract),
+          ('multiply', np.multiply), ('divide', np.divide) ]
 #binops = [('add',np.add), np.subtract, np.multiply, np.divide ]
 for name, func in binops:
     exec "%s = binop_factory(func)" % name
@@ -171,18 +172,19 @@ def test_reductions():
         ymeth = getattr(y, fname)
         for axis in [None,0,1,-1,-2]:
             zred = reduction(z,axis)
-            yield(nt.assert_equal, zred.x, xmeth(axis))
-            yield(nt.assert_equal, zred.y, ymeth(axis))
+            nt.assert_equal(zred.x, xmeth(axis))
+            nt.assert_equal(zred.y, ymeth(axis))
 
 
 def test_binops():
     x, y, z, w = mk_xyzw()
+    binop_names = [n for (n, op) in binops]
     for fname in binop_names:
         op = eval(fname)
         npop = getattr(np, fname)
         opres = op(z,w)
-        yield(nt.assert_equal, opres.x, npop(z.x, w.x) )
-        yield(nt.assert_equal, opres.y, npop(z.y, w.y) )
+        nt.assert_equal(opres.x, npop(z.x, w.x))
+        nt.assert_equal(opres.y, npop(z.y, w.y))
 
 # Test support utilities