Apply rule RUF043

Armavica · Armavica · commit 0a8361294772 · 2025-10-08T19:58:57.000+02:00
diff --git a/tests/compile/test_builders.py b/tests/compile/test_builders.py
@@ -45,7 +45,7 @@ class TestOpFromGraph(unittest_tools.InferShapeTester):
     def test_valid_input(self):
         x, y, z = matrices("xyz")
 
-        with pytest.raises(ValueError, match="Expected at least.*"):
+        with pytest.raises(ValueError, match=r"Expected at least.*"):
             OpFromGraph([x], [x])()
 
         with pytest.raises(ValueError, match=r"Expected 1 input\(s\)"):
diff --git a/tests/graph/test_compute_test_value.py b/tests/graph/test_compute_test_value.py
@@ -264,7 +264,7 @@ def fx(prior_result, A):
                 fn=fx, outputs_info=pt.ones_like(A.T), non_sequences=A, n_steps=k
             )
 
-        with pytest.raises(ValueError, match="^could not broadcast input"):
+        with pytest.raises(ValueError, match=r"^could not broadcast input"):
             pytensor.scan(
                 fn=fx, outputs_info=pt.ones_like(A.T), non_sequences=A, n_steps=k
             )
diff --git a/tests/graph/test_fg.py b/tests/graph/test_fg.py
@@ -62,8 +62,8 @@ def test_validate_inputs(self):
         with pytest.raises(
             ValueError,
             match=(
-                "One of the provided inputs is the output of an already existing node. "
-                "If that is okay, either discard that input's owner or use graph.clone."
+                "One of the provided inputs is the output of an already existing node\\. "
+                "If that is okay, either discard that input's owner or use graph\\.clone\\."
             ),
         ):
             var3 = op1(var1)
@@ -208,7 +208,7 @@ def test_import_var(self):
         assert var5 in fg.variables
         assert var5.owner in fg.apply_nodes
 
-        with pytest.raises(TypeError, match="Computation graph contains.*"):
+        with pytest.raises(TypeError, match=r"Computation graph contains.*"):
             from pytensor.graph.null_type import NullType
 
             fg.import_var(NullType()(), "testing")
@@ -265,7 +265,7 @@ def test_replace_test_value(self):
 
         assert var6.tag.test_value.shape != var4.tag.test_value.shape
 
-        with pytest.raises(AssertionError, match="The replacement.*"):
+        with pytest.raises(AssertionError, match=r"The replacement.*"):
             fg.replace(var4, var6)
 
     def test_replace(self):
@@ -342,27 +342,27 @@ def test_check_integrity(self):
         var5 = op3(var4, var2, var2)
         fg = FunctionGraph([var1, var2], [var3, var5], clone=False)
 
-        with pytest.raises(Exception, match="The following nodes are .*"):
+        with pytest.raises(Exception, match=r"The following nodes are .*"):
             fg.apply_nodes.remove(var5.owner)
 
             fg.check_integrity()
 
-        with pytest.raises(Exception, match="Inconsistent clients.*"):
+        with pytest.raises(Exception, match=r"Inconsistent clients.*"):
             fg.apply_nodes.add(var5.owner)
             fg.remove_client(var2, (var5.owner, 1))
 
             fg.check_integrity()
 
         fg.add_client(var2, (var5.owner, 1))
 
-        with pytest.raises(Exception, match="The following variables are.*"):
+        with pytest.raises(Exception, match=r"The following variables are.*"):
             fg.variables.remove(var4)
 
             fg.check_integrity()
 
         fg.variables.add(var4)
 
-        with pytest.raises(Exception, match="Undeclared input.*"):
+        with pytest.raises(Exception, match=r"Undeclared input.*"):
             var6 = MyVariable2("var6")
             fg.clients[var6] = [(var5.owner, 3)]
             fg.variables.add(var6)
@@ -376,26 +376,26 @@ def test_check_integrity(self):
         # TODO: What if the index value is greater than 1?  It will throw an
         # `IndexError`, but that doesn't sound like anything we'd want.
         out_node = Output(idx=1).make_node(var4)
