ruff rule ANN202 missing-return-type-private-function

Author: cclauss

data_structures/arrays/sudoku_solver.py

@@ -41,7 +41,7 @@ def cross(items_a, items_b):
 peers = {s: {x for u in units[s] for x in u} - {s} for s in squares}
 
 
-def test():
+def test() -> None:
     """A set of unit tests."""
     assert len(squares) == 81
     assert len(unitlist) == 27
@@ -121,7 +121,7 @@ def eliminate(values, s, d):
     return values
 
 
-def display(values):
+def display(values) -> None:
     """
     Display these values as a 2-D grid.
     """
@@ -166,7 +166,7 @@ def search(values):
     return some(search(assign(values.copy(), s, d)) for d in values[s])
 
 
-def solve_all(grids, name="", showif=0.0):
+def solve_all(grids, name="", showif=0.0) -> None:
     """
     Attempt to solve a sequence of grids. Report results.
     When showif is a number of seconds, display puzzles that take longer.

data_structures/binary_tree/binary_tree_mirror.py

@@ -4,7 +4,7 @@
 """
 
 
-def binary_tree_mirror_dict(binary_tree_mirror_dictionary: dict, root: int):
+def binary_tree_mirror_dict(binary_tree_mirror_dictionary: dict, root: int) -> None:
     if not root or root not in binary_tree_mirror_dictionary:
         return
     left_child, right_child = binary_tree_mirror_dictionary[root][:2]

data_structures/binary_tree/segment_tree.py

@@ -35,7 +35,7 @@ def right(self, idx):
         """
         return idx * 2 + 1
 
-    def build(self, idx, left, right):
+    def build(self, idx, left, right) -> None:
         if left == right:
             self.st[idx] = self.A[left]
         else:
@@ -56,7 +56,7 @@ def update(self, a, b, val):
         """
         return self.update_recursive(1, 0, self.N - 1, a - 1, b - 1, val)
 
-    def update_recursive(self, idx, left, right, a, b, val):
+    def update_recursive(self, idx, left, right, a, b, val) -> bool:
         """
         update(1, 1, N, a, b, v) for update val v to [a,b]
         """
@@ -96,7 +96,7 @@ def query_recursive(self, idx, left, right, a, b):
         q2 = self.query_recursive(self.right(idx), mid + 1, right, a, b)
         return max(q1, q2)
 
-    def show_data(self):
+    def show_data(self) -> None:
         show_list = []
         for i in range(1, self.N + 1):
             show_list += [self.query(i, i)]

data_structures/binary_tree/segment_tree_other.py

@@ -133,7 +133,7 @@ def __init__(self, collection: Sequence, function):
         if self.collection:
             self.root = self._build_tree(0, len(collection) - 1)
 
-    def update(self, i, val):
+    def update(self, i, val) -> None:
         """
         Update an element in log(N) time
         :param i: position to be update

data_structures/hashing/hash_table.py

@@ -85,7 +85,7 @@ def _step_by_step(self, step_ord):
         print(list(range(len(self.values))))
         print(self.values)
 
-    def bulk_insert(self, values):
+    def bulk_insert(self, values) -> None:
         """
         bulk_insert is used for entering more than one element at a time
         in the HashTable.
@@ -236,15 +236,15 @@ def _collision_resolution(self, key, data=None):
 
         return new_key
 
-    def rehashing(self):
+    def rehashing(self) -> None:
         survivor_values = [value for value in self.values if value is not None]
         self.size_table = next_prime(self.size_table, factor=2)
         self._keys.clear()
         self.values = [None] * self.size_table  # hell's pointers D: don't DRY ;/
         for value in survivor_values:
             self.insert_data(value)
 
