Avoid building lists unnecessarily

Author: Armavica

pytensor/graph/rewriting/utils.py

@@ -114,7 +114,7 @@ def is_same_graph_with_merge(var1, var2, givens=None):
     # We also need to make sure we replace a Variable if it is present in
     # `givens`.
     vars_replaced = [givens.get(v, v) for v in fgraph.outputs]
-    o1, o2 = [v.owner for v in vars_replaced]
+    o1, o2 = (v.owner for v in vars_replaced)
     if o1 is None and o2 is None:
         # Comparing two single-Variable graphs: they are equal if they are
         # the same Variable.

pytensor/link/c/cmodule.py

@@ -2244,7 +2244,7 @@ def join_options(init_part):
                                 if len(version) != 3:
                                     # Unexpected, but should not be a problem
                                     continue
-                                mj, mn, patch = [int(vp) for vp in version]
+                                mj, mn, patch = (int(vp) for vp in version)
                                 if (
                                     ((mj, mn) == (4, 6) and patch < 4)
                                     or ((mj, mn) == (4, 7) and patch <= 3)

pytensor/link/numba/dispatch/basic.py

@@ -209,7 +209,7 @@ def make_slice_from_constant(context, builder, ty, pyval):
             default_stop_pos,
             default_stop_neg,
             default_step,
-        ) = [context.get_constant(types.intp, x) for x in get_defaults(context)]
+        ) = (context.get_constant(types.intp, x) for x in get_defaults(context))
 
         step = pyval.step
         if step is None:

pytensor/tensor/blas.py

@@ -943,7 +943,7 @@ def make_node(self, *inputs):
             )
         z, a, x, y, b = inputs
 
-        zr, xr, yr = [set(view_roots(i)) for i in (z, x, y)]
+        zr, xr, yr = (set(view_roots(i)) for i in (z, x, y))
 
         # We want the gemm to be inplace. When this op is inplace, it
         # declare to be inplace only on z. So to make it safe, we

pytensor/tensor/math.py

@@ -1909,7 +1909,7 @@ def make_node(self, *inputs):
                 "pytensor.tensor.dot instead."
             )
 
-        sx, sy = [input.type.shape for input in inputs]
+        sx, sy = (input.type.shape for input in inputs)
         if len(sy) == 2:
             sz = sx[:-1] + sy[-1:]
         elif len(sy) == 1:

pytensor/tensor/nlinalg.py

@@ -250,7 +250,7 @@ def make_node(self, x):
     def perform(self, node, inputs, outputs):
         (x,) = inputs
         (w, v) = outputs
-        w[0], v[0] = [z.astype(x.dtype) for z in self._numop(x)]
+        w[0], v[0] = (z.astype(x.dtype) for z in self._numop(x))
 
     def infer_shape(self, fgraph, node, shapes):
         n = shapes[0][0]

tests/link/jax/test_scan.py

@@ -87,9 +87,9 @@ def seir_one_step(ct0, dt0, st0, et0, it0, logp_c, logp_d, beta, gamma, delta):
     s0, e0, i0 = 100, 50, 25
     logp_c0 = np.array(0.0, dtype=config.floatX)
     logp_d0 = np.array(0.0, dtype=config.floatX)
-    beta_val, gamma_val, delta_val = [
+    beta_val, gamma_val, delta_val = (
         np.array(val, dtype=config.floatX) for val in [0.277792, 0.135330, 0.108753]
-    ]
+    )
     C = np.array([3, 5, 8, 13, 21, 26, 10, 3], dtype=np.int32)
     D = np.array([1, 2, 3, 7, 9, 11, 5, 1], dtype=np.int32)
 

tests/link/numba/test_scan.py

@@ -223,9 +223,9 @@ def seir_one_step(ct0, dt0, st0, et0, it0, logp_c, logp_d, beta, gamma, delta):
     s0, e0, i0 = 100, 50, 25
     logp_c0 = np.array(0.0, dtype=config.floatX)
     logp_d0 = np.array(0.0, dtype=config.floatX)