-        with pytest.raises(Exception, match="Inconsistent clients list.*"):
+        with pytest.raises(Exception, match=r"Inconsistent clients list.*"):
             fg.add_client(var4, (out_node, 0))
 
             fg.check_integrity()
 
         fg.remove_client(var4, (out_node, 0))
 
-        with pytest.raises(TypeError, match="The first entry of.*"):
+        with pytest.raises(TypeError, match=r"The first entry of.*"):
             fg.add_client(var4, (None, 0))
 
         var7 = op1(var4)
 
-        with pytest.raises(Exception, match="Client not in FunctionGraph.*"):
+        with pytest.raises(Exception, match=r"Client not in FunctionGraph.*"):
             fg.add_client(var4, (var7.owner, 0))
 
             fg.check_integrity()
 
         fg.remove_client(var4, (var7.owner, 0))
 
-        with pytest.raises(Exception, match="Inconsistent clients list.*"):
+        with pytest.raises(Exception, match=r"Inconsistent clients list.*"):
             fg.add_client(var4, (var3.owner, 0))
 
             fg.check_integrity()
diff --git a/tests/link/numba/test_random.py b/tests/link/numba/test_random.py
@@ -662,7 +662,7 @@ def test_unaligned_RandomVariable(rv_op, dist_args, base_size, cdf_name, params_
             (10, 4),
             pytest.raises(
                 ValueError,
-                match="Vectorized input 0 has an incompatible shape in axis 1.",
+                match="Vectorized input 0 has an incompatible shape in axis 1\\.",
             ),
         ),
     ],
diff --git a/tests/link/pytorch/test_elemwise.py b/tests/link/pytorch/test_elemwise.py
@@ -108,7 +108,7 @@ def test_softmax(axis, dtype):
     if dtype == "int64":
         with pytest.raises(
             NotImplementedError,
-            match="Pytorch Softmax is not currently implemented for non-float types.",
+            match="Pytorch Softmax is not currently implemented for non-float types\\.",
         ):
             compare_pytorch_and_py([x], [out], [test_input])
     else:
@@ -125,7 +125,7 @@ def test_logsoftmax(axis, dtype):
     if dtype == "int64":
         with pytest.raises(
             NotImplementedError,
-            match="Pytorch LogSoftmax is not currently implemented for non-float types.",
+            match="Pytorch LogSoftmax is not currently implemented for non-float types\\.",
         ):
             compare_pytorch_and_py([x], [out], [test_input])
     else:
diff --git a/tests/link/pytorch/test_extra_ops.py b/tests/link/pytorch/test_extra_ops.py
@@ -24,9 +24,9 @@ def test_pytorch_CumOp(axis, dtype):
 
     # Create the output variable
     if isinstance(axis, tuple):
-        with pytest.raises(TypeError, match="axis must be an integer or None."):
+        with pytest.raises(TypeError, match="axis must be an integer or None\\."):
             out = pt.cumsum(a, axis=axis)
-        with pytest.raises(TypeError, match="axis must be an integer or None."):
+        with pytest.raises(TypeError, match="axis must be an integer or None\\."):
             out = pt.cumprod(a, axis=axis)
     else:
         out = pt.cumsum(a, axis=axis)
diff --git a/tests/link/test_vm.py b/tests/link/test_vm.py
@@ -421,7 +421,7 @@ def make_thunk(self, *args, **kwargs):
 
     z = BadOp()(a)
 
-    with pytest.raises(Exception, match=".*Apply node that caused the error.*"):
+    with pytest.raises(Exception, match=r".*Apply node that caused the error.*"):
         function([a], z, mode=Mode(optimizer=None, linker=linker))
 
 
@@ -433,7 +433,7 @@ def __call__(self):
     a = scalar()
     fg = FunctionGraph(outputs=[SomeOp()(a)])
 
-    with pytest.raises(ValueError, match="`nodes` and `thunks`.*"):
+    with pytest.raises(ValueError, match=r"`nodes` and `thunks`.*"):
         SomeVM(fg, fg.apply_nodes, [], [])
 
 
