cleanup

gof/_test_opt.py

@@ -247,26 +247,6 @@ class _test_PatternOptimizer(unittest.TestCase):
 #         assert str(g) == "[Op3(x, y)]"
 
 
-# class _test_PatternDescOptimizer(unittest.TestCase):
-    
-#     def test_replace_output(self):
-#         # replacing the whole graph
-#         x, y, z = inputs()
-#         e = op1(op2(x, y), z)
-#         g = env([x, y, z], [e])
-#         PatternDescOptimizer((Op1, (Op2, '1', '2'), '3'),
-#                              (Op4, '3', '2')).optimize(g)
-#         assert str(g) == "[Op4(z, y)]"
-
-#     def test_eq(self):
-#         x, y, z = inputs()
-#         e = op1(op_y(x, y, 37, 88), op2(op_y(y, z, 1, 7)))
-#         g = env([x, y, z], [e])
-#         PatternDescOptimizer((op_z, '1', '2'),
-#                              (op3, '2', '1')).optimize(g)
-#         assert str(g) == "[Op1(Op3(y, x), Op2(OpZ(y, z)))]"
-
-
 OpSubOptimizer = lambda op1, op2: TopoOptimizer(OpSub(op1, op2))
 OpSubOptimizer = lambda op1, op2: OpKeyOptimizer(OpSub(op1, op2))
 
@@ -384,42 +364,6 @@ class _test_MergeOptimizer(unittest.TestCase):
 
 
 
-# class _test_ConstantFinder(unittest.TestCase):
-
-#     def test_straightforward(self):
-#         x, y, z = inputs()
-#         y.data = 2
-#         z.data = 2
-#         e = op1(x, y, z)
-#         g = env([x], [e])
-#         ConstantFinder().optimize(g)
-#         assert y.constant and z.constant
-#         MergeOptimizer().optimize(g)
-#         assert str(g) == "[Op1(x, y, y)]" \
-#             or str(g) == "[Op1(x, z, z)]"
-
-#     def test_deep(self):
-#         x, y, z = inputs()
-#         y.data = 2
-#         z.data = 2
-#         e = op1(op2(x, y), op2(x, y), op2(x, z))
-#         g = env([x], [e])
-#         ConstantFinder().optimize(g)
-#         assert y.constant and z.constant
-#         MergeOptimizer().optimize(g)
-#         assert str(g) == "[Op1(*1 -> Op2(x, y), *1, *1)]" \
-#             or str(g) == "[Op1(*1 -> Op2(x, z), *1, *1)]"
-
-#     def test_destroyed_orphan_not_constant(self):
-#         x, y, z = inputs()
-#         y.data = 2
-#         z.data = 2
-#         e = op_d(x, op2(y, z)) # here x is destroyed by op_d
-#         g = env([y], [e])
-#         ConstantFinder().optimize(g)
-#         assert not getattr(x, 'constant', False) and z.constant
-#         MergeOptimizer().optimize(g)
-
 reenter = Exception("Re-Entered")
 class LoopyMacro(Macro):
     def __init__(self):
@@ -448,7 +392,7 @@ class _test_ExpandMacro(unittest.TestCase):
         x, y, z = inputs()
         e = Macro1()(x, y)
         g = Env([x, y], [e])
-        expand_macros.optimize(g)
+        ExpandMacros().optimize(g)
         assert str(g) == "[Op1(y, x)]"
         
     def test_loopy_1(self):

gof/_test_toolbox.py

@@ -100,14 +100,15 @@ class _test_NodeFinder(unittest.TestCase):
             if not len([x for x in g.get_nodes(type)]) == num:
                 self.fail((type, num))
 
-    def test_robustness(self):
-        x, y, z = inputs()
-        e = add(add(sigmoid(x), sigmoid(sigmoid(z))), dot(add(x, y), dot(y, z)))
-        g = Env([x, y, z], [e])
-        g.extend(NodeFinder())
-        gen = g.get_nodes(sigmoid) # I want to get Sigmoid instances
-        g.replace(e, add(x, y)) # but here I prune them all
-        assert len([x for x in gen]) == 0 # the generator should not yield them
+#     def test_robustness(self):
+#         # this test used to make sense to have, but it doesn't work like that anymore
+#         x, y, z = inputs()
+#         e = add(add(sigmoid(x), sigmoid(sigmoid(z))), dot(add(x, y), dot(y, z)))
+#         g = Env([x, y, z], [e])
+#         g.extend(NodeFinder())
+#         gen = g.get_nodes(sigmoid) # I want to get Sigmoid instances
+#         g.replace(e, add(x, y)) # but here I prune them all
+#         assert len([x for x in gen]) == 0 # the generator should not yield them
 
 
 

gof/utils.py

@@ -34,8 +34,9 @@ class scratchpad:
         self.__dict__.clear()
     def __update__(self, other):
         self.__dict__.update(other.__dict__)
+        return self
     def __str__(self):
-        print "scratch" + str(self.__dict__)
+        return "scratch" + str(self.__dict__)
 
 
 def memoize(f):