-    beta_val, gamma_val, delta_val = [
+    beta_val, gamma_val, delta_val = (
         np.array(val, dtype=config.floatX) for val in [0.277792, 0.135330, 0.108753]
-    ]
+    )
     C = np.array([3, 5, 8, 13, 21, 26, 10, 3], dtype=np.int32)
     D = np.array([1, 2, 3, 7, 9, 11, 5, 1], dtype=np.int32)
 

tests/sparse/test_basic.py

@@ -3273,7 +3273,7 @@ def test_op_ss(self):
 
                 tested = f(*data)
 
-                x, y = [m.toarray() for m in data]
+                x, y = (m.toarray() for m in data)
                 expected = np.dot(x, y)
 
                 assert tested.format == format

tests/tensor/rewriting/test_basic.py

@@ -490,7 +490,7 @@ def test_local_remove_useless_2(self):
         fg = FunctionGraph(outputs=[assert_op(x, y, 1)], clone=False)
         fg_res = rewrite_graph(fg, include=["canonicalize", "specialize"])
         topo = fg_res.toposort()
-        (assert_node,) = [node for node in topo if isinstance(node.op, CheckAndRaise)]
+        (assert_node,) = (node for node in topo if isinstance(node.op, CheckAndRaise))
         assert assert_node.inputs == [x, y]
 
     def test_local_remove_useless_3(self):
@@ -500,7 +500,7 @@ def test_local_remove_useless_3(self):
         fg = FunctionGraph(outputs=[assert_op(x, y, 0)], clone=False)
         fg_res = rewrite_graph(fg, include=["canonicalize", "specialize"])
         topo = fg_res.toposort()
-        (assert_node,) = [node for node in topo if isinstance(node.op, CheckAndRaise)]
+        (assert_node,) = (node for node in topo if isinstance(node.op, CheckAndRaise))
         assert assert_node.inputs[:2] == [x, y]
         assert assert_node.inputs[-1].data == 0
 

tests/tensor/rewriting/test_elemwise.py

@@ -277,13 +277,13 @@ class TestFusion:
     def my_init(dtype="float64", num=0):
         return np.zeros((5, 5), dtype=dtype) + num
 
-    fw, fx, fy, fz = [
+    fw, fx, fy, fz = (
         tensor(dtype="float32", shape=(None,) * 2, name=n) for n in "wxyz"
-    ]
-    dw, dx, dy, dz = [
+    )
+    dw, dx, dy, dz = (
         tensor(dtype="float64", shape=(None,) * 2, name=n) for n in "wxyz"
-    ]
-    ix, iy, iz = [tensor(dtype="int32", shape=(None,) * 2, name=n) for n in "xyz"]
+    )
+    ix, iy, iz = (tensor(dtype="int32", shape=(None,) * 2, name=n) for n in "xyz")
     fv = fvector("v")
     fs = fscalar("s")
     fwv = my_init("float32", 1)

tests/tensor/rewriting/test_math.py

@@ -1097,15 +1097,15 @@ def my_init(shp, dtype="float64", num=0):
             ret = np.zeros(shp, dtype=dtype) + num
             return ret
 
-        fw, fx, fy, fz = [
+        fw, fx, fy, fz = (
             tensor(dtype="float32", shape=(None,) * len(shp), name=n) for n in "wxyz"
-        ]
-        dw, dx, dy, dz = [
+        )
+        dw, dx, dy, dz = (
             tensor(dtype="float64", shape=(None,) * len(shp), name=n) for n in "wxyz"
-        ]
-        ix, iy, iz = [
+        )
+        ix, iy, iz = (
             tensor(dtype="int32", shape=(None,) * len(shp), name=n) for n in "xyz"
-        ]
+        )
         fv = fvector("v")
         fs = fscalar("s")
 

tests/tensor/test_basic.py

@@ -3656,7 +3656,7 @@ def test_stacklists():
     result = f(1, 2, 3, 4)
     assert result.shape == (2, 2, 1)
 
