ruff rule ANN201 missing-return-type-undocumented-public-function

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)

data_structures/linked_list/doubly_linked_list_two.py

@@ -138,7 +138,7 @@ def get_node(self, item: DataType) -> Node:
             node = node.next
         raise Exception("Node not found")
 
-    def delete_value(self, value):
+    def delete_value(self, value) -> None:
         if (node := self.get_node(value)) is not None:
             if node == self.head:
                 self.head = self.head.next

data_structures/linked_list/singly_linked_list.py

@@ -498,7 +498,7 @@ def test_singly_linked_list_2() -> None:
     )
 
 
-def main():
+def main() -> None:
     from doctest import testmod
 
     testmod()

data_structures/linked_list/skip_list.py

@@ -160,7 +160,7 @@ def _locate_node(self, key) -> tuple[Node[KT, VT] | None, list[Node[KT, VT]]]:
         else:
             return None, update_vector
 
-    def delete(self, key: KT):
+    def delete(self, key: KT) -> None:
         """
         :param key: Key to remove from list.
 
@@ -186,7 +186,7 @@ def delete(self, key: KT):
                     else:
                         update_node.forward = update_node.forward[:i]
 
-    def insert(self, key: KT, value: VT):
+    def insert(self, key: KT, value: VT) -> None:
         """
         :param key: Key to insert.
         :param value: Value associated with given key.
@@ -246,7 +246,7 @@ def find(self, key: VT) -> VT | None:
         return None
 
 
-def test_insert():
+def test_insert() -> None:
     skip_list = SkipList()
     skip_list.insert("Key1", 3)
     skip_list.insert("Key2", 12)
@@ -266,7 +266,7 @@ def test_insert():
     assert all_values["Key4"] == -19
 
 
-def test_insert_overrides_existing_value():
+def test_insert_overrides_existing_value() -> None:
     skip_list = SkipList()
     skip_list.insert("Key1", 10)
     skip_list.insert("Key1", 12)
@@ -294,12 +294,12 @@ def test_insert_overrides_existing_value():
     assert all_values["Key10"] == 10
 
 
-def test_searching_empty_list_returns_none():
+def test_searching_empty_list_returns_none() -> None:
     skip_list = SkipList()
     assert skip_list.find("Some key") is None
 
 
-def test_search():
+def test_search() -> None:
     skip_list = SkipList()
 
     skip_list.insert("Key2", 20)
@@ -315,14 +315,14 @@ def test_search():
     assert skip_list.find("V") == 13
 
 
-def test_deleting_item_from_empty_list_do_nothing():
+def test_deleting_item_from_empty_list_do_nothing() -> None:
     skip_list = SkipList()
     skip_list.delete("Some key")
 
     assert len(skip_list.head.forward) == 0
 
 
-def test_deleted_items_are_not_founded_by_find_method():
+def test_deleted_items_are_not_founded_by_find_method() -> None:
     skip_list = SkipList()
 
     skip_list.insert("Key1", 12)
@@ -337,7 +337,7 @@ def test_deleted_items_are_not_founded_by_find_method():
     assert skip_list.find("Key2") is None
 
 
-def test_delete_removes_only_given_key():
+def test_delete_removes_only_given_key() -> None:
     skip_list = SkipList()
 
     skip_list.insert("Key1", 12)
@@ -370,7 +370,7 @@ def test_delete_removes_only_given_key():
     assert skip_list.find("Key2") is None
 
 
-def test_delete_doesnt_leave_dead_nodes():
+def test_delete_doesnt_leave_dead_nodes() -> None:
     skip_list = SkipList()
 
     skip_list.insert("Key1", 12)
@@ -388,7 +388,7 @@ def traverse_keys(node):
     assert len(set(traverse_keys(skip_list.head))) == 4
 
 
-def test_iter_always_yields_sorted_values():
+def test_iter_always_yields_sorted_values() -> None:
     def is_sorted(lst):
         return all(next_item >= item for item, next_item in pairwise(lst))
 
@@ -405,7 +405,7 @@ def is_sorted(lst):
     assert is_sorted(list(skip_list))
 
 
-def pytests():
+def pytests() -> None:
     for _ in range(100):
         # Repeat test 100 times due to the probabilistic nature of skip list
         # random values == random bugs
@@ -423,7 +423,7 @@ def pytests():
         test_iter_always_yields_sorted_values()
 
 
-def main():
+def main() -> None:
     """
     >>> pytests()
     """

data_structures/queues/priority_queue_using_list.py

@@ -177,7 +177,7 @@ def __str__(self) -> str:
         return str(self.queue)
 
 
-def fixed_priority_queue():
+def fixed_priority_queue() -> None:
     fpq = FixedPriorityQueue()
     fpq.enqueue(0, 10)
     fpq.enqueue(1, 70)
@@ -202,7 +202,7 @@ def fixed_priority_queue():
     print(fpq.dequeue())
 
 
-def element_priority_queue():
+def element_priority_queue() -> None:
     epq = ElementPriorityQueue()
     epq.enqueue(10)
     epq.enqueue(70)

data_structures/stacks/stock_span_problem.py

@@ -58,7 +58,7 @@ def calculate_span(price: list[int]) -> list[int]:
 
 
 # A utility function to print elements of array
-def print_array(arr, n):
+def print_array(arr, n) -> None:
     for i in range(n):
         print(arr[i], end=" ")
 

digital_image_processing/edge_detection/canny.py

@@ -72,7 +72,7 @@ def suppress_non_maximum(image_shape, gradient_direction, sobel_grad):
 
 def detect_high_low_threshold(
     image_shape, destination, threshold_low, threshold_high, weak, strong
-):
+) -> None:
     """
     High-Low threshold detection. If an edge pixel's gradient value is higher
     than the high threshold value, it is marked as a strong edge pixel. If an
@@ -91,7 +91,7 @@ def detect_high_low_threshold(
                 destination[row, col] = weak
 
 
-def track_edge(image_shape, destination, weak, strong):
+def track_edge(image_shape, destination, weak, strong) -> None:
     """
     Edge tracking. Usually a weak edge pixel caused from true edges will be connected
     to a strong edge pixel while noise responses are unconnected. As long as there is