@@ -453,7 +453,7 @@ def test_Loop_exception():
 
     thunks = [node.op.make_thunk(node, storage_map, compute_map, []) for node in nodes]
 
-    with pytest.raises(ValueError, match="`nodes`, `thunks` and `post_thunk_clear`.*"):
+    with pytest.raises(ValueError, match=r"`nodes`, `thunks` and `post_thunk_clear`.*"):
         Loop(
             fg,
             fg.apply_nodes,
diff --git a/tests/sparse/test_type.py b/tests/sparse/test_type.py
@@ -79,5 +79,5 @@ def test_SparseTensorType_filter():
     x_res = z.type.filter(x.astype("float32"), allow_downcast=True)
     assert x_res.dtype == "float64"
 
-    with pytest.raises(TypeError, match=".*dtype but got.*"):
+    with pytest.raises(TypeError, match=r".*dtype but got.*"):
         w.type.filter(x)
diff --git a/tests/tensor/random/test_op.py b/tests/tensor/random/test_op.py
@@ -32,7 +32,7 @@ def test_RandomVariable_basics(strict_test_value_flags):
     assert str_res == 'normal_rv{"(),()->()"}'
 
     # `ndims_params` should be a `Sequence` type
-    with pytest.raises(TypeError, match="^Parameter ndims_params*"):
+    with pytest.raises(TypeError, match=r"^Parameter ndims_params*"):
         RandomVariable(
             "normal",
             0,
@@ -42,7 +42,7 @@ def test_RandomVariable_basics(strict_test_value_flags):
         )
 
     # `size` should be a `Sequence` type
-    with pytest.raises(TypeError, match="^Parameter size*"):
+    with pytest.raises(TypeError, match=r"^Parameter size*"):
         RandomVariable(
             "normal",
             0,
diff --git a/tests/tensor/random/test_utils.py b/tests/tensor/random/test_utils.py
@@ -284,7 +284,7 @@ def __init__(self, seed=123):
 
 
 def test_supp_shape_from_ref_param_shape():
-    with pytest.raises(ValueError, match="^ndim_supp*"):
+    with pytest.raises(ValueError, match=r"^ndim_supp*"):
         supp_shape_from_ref_param_shape(
             ndim_supp=0,
             dist_params=(np.array([1, 2]), 0),
@@ -306,7 +306,7 @@ def test_supp_shape_from_ref_param_shape():
     )
     assert res == (2,)
 
-    with pytest.raises(ValueError, match="^Reference parameter*"):
+    with pytest.raises(ValueError, match=r"^Reference parameter*"):
         supp_shape_from_ref_param_shape(
             ndim_supp=1,
             dist_params=(np.array(1),),
diff --git a/tests/tensor/rewriting/test_basic.py b/tests/tensor/rewriting/test_basic.py
@@ -298,7 +298,7 @@ def test_inconsistent_shared(self, shape_unsafe):
             # Error raised by SpecifyShape that is introduced due to static shape inference
             with pytest.raises(
                 AssertionError,
-                match="SpecifyShape: dim 0 of input has shape 3, expected 6.",
+                match="SpecifyShape: dim 0 of input has shape 3, expected 6\\.",
             ):
                 f()
         else:
diff --git a/tests/tensor/test_basic.py b/tests/tensor/test_basic.py
@@ -589,7 +589,7 @@ def test_ndim_all_broadcastable(self):
 
     def test_ndim_incompatible(self):
         x = TensorType(config.floatX, shape=(1, None))("x")
-        with pytest.raises(ValueError, match="^Tensor of type.*"):
+        with pytest.raises(ValueError, match=r"^Tensor of type.*"):
             as_tensor_variable(x, ndim=0)
 
     def test_bool(self):
@@ -898,7 +898,7 @@ def test_runtime_broadcast(self, mode):
 
 
 def test_infer_static_shape():
-    with pytest.raises(TypeError, match="^Shapes must be scalar integers.*"):
+    with pytest.raises(TypeError, match=r"^Shapes must be scalar integers.*"):
         infer_static_shape([constant(1.0)])
 
     with (
@@ -907,7 +907,7 @@ def test_infer_static_shape():
     ):
         infer_static_shape([dscalar("x")])
 
-    with pytest.raises(ValueError, match=".*could not be cast to have 0 dimensions"):
+    with pytest.raises(ValueError, match=r".*could not be cast to have 0 dimensions"):
         infer_static_shape((as_tensor_variable([[1, 2]]),))
 
     constant_size = constant([1])
@@ -1269,7 +1269,7 @@ def test_get_vector_length():
         as_tensor_variable([1, 2], ndim=1),
         as_tensor_variable([3, 4], ndim=1),
     )
-    with pytest.raises(ValueError, match="^Length of .*"):
+    with pytest.raises(ValueError, match=r"^Length of .*"):
         get_vector_length(z)
 
     # Test `MakeVector`s
@@ -1329,13 +1329,13 @@ def eval_outputs_and_check_vector(self, outputs, make_vector_op=None):
         return variables
 
     def test_input_validation(self):
-        with pytest.raises(TypeError, match=".*integer.*"):
+        with pytest.raises(TypeError, match=r".*integer.*"):
             Split(2)(matrix(), dscalar(), [1, 1])
 
-        with pytest.raises(TypeError, match=".*integer.*"):
+        with pytest.raises(TypeError, match=r".*integer.*"):
             Split(2)(matrix(), ivector(), [1, 1])
 
-        with pytest.raises(TypeError, match=".*integer.*"):
+        with pytest.raises(TypeError, match=r".*integer.*"):
             join(dscalar(), matrix(), matrix())
 
     def test_join_scalar(self):
@@ -3131,7 +3131,7 @@ def test_default():
     assert f(None, 2) == 2
     assert f(1, None) == 1
 
-    with pytest.raises(TypeError, match=".*compatible types.*"):
+    with pytest.raises(TypeError, match=r".*compatible types.*"):
         default(x, vector())
 
 
@@ -3622,7 +3622,7 @@ def test_diag(self):
     @pytest.mark.parametrize("inp", (scalar, tensor3))
     def test_diag_invalid_input_ndim(self, inp):
         x = inp()
-        with pytest.raises(ValueError, match="Input must be 1- or 2-d."):
+        with pytest.raises(ValueError, match="Input must be 1- or 2-d\\."):
             diag(x)
 
 
diff --git a/tests/tensor/test_extra_ops.py b/tests/tensor/test_extra_ops.py
@@ -1374,7 +1374,7 @@ def test_concat_with_broadcast():
 
     with pytest.raises(
         TypeError,
-        match="Only tensors with the same number of dimensions can be concatenated.",
+        match="Only tensors with the same number of dimensions can be concatenated\\.",
     ):
         a = pt.tensor("a", shape=(1, 3, 5))
         b = pt.tensor("b", shape=(3, 5))
diff --git a/tests/tensor/test_math.py b/tests/tensor/test_math.py
@@ -1462,7 +1462,7 @@ def test_bool(self):
 def test_MaxAndArgmax_deprecated():
     with pytest.raises(
         AttributeError,
-        match="The class `MaxandArgmax` has been deprecated. Call `Max` and `Argmax` seperately as an alternative.",
+        match="The class `MaxandArgmax` has been deprecated\\. Call `Max` and `Argmax` seperately as an alternative\\.",
     ):
         pytensor.tensor.math.MaxAndArgmax
 
diff --git a/tests/tensor/test_shape.py b/tests/tensor/test_shape.py
@@ -495,14 +495,14 @@ def test_python_perform(self):
         f = pytensor.function([x, shape], y, mode=Mode("py"))
         assert f([1], (1,)) == [1]
 
-        with pytest.raises(AssertionError, match="SpecifyShape:.*"):
+        with pytest.raises(AssertionError, match=r"SpecifyShape:.*"):
             assert f([1], (2,)) == [1]
 
         x = matrix()
         y = specify_shape(x, (None, 2))
         f = pytensor.function([x], y, mode=Mode("py"))
         assert f(np.zeros((3, 2), dtype=config.floatX)).shape == (3, 2)
-        with pytest.raises(AssertionError, match="SpecifyShape:.*"):
+        with pytest.raises(AssertionError, match=r"SpecifyShape:.*"):
             assert f(np.zeros((3, 3), dtype=config.floatX))
 
     def test_bad_shape(self):
@@ -516,7 +516,7 @@ def test_bad_shape(self):
         assert np.array_equal(f(xval), xval)
 
         xval = np.random.random(3).astype(config.floatX)
-        with pytest.raises(AssertionError, match="SpecifyShape:.*"):
+        with pytest.raises(AssertionError, match=r"SpecifyShape:.*"):
             f(xval)
 
         assert isinstance(
@@ -540,14 +540,14 @@ def test_bad_shape(self):
 
         for shape_ in [(4, 3), (2, 8)]:
             xval = np.random.random(shape_).astype(config.floatX)
-            with pytest.raises(AssertionError, match="SpecifyShape:.*"):
+            with pytest.raises(AssertionError, match=r"SpecifyShape:.*"):
                 f(xval)
 
         s = iscalar("s")
         f = pytensor.function([x, s], specify_shape(x, None, s), mode=self.mode)
         x_val = np.zeros((3, 2), dtype=config.floatX)
         assert f(x_val, 2).shape == (3, 2)
-        with pytest.raises(AssertionError, match="SpecifyShape:.*"):
+        with pytest.raises(AssertionError, match=r"SpecifyShape:.*"):
             f(xval, 3)
 
     def test_infer_shape(self):
diff --git a/tests/tensor/test_slinalg.py b/tests/tensor/test_slinalg.py
@@ -240,7 +240,7 @@ def test__repr__(self):
 
 
 def test_solve_raises_on_invalid_assume_a():
-    with pytest.raises(ValueError, match="Invalid assume_a: test. It must be one of"):
+    with pytest.raises(ValueError, match="Invalid assume_a: test\\. It must be one of"):
         Solve(assume_a="test", b_ndim=2)
 
 
diff --git a/tests/tensor/test_subtensor.py b/tests/tensor/test_subtensor.py
@@ -1364,12 +1364,12 @@ def test_advanced1_inc_runtime_broadcast(self, func):
         f(np.ones((20, 5)))  # Fine
         with pytest.raises(
             ValueError,
-            match="Runtime broadcasting not allowed. AdvancedIncSubtensor1 was asked",
+            match="Runtime broadcasting not allowed\\. AdvancedIncSubtensor1 was asked",
         ):
             f(np.ones((1, 5)))
         with pytest.raises(
             ValueError,
-            match="Runtime broadcasting not allowed. AdvancedIncSubtensor1 was asked",
+            match="Runtime broadcasting not allowed\\. AdvancedIncSubtensor1 was asked",
         ):
             f(np.ones((20, 1)))
 
@@ -2903,7 +2903,7 @@ def test_get_vector_length():
     assert get_vector_length(lvector()[1:1]) == 0
     assert get_vector_length(lvector()[-1:-1:3]) == 0
 
-    with pytest.raises(ValueError, match="^Length of .*"):
+    with pytest.raises(ValueError, match=r"^Length of .*"):
         get_vector_length(x[lscalar() :])
 
 
diff --git a/tests/tensor/test_type.py b/tests/tensor/test_type.py
diff --git a/tests/test_config.py b/tests/test_config.py
diff --git a/tests/test_ifelse.py b/tests/test_ifelse.py
diff --git a/tests/xtensor/test_indexing.py b/tests/xtensor/test_indexing.py
diff --git a/tests/xtensor/test_shape.py b/tests/xtensor/test_shape.py

Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ def fx(prior_result, A):`
`264`	`264`	`fn=fx, outputs_info=pt.ones_like(A.T), non_sequences=A, n_steps=k`
`265`	`265`	`)`
`266`	`266`
`267`		`- with pytest.raises(ValueError, match="^could not broadcast input"):`
	`267`	`+ with pytest.raises(ValueError, match=r"^could not broadcast input"):`
`268`	`268`	`pytensor.scan(`
`269`	`269`	`fn=fx, outputs_info=pt.ones_like(A.T), non_sequences=A, n_steps=k`
`270`	`270`	`)`