-    def insert_data(self, data):
+    def insert_data(self, data) -> None:
         """
         insert_data is used for inserting a single element at a time in the HashTable.
 

data_structures/hashing/tests/test_hash_map.py

@@ -74,7 +74,7 @@ def _run_operation(obj, fun, *args):
         pytest.param(_add_with_resize_down, id="add with resize down"),
     ],
 )
-def test_hash_map_is_the_same_as_dict(operations):
+def test_hash_map_is_the_same_as_dict(operations) -> None:
     my = HashMap(initial_block_size=4)
     py = {}
     for _, (fun, *args) in enumerate(operations):
@@ -87,7 +87,7 @@ def test_hash_map_is_the_same_as_dict(operations):
         assert set(my.items()) == set(py.items())
 
 
-def test_no_new_methods_was_added_to_api():
+def test_no_new_methods_was_added_to_api() -> None:
     def is_public(name: str) -> bool:
         return not name.startswith("_")
 

data_structures/heap/binomial_heap.py

@@ -203,7 +203,7 @@ def merge_heaps(self, other):
         # Return the merged heap
         return self
 
-    def insert(self, val):
+    def insert(self, val) -> None:
         """
         insert a value in the heap
         """

data_structures/heap/min_heap.py

@@ -64,7 +64,7 @@ def build_heap(self, array):
         return array
 
     # this is min-heapify method
-    def sift_down(self, idx, array):
+    def sift_down(self, idx, array) -> None:
         while True:
             left = self.get_left_child_idx(idx)
             right = self.get_right_child_idx(idx)
@@ -88,7 +88,7 @@ def sift_down(self, idx, array):
             else:
                 break
 
-    def sift_up(self, idx):
+    def sift_up(self, idx) -> None:
         p = self.get_parent_idx(idx)
         while p >= 0 and self.heap[p] > self.heap[idx]:
             self.heap[p], self.heap[idx] = self.heap[idx], self.heap[p]
@@ -114,7 +114,7 @@ def remove(self):
         self.sift_down(0, self.heap)
         return x
 
-    def insert(self, node):
+    def insert(self, node) -> None:
         self.heap.append(node)
         self.idx_of_element[node] = len(self.heap) - 1
         self.heap_dict[node.name] = node.val
@@ -123,7 +123,7 @@ def insert(self, node):
     def is_empty(self):
         return len(self.heap) == 0
 
-    def decrease_key(self, node, new_value):
+    def decrease_key(self, node, new_value) -> None:
         assert self.heap[self.idx_of_element[node]].val > new_value, (
             "newValue must be less that current value"
         )

data_structures/kd_tree/tests/test_kdtree.py

@@ -23,7 +23,9 @@
         (10, 10.0, 3, -2, KDNode),  # Depth = -2, 3D points
     ],
 )
-def test_build_kdtree(num_points, cube_size, num_dimensions, depth, expected_result):
+def test_build_kdtree(
+    num_points, cube_size, num_dimensions, depth, expected_result
+) -> None:
     """
     Test that KD-Tree is built correctly.
 
@@ -58,7 +60,7 @@ def test_build_kdtree(num_points, cube_size, num_dimensions, depth, expected_res
         )
 
 
-def test_nearest_neighbour_search():
+def test_nearest_neighbour_search() -> None:
     """
     Test the nearest neighbor search function.
     """
@@ -85,7 +87,7 @@ def test_nearest_neighbour_search():
     assert nodes_visited >= 0
 
 
-def test_edge_cases():
+def test_edge_cases() -> None:
     """
     Test edge cases such as an empty KD-Tree.
     """

data_structures/linked_list/doubly_linked_list.py

@@ -57,13 +57,13 @@ def __len__(self):
         """
         return sum(1 for _ in self)
 
-    def insert_at_head(self, data):
+    def insert_at_head(self, data) -> None:
         self.insert_at_nth(0, data)
 
-    def insert_at_tail(self, data):
+    def insert_at_tail(self, data) -> None:
         self.insert_at_nth(len(self), data)
 
-    def insert_at_nth(self, index: int, data):
+    def insert_at_nth(self, index: int, data) -> None:
         """
         >>> linked_list = DoublyLinkedList()
         >>> linked_list.insert_at_nth(-1, 666)