Add more ruff rules (#8767)

* Add more ruff rules

* Add more ruff rules

* pre-commit: Update ruff v0.0.269 -> v0.0.270

* Apply suggestions from code review

* Fix doctest

* Fix doctest (ignore whitespace)

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: Dhruv Manilawala <dhruvmanila@gmail.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
     -   id: auto-walrus
 
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.269
+    rev: v0.0.270
     hooks:
       - id: ruff
 

arithmetic_analysis/jacobi_iteration_method.py

@@ -49,7 +49,9 @@ def jacobi_iteration_method(
     >>> constant = np.array([[2], [-6]])
     >>> init_val = [0.5, -0.5, -0.5]
     >>> iterations = 3
-    >>> jacobi_iteration_method(coefficient, constant, init_val, iterations)
+    >>> jacobi_iteration_method(
+    ...     coefficient, constant, init_val, iterations
+    ... )  # doctest: +NORMALIZE_WHITESPACE
     Traceback (most recent call last):
         ...
     ValueError: Coefficient and constant matrices dimensions must be nxn and nx1 but
@@ -59,7 +61,9 @@ def jacobi_iteration_method(
     >>> constant = np.array([[2], [-6], [-4]])
     >>> init_val = [0.5, -0.5]
     >>> iterations = 3
-    >>> jacobi_iteration_method(coefficient, constant, init_val, iterations)
+    >>> jacobi_iteration_method(
+    ...     coefficient, constant, init_val, iterations
+    ... )  # doctest: +NORMALIZE_WHITESPACE
     Traceback (most recent call last):
         ...
     ValueError: Number of initial values must be equal to number of rows in coefficient
@@ -79,24 +83,26 @@ def jacobi_iteration_method(
     rows2, cols2 = constant_matrix.shape
 
     if rows1 != cols1:
-        raise ValueError(
-            f"Coefficient matrix dimensions must be nxn but received {rows1}x{cols1}"
-        )
+        msg = f"Coefficient matrix dimensions must be nxn but received {rows1}x{cols1}"
+        raise ValueError(msg)
 
     if cols2 != 1:
-        raise ValueError(f"Constant matrix must be nx1 but received {rows2}x{cols2}")
+        msg = f"Constant matrix must be nx1 but received {rows2}x{cols2}"
+        raise ValueError(msg)
 
     if rows1 != rows2:
-        raise ValueError(
-            f"""Coefficient and constant matrices dimensions must be nxn and nx1 but
-            received {rows1}x{cols1} and {rows2}x{cols2}"""
+        msg = (
+            "Coefficient and constant matrices dimensions must be nxn and nx1 but "
+            f"received {rows1}x{cols1} and {rows2}x{cols2}"
         )
+        raise ValueError(msg)
 
     if len(init_val) != rows1:
-        raise ValueError(
-            f"""Number of initial values must be equal to number of rows in coefficient
-            matrix but received {len(init_val)} and {rows1}"""
+        msg = (
+            "Number of initial values must be equal to number of rows in coefficient "
+            f"matrix but received {len(init_val)} and {rows1}"
         )
+        raise ValueError(msg)
 
     if iterations <= 0:
         raise ValueError("Iterations must be at least 1")

arithmetic_analysis/lu_decomposition.py

@@ -80,10 +80,11 @@ def lower_upper_decomposition(table: np.ndarray) -> tuple[np.ndarray, np.ndarray
     # Ensure that table is a square array
     rows, columns = np.shape(table)
     if rows != columns:
-        raise ValueError(
-            f"'table' has to be of square shaped array but got a "
+        msg = (
+            "'table' has to be of square shaped array but got a "
             f"{rows}x{columns} array:\n{table}"
         )
+        raise ValueError(msg)
 
     lower = np.zeros((rows, columns))
     upper = np.zeros((rows, columns))

audio_filters/iir_filter.py

@@ -50,16 +50,18 @@ def set_coefficients(self, a_coeffs: list[float], b_coeffs: list[float]) -> None
             a_coeffs = [1.0, *a_coeffs]
 
         if len(a_coeffs) != self.order + 1:
-            raise ValueError(
-                f"Expected a_coeffs to have {self.order + 1} elements for {self.order}"
-                f"-order filter, got {len(a_coeffs)}"
+            msg = (
+                f"Expected a_coeffs to have {self.order + 1} elements "
+                f"for {self.order}-order filter, got {len(a_coeffs)}"
             )
+            raise ValueError(msg)
 
         if len(b_coeffs) != self.order + 1:
-            raise ValueError(
-                f"Expected b_coeffs to have {self.order + 1} elements for {self.order}"
-                f"-order filter, got {len(a_coeffs)}"
+            msg = (
+                f"Expected b_coeffs to have {self.order + 1} elements "
+                f"for {self.order}-order filter, got {len(a_coeffs)}"
             )
+            raise ValueError(msg)
 
         self.a_coeffs = a_coeffs
         self.b_coeffs = b_coeffs

backtracking/knight_tour.py

@@ -91,7 +91,8 @@ def open_knight_tour(n: int) -> list[list[int]]:
                 return board
             board[i][j] = 0
 
-    raise ValueError(f"Open Kight Tour cannot be performed on a board of size {n}")
+    msg = f"Open Kight Tour cannot be performed on a board of size {n}"
+    raise ValueError(msg)
 
 
 if __name__ == "__main__":

bit_manipulation/reverse_bits.py

@@ -14,10 +14,11 @@ def get_reverse_bit_string(number: int) -> str:
     TypeError: operation can not be conducted on a object of type str
     """
     if not isinstance(number, int):
-        raise TypeError(
+        msg = (
             "operation can not be conducted on a object of type "
             f"{type(number).__name__}"
         )
+        raise TypeError(msg)
     bit_string = ""
     for _ in range(0, 32):
         bit_string += str(number % 2)

ciphers/base64.py

@@ -34,9 +34,8 @@ def base64_encode(data: bytes) -> bytes:
     """
     # Make sure the supplied data is a bytes-like object
     if not isinstance(data, bytes):
-        raise TypeError(
-            f"a bytes-like object is required, not '{data.__class__.__name__}'"
-        )
+        msg = f"a bytes-like object is required, not '{data.__class__.__name__}'"
+        raise TypeError(msg)
 
     binary_stream = "".join(bin(byte)[2:].zfill(8) for byte in data)
 
@@ -88,10 +87,11 @@ def base64_decode(encoded_data: str) -> bytes:
     """
     # Make sure encoded_data is either a string or a bytes-like object
     if not isinstance(encoded_data, bytes) and not isinstance(encoded_data, str):
-        raise TypeError(
-            "argument should be a bytes-like object or ASCII string, not "
-            f"'{encoded_data.__class__.__name__}'"
+        msg = (
+            "argument should be a bytes-like object or ASCII string, "
+            f"not '{encoded_data.__class__.__name__}'"
         )
+        raise TypeError(msg)
 
     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object

ciphers/beaufort_cipher.py

@@ -5,7 +5,7 @@
 from string import ascii_uppercase
 
 dict1 = {char: i for i, char in enumerate(ascii_uppercase)}
-dict2 = {i: char for i, char in enumerate(ascii_uppercase)}
+dict2 = dict(enumerate(ascii_uppercase))
 
 
 # This function generates the key in

ciphers/cryptomath_module.py

@@ -6,7 +6,8 @@ def gcd(a: int, b: int) -> int:
 
 def find_mod_inverse(a: int, m: int) -> int:
     if gcd(a, m) != 1:
-        raise ValueError(f"mod inverse of {a!r} and {m!r} does not exist")
+        msg = f"mod inverse of {a!r} and {m!r} does not exist"
+        raise ValueError(msg)
     u1, u2, u3 = 1, 0, a
     v1, v2, v3 = 0, 1, m
     while v3 != 0:

ciphers/enigma_machine2.py

@@ -87,22 +87,20 @@ def _validator(
     # Checks if there are 3 unique rotors
 
     if (unique_rotsel := len(set(rotsel))) < 3:
-        raise Exception(f"Please use 3 unique rotors (not {unique_rotsel})")
+        msg = f"Please use 3 unique rotors (not {unique_rotsel})"
+        raise Exception(msg)
 
     # Checks if rotor positions are valid
     rotorpos1, rotorpos2, rotorpos3 = rotpos
     if not 0 < rotorpos1 <= len(abc):
-        raise ValueError(
-            "First rotor position is not within range of 1..26 (" f"{rotorpos1}"
-        )
+        msg = f"First rotor position is not within range of 1..26 ({rotorpos1}"
+        raise ValueError(msg)
     if not 0 < rotorpos2 <= len(abc):
-        raise ValueError(
-            "Second rotor position is not within range of 1..26 (" f"{rotorpos2})"
-        )
+        msg = f"Second rotor position is not within range of 1..26 ({rotorpos2})"
+        raise ValueError(msg)
     if not 0 < rotorpos3 <= len(abc):
-        raise ValueError(
-            "Third rotor position is not within range of 1..26 (" f"{rotorpos3})"
-        )
+        msg = f"Third rotor position is not within range of 1..26 ({rotorpos3})"
+        raise ValueError(msg)
 
     # Validates string and returns dict
     pbdict = _plugboard(pb)
@@ -130,9 +128,11 @@ def _plugboard(pbstring: str) -> dict[str, str]:
     # a) is type string
     # b) has even length (so pairs can be made)
     if not isinstance(pbstring, str):
-        raise TypeError(f"Plugboard setting isn't type string ({type(pbstring)})")
+        msg = f"Plugboard setting isn't type string ({type(pbstring)})"
+        raise TypeError(msg)
     elif len(pbstring) % 2 != 0:
-        raise Exception(f"Odd number of symbols ({len(pbstring)})")
+        msg = f"Odd number of symbols ({len(pbstring)})"
+        raise Exception(msg)
     elif pbstring == "":
         return {}
 
@@ -142,9 +142,11 @@ def _plugboard(pbstring: str) -> dict[str, str]:
     tmppbl = set()
     for i in pbstring:
         if i not in abc:
-            raise Exception(f"'{i}' not in list of symbols")
+            msg = f"'{i}' not in list of symbols"
+            raise Exception(msg)
         elif i in tmppbl:
-            raise Exception(f"Duplicate symbol ({i})")
+            msg = f"Duplicate symbol ({i})"
+            raise Exception(msg)
         else:
             tmppbl.add(i)
     del tmppbl