-    a, b, c, d = [matrix(x) for x in "abcd"]
+    a, b, c, d = (matrix(x) for x in "abcd")
     X = stacklists([[a, b], [c, d]])
     f = function([a, b, c, d], X)
     x = np.ones((4, 4), "float32")

tests/tensor/test_blas.py

@@ -124,11 +124,11 @@ def cmp(self, z_, a_, x_, y_, b_):
             b = np.asarray(b_, dtype=dtype)
 
             def cmp_linker(z, a, x, y, b, l):
-                z, a, x, y, b = [np.asarray(p) for p in (z, a, x, y, b)]
+                z, a, x, y, b = (np.asarray(p) for p in (z, a, x, y, b))
                 z_orig = z.copy()
-                tz, ta, tx, ty, tb = [
+                tz, ta, tx, ty, tb = (
                     as_tensor_variable(p).type() for p in (z, a, x, y, b)
-                ]
+                )
 
                 f = inplace_func(
                     [tz, ta, tx, ty, tb],
@@ -309,11 +309,11 @@ def test_transposes(self):
         C = rng.random((4, 5))[:, :4]
 
         def t(z, x, y, a=1.0, b=0.0, l="c|py", dt="float64"):
-            z, a, x, y, b = [_asarray(p, dtype=dt) for p in (z, a, x, y, b)]
+            z, a, x, y, b = (_asarray(p, dtype=dt) for p in (z, a, x, y, b))
             # z_orig = z.copy()
             z_after = self._gemm(z, a, x, y, b)
 
-            tz, ta, tx, ty, tb = [shared(p) for p in (z, a, x, y, b)]
+            tz, ta, tx, ty, tb = (shared(p) for p in (z, a, x, y, b))
 
             # f = inplace_func([tz,ta,tx,ty,tb], gemm_inplace(tz,ta,tx,ty,tb),
             #                 mode = Mode(optimizer = None, linker=l))
@@ -368,13 +368,13 @@ def test_non_contiguous(self):
         C = rng.random((4, 4, 3))
 
         def t(z, x, y, a=1.0, b=0.0, l="c|py", dt="float64"):
-            z, a, x, y, b = [_asarray(p, dtype=dt) for p in (z, a, x, y, b)]
+            z, a, x, y, b = (_asarray(p, dtype=dt) for p in (z, a, x, y, b))
             z_orig = z.copy()
             z_after = np.zeros_like(z_orig)
             for i in range(3):
                 z_after[:, :, i] = self._gemm(z[:, :, i], a, x[:, :, i], y[:, :, i], b)
 
-            tz, ta, tx, ty, tb = [shared(p) for p in (z, a, x, y, b)]
+            tz, ta, tx, ty, tb = (shared(p) for p in (z, a, x, y, b))
             for i in range(3):
                 f_i = inplace_func(
                     [],
@@ -1559,7 +1559,7 @@ def get_data(self, x_stride=1, y_stride=1):
         return alpha, beta, a, x, y
 
     def test_simple(self):
-        alpha, beta, a, x, y = [shared(value) for value in self.get_data()]
+        alpha, beta, a, x, y = (shared(value) for value in self.get_data())
         desired_oy = (
             alpha.get_value() * matrixmultiply(a.get_value(), x.get_value())
             + beta.get_value() * y.get_value()
@@ -1597,7 +1597,7 @@ def test_default_beta_y(self):
     def test_simple_transpose(self):
         vs = self.get_data()
         alpha_v, beta_v, a_v, x_v, y_v = vs
-        alpha, beta, a, x, y = [shared(v) for v in vs]
+        alpha, beta, a, x, y = (shared(v) for v in vs)
 
         desired_oy = alpha_v * matrixmultiply(np.transpose(a_v), x_v) + beta_v * y_v
 
@@ -1613,7 +1613,7 @@ def test_simple_transpose(self):
     def test_x_stride(self):
         vs = self.get_data(x_stride=2)
         alpha_v, beta_v, a_v, x_v, y_v = vs
-        alpha, beta, a, x, y = [shared(v) for v in vs]
+        alpha, beta, a, x, y = (shared(v) for v in vs)
 
         desired_oy = alpha_v * matrixmultiply(a_v, x_v[::2]) + beta_v * y_v
 
@@ -1629,7 +1629,7 @@ def test_x_stride(self):
     def test_x_stride_transpose(self):
         vs = self.get_data(x_stride=2)
         alpha_v, beta_v, a_v, x_v, y_v = vs
-        alpha, beta, a, x, y = [shared(v) for v in vs]
+        alpha, beta, a, x, y = (shared(v) for v in vs)
 
         desired_oy = (
             alpha_v * matrixmultiply(np.transpose(a_v), x_v[::2]) + beta_v * y_v
@@ -1647,7 +1647,7 @@ def test_x_stride_transpose(self):
     def test_y_stride(self):
         vs = self.get_data(y_stride=2)
         alpha_v, beta_v, a_v, x_v, y_v = vs
-        alpha, beta, a, x, y = [shared(v) for v in vs]
+        alpha, beta, a, x, y = (shared(v) for v in vs)
 
         desired_oy = alpha_v * matrixmultiply(a_v, x_v) + beta_v * y_v[::2]
 
@@ -1663,7 +1663,7 @@ def test_y_stride(self):
     def test_y_stride_transpose(self):
         vs = self.get_data(y_stride=2)
         alpha_v, beta_v, a_v, x_v, y_v = vs
-        alpha, beta, a, x, y = [shared(v) for v in vs]
+        alpha, beta, a, x, y = (shared(v) for v in vs)
 
         desired_oy = (
             alpha_v * matrixmultiply(np.transpose(a_v), x_v) + beta_v * y_v[::2]
@@ -1681,7 +1681,7 @@ def test_y_stride_transpose(self):
     def test_a_strides(self):
         vs = self.get_data()
         alpha_v, beta_v, a_v, x_v, y_v = vs
-        alpha, beta, a, x, y = [shared(v) for v in vs]
+        alpha, beta, a, x, y = (shared(v) for v in vs)
         a_v = a_v[::-1, ::-1]
         a.set_value(
             a.get_value(borrow=True, return_internal_type=True)[::-1, ::-1], borrow=True
@@ -1701,7 +1701,7 @@ def test_a_strides(self):
     def test_a_strides_transpose(self):
         vs = self.get_data()
         alpha_v, beta_v, a_v, x_v, y_v = vs
-        alpha, beta, a, x, y = [shared(v) for v in vs]
+        alpha, beta, a, x, y = (shared(v) for v in vs)
         a_v = a_v[::-1, ::-1]
         a.set_value(
             a.get_value(borrow=True, return_internal_type=True)[::-1, ::-1], borrow=True

tests/tensor/test_nlinalg.py

@@ -331,7 +331,7 @@ def test_eval(self):
         A = matrix(dtype=self.dtype)
         assert [e.eval({A: [[1]]}) for e in self.op(A)] == [[1.0], [[1.0]]]
         x = [[0, 1], [1, 0]]
-        w, v = [e.eval({A: x}) for e in self.op(A)]
+        w, v = (e.eval({A: x}) for e in self.op(A))
         assert_array_almost_equal(np.dot(x, v), w * v)
 
 
@@ -341,8 +341,8 @@ class TestEigh(TestEig):
     def test_uplo(self):
         S = self.S
         a = matrix(dtype=self.dtype)
-        wu, vu = [out.eval({a: S}) for out in self.op(a, "U")]
-        wl, vl = [out.eval({a: S}) for out in self.op(a, "L")]
+        wu, vu = (out.eval({a: S}) for out in self.op(a, "U"))
+        wl, vl = (out.eval({a: S}) for out in self.op(a, "L"))
         assert_array_almost_equal(wu, wl)
         assert_array_almost_equal(vu * np.sign(vu[0, :]), vl * np.sign(vl[0, :]))