Python linting: Add ruff rules for Pandas-vet and Pytest-style

Author: cclauss

Diff for: .pre-commit-config.yaml

@@ -51,7 +51,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.5.1
+    rev: v1.6.0
     hooks:
       - id: mypy
         args:

Diff for: blockchain/diophantine_equation.py

@@ -83,7 +83,8 @@ def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
     (1, -2, 3)
 
     """
-    assert a >= 0 and b >= 0
+    assert a >= 0
+    assert b >= 0
 
     if b == 0:
         d, x, y = a, 1, 0
@@ -92,7 +93,8 @@ def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
         x = q
         y = p - q * (a // b)
 
-    assert a % d == 0 and b % d == 0
+    assert a % d == 0
+    assert b % d == 0
     assert d == a * x + b * y
 
     return (d, x, y)

Diff for: ciphers/xor_cipher.py

@@ -38,7 +38,8 @@ def encrypt(self, content: str, key: int) -> list[str]:
         """
 
         # precondition
-        assert isinstance(key, int) and isinstance(content, str)
+        assert isinstance(key, int)
+        assert isinstance(content, str)
 
         key = key or self.__key or 1
 
@@ -56,7 +57,8 @@ def decrypt(self, content: str, key: int) -> list[str]:
         """
 
         # precondition
-        assert isinstance(key, int) and isinstance(content, list)
+        assert isinstance(key, int)
+        assert isinstance(content, list)
 
         key = key or self.__key or 1
 
@@ -74,7 +76,8 @@ def encrypt_string(self, content: str, key: int = 0) -> str:
         """
 
         # precondition
-        assert isinstance(key, int) and isinstance(content, str)
+        assert isinstance(key, int)
+        assert isinstance(content, str)
 
         key = key or self.__key or 1
 
@@ -99,7 +102,8 @@ def decrypt_string(self, content: str, key: int = 0) -> str:
         """
 
         # precondition
-        assert isinstance(key, int) and isinstance(content, str)
+        assert isinstance(key, int)
+        assert isinstance(content, str)
 
         key = key or self.__key or 1
 
@@ -125,7 +129,8 @@ def encrypt_file(self, file: str, key: int = 0) -> bool:
         """
 
         # precondition
-        assert isinstance(file, str) and isinstance(key, int)
+        assert isinstance(file, str)
+        assert isinstance(key, int)
 
         try:
             with open(file) as fin, open("encrypt.out", "w+") as fout:
@@ -148,7 +153,8 @@ def decrypt_file(self, file: str, key: int) -> bool:
         """
 
         # precondition
-        assert isinstance(file, str) and isinstance(key, int)
+        assert isinstance(file, str)
+        assert isinstance(key, int)
 
         try:
             with open(file) as fin, open("decrypt.out", "w+") as fout:

Diff for: conversions/decimal_to_hexadecimal.py

@@ -57,7 +57,8 @@ def decimal_to_hexadecimal(decimal: float) -> str:
     >>> decimal_to_hexadecimal(-256) == hex(-256)
     True
     """
-    assert type(decimal) in (int, float) and decimal == int(decimal)
+    assert type(decimal) in (int, float)
+    assert decimal == int(decimal)
     decimal = int(decimal)
     hexadecimal = ""
     negative = False

Diff for: data_structures/binary_tree/binary_search_tree_recursive.py

@@ -12,6 +12,8 @@
 import unittest
 from collections.abc import Iterator
 
+import pytest
+
 
 class Node:
     def __init__(self, label: int, parent: Node | None) -> None:
@@ -359,7 +361,7 @@ def test_put(self) -> None:
         assert t.root.left.left.parent == t.root.left
         assert t.root.left.left.label == 1
 
-        with self.assertRaises(Exception):  # noqa: B017
+        with pytest.raises(Exception):  # noqa: B017
             t.put(1)
 
     def test_search(self) -> None:
@@ -371,7 +373,7 @@ def test_search(self) -> None:
         node = t.search(13)
         assert node.label == 13
 
-        with self.assertRaises(Exception):  # noqa: B017
+        with pytest.raises(Exception):  # noqa: B017
             t.search(2)
 
     def test_remove(self) -> None:
@@ -517,7 +519,7 @@ def test_get_max_label(self) -> None:
         assert t.get_max_label() == 14
 
         t.empty()
-        with self.assertRaises(Exception):  # noqa: B017
+        with pytest.raises(Exception):  # noqa: B017
             t.get_max_label()
 
     def test_get_min_label(self) -> None:
@@ -526,7 +528,7 @@ def test_get_min_label(self) -> None:
         assert t.get_min_label() == 1
 
         t.empty()
-        with self.assertRaises(Exception):  # noqa: B017
+        with pytest.raises(Exception):  # noqa: B017
             t.get_min_label()
 
     def test_inorder_traversal(self) -> None:

Diff for: data_structures/hashing/tests/test_hash_map.py

@@ -65,14 +65,14 @@ def _run_operation(obj, fun, *args):
 
 @pytest.mark.parametrize(
     "operations",
-    (
+    [
         pytest.param(_add_items, id="add items"),
         pytest.param(_overwrite_items, id="overwrite items"),
         pytest.param(_delete_items, id="delete items"),
         pytest.param(_access_absent_items, id="access absent items"),
         pytest.param(_add_with_resize_up, id="add with resize up"),
         pytest.param(_add_with_resize_down, id="add with resize down"),
-    ),
+    ],
 )
 def test_hash_map_is_the_same_as_dict(operations):
     my = HashMap(initial_block_size=4)

Diff for: data_structures/linked_list/circular_linked_list.py

@@ -124,7 +124,8 @@ def delete_nth(self, index: int = 0) -> Any:
         if not 0 <= index < len(self):
             raise IndexError("list index out of range.")
 
-        assert self.head is not None and self.tail is not None
+        assert self.head is not None
+        assert self.tail is not None
         delete_node: Node = self.head
         if self.head == self.tail:  # Just one node
             self.head = self.tail = None
@@ -137,7 +138,8 @@ def delete_nth(self, index: int = 0) -> Any:
             for _ in range(index - 1):
                 assert temp is not None
                 temp = temp.next
-            assert temp is not None and temp.next is not None
+            assert temp is not None
+            assert temp.next is not None
             delete_node = temp.next
             temp.next = temp.next.next
             if index == len(self) - 1:  # Delete at tail

Diff for: digital_image_processing/test_digital_image_processing.py

@@ -73,7 +73,8 @@ def test_median_filter():
 
 def test_sobel_filter():
     grad, theta = sob.sobel_filter(gray)
-    assert grad.any() and theta.any()
+    assert grad.any()
+    assert theta.any()
 
 
 def test_sepia():

Diff for: graphs/graph_adjacency_list.py

@@ -22,6 +22,8 @@
 from pprint import pformat
 from typing import Generic, TypeVar
 
+import pytest
+
 T = TypeVar("T")
 
 
@@ -185,42 +187,42 @@ def __assert_graph_edge_exists_check(
         directed_graph: GraphAdjacencyList,
         edge: list[int],
     ) -> None:
-        self.assertTrue(undirected_graph.contains_edge(edge[0], edge[1]))
-        self.assertTrue(undirected_graph.contains_edge(edge[1], edge[0]))
-        self.assertTrue(directed_graph.contains_edge(edge[0], edge[1]))
+        assert undirected_graph.contains_edge(edge[0], edge[1])
+        assert undirected_graph.contains_edge(edge[1], edge[0])
+        assert directed_graph.contains_edge(edge[0], edge[1])
 
     def __assert_graph_edge_does_not_exist_check(
         self,
         undirected_graph: GraphAdjacencyList,
         directed_graph: GraphAdjacencyList,
         edge: list[int],
     ) -> None:
-        self.assertFalse(undirected_graph.contains_edge(edge[0], edge[1]))
-        self.assertFalse(undirected_graph.contains_edge(edge[1], edge[0]))
-        self.assertFalse(directed_graph.contains_edge(edge[0], edge[1]))
+        assert not undirected_graph.contains_edge(edge[0], edge[1])
+        assert not undirected_graph.contains_edge(edge[1], edge[0])
+        assert not directed_graph.contains_edge(edge[0], edge[1])
 
     def __assert_graph_vertex_exists_check(
         self,
         undirected_graph: GraphAdjacencyList,
         directed_graph: GraphAdjacencyList,
         vertex: int,
     ) -> None:
