MAINT: rename broadcast_collect paramnames to use snake_case

blaze/compute/dask.py

@@ -39,8 +39,11 @@ def compute_broadcast(expr, *data, **kwargs):
                     *concat((dat, tuple(range(ndim(dat))[::-1])) for dat in data))
 
     def optimize_array(expr, *data):
-        return broadcast_collect(expr, Broadcastable=Broadcastable,
-                                       WantToBroadcast=Broadcastable)
+        return broadcast_collect(
+            expr,
+            broadcastable=Broadcastable,
+            want_to_broadcast=Broadcastable,
+        )
 
     for i in range(5):
         compute_up.register(Broadcast, *([(Array, Number)] * i))(compute_broadcast)

blaze/compute/numexpr.py

@@ -59,13 +59,15 @@ def print_numexpr(leaves, expr):
         return '%s%s' % (expr.symbol, parenthesize(child))
     if isinstance(expr, isnan):
         child = print_numexpr(leaves, expr._child)
-        return '%s != %s' % (parenthsize(child), parenthesize(child))
+        return '%s != %s' % (parenthesize(child), parenthesize(child))
     raise NotImplementedError("Operation %s not supported by numexpr" %
                               type(expr).__name__)
 
 
 Broadcastable = WantToBroadcast = BinOp, UnaryOp
 
-broadcast_numexpr_collect = curry(broadcast_collect,
-                                  Broadcastable=Broadcastable,
-                                  WantToBroadcast=WantToBroadcast)
+broadcast_numexpr_collect = curry(
+    broadcast_collect,
+    broadcastable=Broadcastable,
+    want_to_broadcast=WantToBroadcast
+)

blaze/compute/pytables.py

@@ -157,8 +157,11 @@ def compute_up(expr, x, **kwargs):
 
 @dispatch(Expr, tb.Table)
 def optimize(expr, seq):
-    return broadcast_numexpr_collect(expr, Broadcastable=Broadcastable,
-                                     WantToBroadcast=WantToBroadcast)
+    return broadcast_numexpr_collect(
+        expr,
+        broadcastable=Broadcastable,
+        want_to_broadcast=WantToBroadcast,
+    )
 
 
 @dispatch(nelements, tb.Table)

blaze/expr/tests/test_broadcast.py

@@ -59,8 +59,11 @@ def test_optimize_broadcast():
     expr = (t.distinct().x + 1).distinct()
 
     expected = broadcast(t.distinct().x + 1, [t.distinct()]).distinct()
-    result = broadcast_collect(expr, Broadcastable=(Field, Arithmetic),
-                                     WantToBroadcast=(Field, Arithmetic))
+    result = broadcast_collect(
+        expr,
+        broadcastable=(Field, Arithmetic),
+        want_to_broadcast=(Field, Arithmetic),
+    )
 
     assert result.isidentical(expected)
 
@@ -76,8 +79,11 @@ def test_leaves_of_type():
 def test_broadcast_collect_doesnt_collect_scalars():
     expr = xx + yy * a
 
-    assert broadcast_collect(expr, Broadcastable=Arithmetic,
-                                   WantToBroadcast=Arithmetic).isidentical(expr)
+    assert broadcast_collect(
+        expr,
+        broadcastable=Arithmetic,
+        want_to_broadcast=Arithmetic,
+    ).isidentical(expr)
 
 
 def test_table_broadcast():