Fix RUF005

Author: Armavica

pymc/_version.py

@@ -98,10 +98,10 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=
 
     for command in commands:
         try:
-            dispcmd = str([command] + args)
+            dispcmd = str([command, *args])
             # remember shell=False, so use git.cmd on windows, not just git
             process = subprocess.Popen(
-                [command] + args,
+                [command, *args],
                 cwd=cwd,
                 env=env,
                 stdout=subprocess.PIPE,

pymc/backends/arviz.py

@@ -149,7 +149,7 @@ def insert(self, k: str, v, idx: int):
 
         # initialize if necessary
         if k not in self.trace_dict:
-            array_shape = (self._len,) + value_shape
+            array_shape = (self._len, *value_shape)
             self.trace_dict[k] = np.empty(array_shape, dtype=np.array(v).dtype)
 
         # do the actual insertion

pymc/backends/ndarray.py

@@ -72,12 +72,12 @@ def setup(self, draws, chain, sampler_vars=None) -> None:
             self.draw_idx = old_draws
             for varname, shape in self.var_shapes.items():
                 old_var_samples = self.samples[varname]
-                new_var_samples = np.zeros((draws,) + shape, self.var_dtypes[varname])
+                new_var_samples = np.zeros((draws, *shape), self.var_dtypes[varname])
                 self.samples[varname] = np.concatenate((old_var_samples, new_var_samples), axis=0)
         else:  # Otherwise, make array of zeros for each variable.
             self.draws = draws
             for varname, shape in self.var_shapes.items():
-                self.samples[varname] = np.zeros((draws,) + shape, dtype=self.var_dtypes[varname])
+                self.samples[varname] = np.zeros((draws, *shape), dtype=self.var_dtypes[varname])
 
         if sampler_vars is None:
             return

pymc/distributions/discrete.py

@@ -1159,7 +1159,7 @@ def logp(value, p):
                 value_clip = pt.shape_padleft(value_clip, p_.ndim - value_clip.ndim)
             elif p.ndim < value_clip.ndim:
                 p = pt.shape_padleft(p, value_clip.ndim - p_.ndim)
-            pattern = (p.ndim - 1,) + tuple(range(p.ndim - 1))
+            pattern = (p.ndim - 1, *range(p.ndim - 1))
             a = pt.log(
                 pt.take_along_axis(
                     p.dimshuffle(pattern),

pymc/distributions/dist_math.py

@@ -334,7 +334,7 @@ def random_choice(p, size):
         # probability. We must iterate over the elements of all the other
         # dimensions.
         # We first ensure that p is broadcasted to the output's shape
-        size = to_tuple(size) + (1,)
+        size = (*to_tuple(size), 1)
         p = np.broadcast_arrays(p, np.empty(size))[0]
         out_shape = p.shape[:-1]
         # np.random.choice accepts 1D p arrays, so we semiflatten p to

pymc/distributions/distribution.py

@@ -722,7 +722,7 @@ def rv_op(
             error_msg_on_access="Model variables cannot be created in the dist function. Use the `.dist` API"
         ):
             dummy_rv = dist(*dummy_dist_params, dummy_size_param)
-        dummy_params = [dummy_size_param] + dummy_dist_params
+        dummy_params = [dummy_size_param, *dummy_dist_params]
         dummy_updates_dict = collect_default_updates(inputs=dummy_params, outputs=(dummy_rv,))
 
         rv_type = type(
@@ -777,7 +777,7 @@ def change_custom_symbolic_dist_size(op, rv, new_size, expand):
             dummy_size_param = new_size.type()
             dummy_dist_params = [dist_param.type() for dist_param in old_dist_params]
             dummy_rv = dist(*dummy_dist_params, dummy_size_param)
-            dummy_params = [dummy_size_param] + dummy_dist_params
+            dummy_params = [dummy_size_param, *dummy_dist_params]
             dummy_updates_dict = collect_default_updates(inputs=dummy_params, outputs=(dummy_rv,))
             new_rv_op = rv_type(
                 inputs=dummy_params,

pymc/distributions/mixture.py

@@ -315,7 +315,7 @@ def _resize_components(cls, size, *components):
             # axis intact, because that's what determines the number of mixture components
             mix_axis = -components[0].owner.op.ndim_supp - 1
             mix_size = components[0].shape[mix_axis]
-            size = tuple(size) + (mix_size,)
+            size = (*size, mix_size)
 
         return [change_dist_size(component, size) for component in components]
 

pymc/distributions/multivariate.py

@@ -616,7 +616,7 @@ def rng_fn(cls, rng, n, a, size):
 
             if size:
                 n = np.broadcast_to(n, size)
-                a = np.broadcast_to(a, size + (a.shape[-1],))
+                a = np.broadcast_to(a, (*size, a.shape[-1]))
 
             res = np.empty(a.shape)
             for idx in np.ndindex(a.shape[:-1]):
@@ -1205,7 +1205,7 @@ def rv_op(cls, n, eta, sd_dist, size=None):
         # implied batched dimensions from those for the time being.
         if size is None:
             size = sd_dist.shape[:-1]
-        shape = tuple(size) + (n,)
+        shape = (*size, n)
         if sd_dist.owner.op.ndim_supp == 0:
             sd_dist = change_dist_size(sd_dist, shape)
         else:
@@ -1685,7 +1685,7 @@ def dist(cls, n, eta, *, return_matrix=False, **kwargs):
     @classmethod
     def vec_to_corr_mat(cls, vec, n):
         tri = pt.zeros(pt.concatenate([vec.shape[:-1], (n, n)]))
-        tri = pt.subtensor.set_subtensor(tri[(...,) + np.triu_indices(n, 1)], vec)
+        tri = pt.subtensor.set_subtensor(tri[(..., *np.triu_indices(n, 1))], vec)
         return tri + pt.moveaxis(tri, -2, -1) + pt.diag(pt.ones(n))
 
 
@@ -2183,7 +2183,7 @@ def rng_fn(cls, rng: np.random.RandomState, mu, W, alpha, tau, size):
 
         size = tuple(size or ())
         if size:
-            mu = np.broadcast_to(mu, size + (mu.shape[-1],))
+            mu = np.broadcast_to(mu, (*size, mu.shape[-1]))
         z = rng.normal(size=mu.shape)
         samples = np.empty(z.shape)
         for idx in np.ndindex(mu.shape[:-1]):
@@ -2492,7 +2492,7 @@ def rng_fn(cls, rng, alpha, K, size):
             raise ValueError("K needs to be positive.")
 
         size = to_tuple(size) if size is not None else alpha.shape
-        size = size + (K,)
+        size = (*size, K)
         alpha = alpha[..., np.newaxis]
 
         betas = rng.beta(1, alpha, size=size)

pymc/distributions/timeseries.py

@@ -819,7 +819,7 @@ def step(prev_y, prev_sigma, omega, alpha_1, beta_1, rng):
         (noise_next_rng,) = tuple(innov_updates_.values())
 
         garch11_ = pt.concatenate([init_[None, ...], y_t], axis=0).dimshuffle(
-            tuple(range(1, y_t.ndim)) + (0,)
+            (*range(1, y_t.ndim), 0)
         )
 
         garch11_op = GARCH11RV(
@@ -850,7 +850,7 @@ def garch11_logp(
 ):
     (value,) = values
     # Move the time axis to the first dimension
-    value_dimswapped = value.dimshuffle((value.ndim - 1,) + tuple(range(0, value.ndim - 1)))
+    value_dimswapped = value.dimshuffle((value.ndim - 1, *range(0, value.ndim - 1)))
     initial_vol = initial_vol * pt.ones_like(value_dimswapped[0])
 
     def volatility_update(x, vol, w, a, b):
@@ -991,18 +991,18 @@ def step(*prev_args):
         y_t, innov_updates_ = pytensor.scan(
             fn=step,
             outputs_info=[init_],
-            non_sequences=sde_pars_ + [noise_rng],
+            non_sequences=[*sde_pars_, noise_rng],
             n_steps=steps_,
             strict=True,
         )
         (noise_next_rng,) = tuple(innov_updates_.values())
 
         sde_out_ = pt.concatenate([init_[None, ...], y_t], axis=0).dimshuffle(
-            tuple(range(1, y_t.ndim)) + (0,)
+            (*range(1, y_t.ndim), 0)
         )
 
         eulermaruyama_op = EulerMaruyamaRV(
-            inputs=[init_, steps_] + sde_pars_,
+            inputs=[init_, steps_, *sde_pars_],
             outputs=[noise_next_rng, sde_out_],
             dt=dt,
             sde_fn=sde_fn,

pymc/distributions/transforms.py

@@ -303,7 +303,7 @@ def extend_axis_rev(array, axis):
         norm = sum_vals / (pt.sqrt(n) + n)
         slice_before = (slice(None, None),) * normalized_axis
 
-        return array[slice_before + (slice(None, -1),)] + norm
+        return array[(*slice_before, slice(None, -1))] + norm
 
     def forward(self, value, *rv_inputs):
         for axis in self.zerosum_axes:

pymc/logprob/mixture.py

@@ -310,7 +310,7 @@ def find_measurable_index_mixture(fgraph, node):
         old_mixture_rv.dtype,
         old_mixture_rv.broadcastable,
     )
-    new_node = mix_op.make_node(*([join_axis] + mixing_indices + mixture_rvs))
+    new_node = mix_op.make_node(*([join_axis, *mixing_indices, *mixture_rvs]))
 
     new_mixture_rv = new_node.default_output()
 

pymc/logprob/rewriting.py

@@ -285,7 +285,7 @@ def request_measurable(self, vars: Sequence[Variable]) -> list[Variable]:
 
 
 @register_canonicalize
-@node_rewriter((Elemwise, Alloc, DimShuffle) + subtensor_ops)
+@node_rewriter((Elemwise, Alloc, DimShuffle, *subtensor_ops))
 def local_lift_DiracDelta(fgraph, node):
     r"""Lift basic `Op`\s through `DiracDelta`\s."""
 

pymc/logprob/scan.py

@@ -164,14 +164,14 @@ def remove(x, i):
             inner_in_mit_sot_var = cast(
                 tuple[int, ...], tuple(output_scan_args.inner_in_mit_sot[var_idx])
             )
-            new_inner_in_seqs = inner_in_mit_sot_var + (new_inner_in_var,)
+            new_inner_in_seqs = (*inner_in_mit_sot_var, new_inner_in_var)
             new_inner_in_mit_sot = remove(output_scan_args.inner_in_mit_sot, var_idx)
             new_outer_in_mit_sot = remove(output_scan_args.outer_in_mit_sot, var_idx)
             new_inner_in_sit_sot = tuple(output_scan_args.inner_in_sit_sot)
             new_outer_in_sit_sot = tuple(output_scan_args.outer_in_sit_sot)
             add_nit_sot = True
         elif inner_out_info.name.endswith("sit_sot"):
-            new_inner_in_seqs = (output_scan_args.inner_in_sit_sot[var_idx],) + (new_inner_in_var,)
+            new_inner_in_seqs = (output_scan_args.inner_in_sit_sot[var_idx], new_inner_in_var)
             new_inner_in_sit_sot = remove(output_scan_args.inner_in_sit_sot, var_idx)
             new_outer_in_sit_sot = remove(output_scan_args.outer_in_sit_sot, var_idx)
             new_inner_in_mit_sot = tuple(output_scan_args.inner_in_mit_sot)
@@ -193,7 +193,7 @@ def remove(x, i):
             mit_sot_var_taps = cast(
                 tuple[int, ...], tuple(output_scan_args.mit_sot_in_slices[var_idx])
             )
-            taps = mit_sot_var_taps + (0,)
+            taps = (*mit_sot_var_taps, 0)
             new_mit_sot_in_slices = remove(output_scan_args.mit_sot_in_slices, var_idx)
         elif inner_out_info.name.endswith("sit_sot"):
             taps = (-1, 0)
@@ -230,7 +230,7 @@ def remove(x, i):
         output_scan_args.outer_in_seqs = list(new_outer_in_seqs)
 
         if add_nit_sot:
-            new_outer_in_nit_sot = tuple(output_scan_args.outer_in_nit_sot) + (n_steps,)
+            new_outer_in_nit_sot = (*output_scan_args.outer_in_nit_sot, n_steps)
         else:
             new_outer_in_nit_sot = tuple(output_scan_args.outer_in_nit_sot)
 

pymc/model/core.py

@@ -334,7 +334,7 @@ def __init__(
             grads = pytensor.grad(cost, grad_vars, disconnected_inputs="ignore")
             for grad_wrt, var in zip(grads, grad_vars):
                 grad_wrt.name = f"{var.name}_grad"
-            outputs = [cost] + grads
+            outputs = [cost, *grads]
         else:
             outputs = [cost]
 

pymc/plots/__init__.py

@@ -56,7 +56,8 @@ def wrapped(*args, **kwargs):
 compareplot = alias_deprecation(az.plot_compare, alias="compareplot")
 
 
-__all__ = tuple(az.plots.__all__) + (
+__all__ = (
+    *az.plots.__all__,
     "autocorrplot",
     "compareplot",
     "forestplot",

pymc/sampling/jax.py

@@ -58,7 +58,7 @@
 
 xla_flags_env = os.getenv("XLA_FLAGS", "")
 xla_flags = re.sub(r"--xla_force_host_platform_device_count=.+\s", "", xla_flags_env).split()
-os.environ["XLA_FLAGS"] = " ".join([f"--xla_force_host_platform_device_count={100}"] + xla_flags)
+os.environ["XLA_FLAGS"] = " ".join([f"--xla_force_host_platform_device_count={100}", *xla_flags])
 
 __all__ = (
     "get_jaxified_graph",

pymc/stats/__init__.py

@@ -29,4 +29,4 @@
 
 from pymc.stats.log_likelihood import compute_log_likelihood
 
-__all__ = ("compute_log_likelihood",) + tuple(az.stats.__all__)
+__all__ = ("compute_log_likelihood", *az.stats.__all__)

pymc/step_methods/compound.py

@@ -151,7 +151,7 @@ def __new__(cls, *args, **kwargs):
                 # call __init__
                 step.__init__([var], *args, **kwargs)
                 # Hack for creating the class correctly when unpickling.
-                step.__newargs = ([var],) + args, kwargs
+                step.__newargs = ([var], *args), kwargs
                 steps.append(step)
 
             return CompoundStep(steps)
@@ -160,7 +160,7 @@ def __new__(cls, *args, **kwargs):
             step.stats_dtypes = stats_dtypes
             step.stats_dtypes_shapes = stats_dtypes_shapes
             # Hack for creating the class correctly when unpickling.
-            step.__newargs = (vars,) + args, kwargs
+            step.__newargs = (vars, *args), kwargs
             return step
 
     # Hack for creating the class correctly when unpickling.

pymc/testing.py

@@ -143,7 +143,7 @@ def __neg__(self):
 class ProductDomain:
     def __init__(self, domains):
         self.vals = list(it.product(*(d.vals for d in domains)))
-        self.shape = (len(domains),) + domains[0].shape
+        self.shape = (len(domains), *domains[0].shape)
         self.lower = [d.lower for d in domains]
         self.upper = [d.upper for d in domains]
         self.dtype = domains[0].dtype

pymc/variational/opvi.py

@@ -1511,7 +1511,7 @@ def vars_names(vs):
         ):
             if name in vars_names(vars_):
                 name_, slc, shape, dtype = ordering[name]
-                found = random[..., slc].reshape((random.shape[0],) + shape).astype(dtype)
+                found = random[..., slc].reshape((random.shape[0], *shape)).astype(dtype)
                 found.name = name + "_vi_random_slice"
                 break
         else:

pymc/variational/updates.py

@@ -570,7 +570,7 @@ def adagrad_window(loss_or_grads=None, params=None, learning_rate=0.001, epsilon
         i = pytensor.shared(pm.floatX(0))
         i_int = i.astype("int32")
         value = param.get_value(borrow=True)
-        accu = pytensor.shared(np.zeros(value.shape + (n_win,), dtype=value.dtype))
+        accu = pytensor.shared(np.zeros((*value.shape, n_win), dtype=value.dtype))
 
         # Append squared gradient vector to accu_new
         accu_new = pt.set_subtensor(accu[..., i_int], grad**2)

tests/backends/fixtures.py

@@ -60,7 +60,7 @@ def test_append_invalid(self):
             with pytest.raises(ValueError):
                 self.strace.setup(self.draws, self.chain)
             with pytest.raises(ValueError):
-                vars = self.sampler_vars + [{"a": bool}]
+                vars = [*self.sampler_vars, {"a": bool}]
                 self.strace.setup(self.draws, self.chain, vars)
         else:
             with pytest.raises((ValueError, TypeError)):

tests/backends/test_arviz.py

@@ -156,7 +156,7 @@ def test_to_idata(self, data, eight_schools_params, chains, draws):
         chains = inference_data.posterior.sizes["chain"]
         draws = inference_data.posterior.sizes["draw"]
         obs = inference_data.observed_data["obs"]
-        assert inference_data.log_likelihood["obs"].shape == (chains, draws) + obs.shape
+        assert inference_data.log_likelihood["obs"].shape == (chains, draws, *obs.shape)
 
     def test_predictions_to_idata(self, data, eight_schools_params):
         "Test that we can add predictions to a previously-existing InferenceData."

tests/distributions/test_discrete.py

@@ -455,9 +455,9 @@ def test_orderedlogistic_dimensions(shape):
     # Test for issue #3535
     loge = np.log10(np.exp(1))
     size = 7
-    p = np.ones(shape + (10,)) / 10
-    cutpoints = np.tile(sp.logit(np.linspace(0, 1, 11)[1:-1]), shape + (1,))
-    obs = np.random.randint(0, 2, size=(size,) + shape)
+    p = np.ones((*shape, 10)) / 10
+    cutpoints = np.tile(sp.logit(np.linspace(0, 1, 11)[1:-1]), (*shape, 1))
+    obs = np.random.randint(0, 2, size=(size, *shape))
     with pm.Model():
         ol = pm.OrderedLogistic(
             "ol",
@@ -472,7 +472,7 @@ def test_orderedlogistic_dimensions(shape):
         )
     ologp = pm.logp(ol, np.ones_like(obs)).sum().eval() * loge
     clogp = pm.logp(c, np.ones_like(obs)).sum().eval() * loge
-    expected = -np.prod((size,) + shape)
+    expected = -np.prod((size, *shape))
 
     assert c.owner.inputs[3].ndim == (len(shape) + 1)
     assert np.allclose(clogp, expected)