-        self.assertTrue(undirected_graph.contains_vertex(vertex))
-        self.assertTrue(directed_graph.contains_vertex(vertex))
+        assert undirected_graph.contains_vertex(vertex)
+        assert directed_graph.contains_vertex(vertex)
 
     def __assert_graph_vertex_does_not_exist_check(
         self,
         undirected_graph: GraphAdjacencyList,
         directed_graph: GraphAdjacencyList,
         vertex: int,
     ) -> None:
-        self.assertFalse(undirected_graph.contains_vertex(vertex))
-        self.assertFalse(directed_graph.contains_vertex(vertex))
+        assert not undirected_graph.contains_vertex(vertex)
+        assert not directed_graph.contains_vertex(vertex)
 
     def __generate_random_edges(
         self, vertices: list[int], edge_pick_count: int
     ) -> list[list[int]]:
-        self.assertTrue(edge_pick_count <= len(vertices))
+        assert edge_pick_count <= len(vertices)
 
         random_source_vertices: list[int] = random.sample(
             vertices[0 : int(len(vertices) / 2)], edge_pick_count
@@ -281,8 +283,8 @@ def test_init_check(self) -> None:
             self.__assert_graph_edge_exists_check(
                 undirected_graph, directed_graph, edge
             )
-        self.assertFalse(undirected_graph.directed)
-        self.assertTrue(directed_graph.directed)
+        assert not undirected_graph.directed
+        assert directed_graph.directed
 
     def test_contains_vertex(self) -> None:
         random_vertices: list[int] = random.sample(range(101), 20)
@@ -297,12 +299,8 @@ def test_contains_vertex(self) -> None:
 
         # Test contains_vertex
         for num in range(101):
-            self.assertEqual(
-                num in random_vertices, undirected_graph.contains_vertex(num)
-            )
-            self.assertEqual(
-                num in random_vertices, directed_graph.contains_vertex(num)
-            )
+            assert (num in random_vertices) == undirected_graph.contains_vertex(num)
+            assert (num in random_vertices) == directed_graph.contains_vertex(num)
 
     def test_add_vertices(self) -> None:
         random_vertices: list[int] = random.sample(range(101), 20)
@@ -507,9 +505,9 @@ def test_add_vertex_exception_check(self) -> None:
         ) = self.__generate_graphs(20, 0, 100, 4)
 
         for vertex in random_vertices:
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 undirected_graph.add_vertex(vertex)
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 directed_graph.add_vertex(vertex)
 
     def test_remove_vertex_exception_check(self) -> None:
@@ -522,9 +520,9 @@ def test_remove_vertex_exception_check(self) -> None:
 
         for i in range(101):
             if i not in random_vertices:
-                with self.assertRaises(ValueError):
+                with pytest.raises(ValueError):
                     undirected_graph.remove_vertex(i)
-                with self.assertRaises(ValueError):
+                with pytest.raises(ValueError):
                     directed_graph.remove_vertex(i)
 
     def test_add_edge_exception_check(self) -> None:
@@ -536,9 +534,9 @@ def test_add_edge_exception_check(self) -> None:
         ) = self.__generate_graphs(20, 0, 100, 4)
 
         for edge in random_edges:
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 undirected_graph.add_edge(edge[0], edge[1])
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 directed_graph.add_edge(edge[0], edge[1])
 
     def test_remove_edge_exception_check(self) -> None:
@@ -560,9 +558,9 @@ def test_remove_edge_exception_check(self) -> None:
                     more_random_edges.append(edge)
 
         for edge in more_random_edges:
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 undirected_graph.remove_edge(edge[0], edge[1])
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 directed_graph.remove_edge(edge[0], edge[1])
 
     def test_contains_edge_exception_check(self) -> None:
@@ -574,14 +572,14 @@ def test_contains_edge_exception_check(self) -> None:
         ) = self.__generate_graphs(20, 0, 100, 4)
 
         for vertex in random_vertices:
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 undirected_graph.contains_edge(vertex, 102)
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 directed_graph.contains_edge(vertex, 102)
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             undirected_graph.contains_edge(103, 102)
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             directed_graph.contains_edge(103, 102)