Add flake8-builtins to pre-commit and fix errors

.pre-commit-config.yaml

@@ -40,7 +40,7 @@ repos:
           - --ignore=E203,W503
           - --max-complexity=25
           - --max-line-length=88
-        additional_dependencies: [pep8-naming]
+        additional_dependencies: [flake8-builtins, pep8-naming]
 
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v0.982

arithmetic_analysis/gaussian_elimination.py

@@ -33,11 +33,11 @@ def retroactive_resolution(
 
     x: NDArray[float64] = np.zeros((rows, 1), dtype=float)
     for row in reversed(range(rows)):
-        sum = 0
+        total = 0
         for col in range(row + 1, columns):
-            sum += coefficients[row, col] * x[col]
+            total += coefficients[row, col] * x[col]
 
-        x[row, 0] = (vector[row] - sum) / coefficients[row, row]
+        x[row, 0] = (vector[row] - total) / coefficients[row, row]
 
     return x
 

arithmetic_analysis/jacobi_iteration_method.py

@@ -147,14 +147,14 @@ def strictly_diagonally_dominant(table: NDArray[float64]) -> bool:
     is_diagonally_dominant = True
 
     for i in range(0, rows):
-        sum = 0
+        total = 0
         for j in range(0, cols - 1):
             if i == j:
                 continue
             else:
-                sum += table[i][j]
+                total += table[i][j]
 
-        if table[i][i] <= sum:
+        if table[i][i] <= total:
             raise ValueError("Coefficient matrix is not strictly diagonally dominant")
 
     return is_diagonally_dominant

audio_filters/show_response.py

@@ -34,7 +34,7 @@ def get_bounds(
     return lowest, highest
 
 
-def show_frequency_response(filter: FilterType, samplerate: int) -> None:
+def show_frequency_response(filter_type: FilterType, samplerate: int) -> None:
     """
     Show frequency response of a filter
 
@@ -45,7 +45,7 @@ def show_frequency_response(filter: FilterType, samplerate: int) -> None:
 
     size = 512
     inputs = [1] + [0] * (size - 1)
-    outputs = [filter.process(item) for item in inputs]
+    outputs = [filter_type.process(item) for item in inputs]
 
     filler = [0] * (samplerate - size)  # zero-padding
     outputs += filler
@@ -66,7 +66,7 @@ def show_frequency_response(filter: FilterType, samplerate: int) -> None:
     plt.show()
 
 
-def show_phase_response(filter: FilterType, samplerate: int) -> None:
+def show_phase_response(filter_type: FilterType, samplerate: int) -> None:
     """
     Show phase response of a filter
 
@@ -77,7 +77,7 @@ def show_phase_response(filter: FilterType, samplerate: int) -> None:
 
     size = 512
     inputs = [1] + [0] * (size - 1)
-    outputs = [filter.process(item) for item in inputs]
+    outputs = [filter_type.process(item) for item in inputs]
 
     filler = [0] * (samplerate - size)  # zero-padding
     outputs += filler

backtracking/hamiltonian_cycle.py

@@ -95,10 +95,10 @@ def util_hamilton_cycle(graph: list[list[int]], path: list[int], curr_ind: int)
         return graph[path[curr_ind - 1]][path[0]] == 1
 
     # Recursive Step
-    for next in range(0, len(graph)):
-        if valid_connection(graph, next, curr_ind, path):
+    for next_ver in range(0, len(graph)):
+        if valid_connection(graph, next_ver, curr_ind, path):
             # Insert current vertex  into path as next transition
-            path[curr_ind] = next
+            path[curr_ind] = next_ver
             # Validate created path
             if util_hamilton_cycle(graph, path, curr_ind + 1):
                 return True

data_structures/binary_tree/avl_tree.py

@@ -33,7 +33,7 @@ def pop(self) -> Any:
     def count(self) -> int:
         return self.tail - self.head
 
-    def print(self) -> None:
+    def print_queue(self) -> None:
         print(self.data)
         print("**************")
         print(self.data[self.head : self.tail])

data_structures/binary_tree/fenwick_tree.py

@@ -46,7 +46,7 @@ def init(self, arr: list[int]) -> None:
         self.size = len(arr)
         self.tree = deepcopy(arr)
         for i in range(1, self.size):
-            j = self.next(i)
+            j = self.next_index(i)
             if j < self.size:
                 self.tree[j] += self.tree[i]
 
@@ -64,13 +64,13 @@ def get_array(self) -> list[int]:
         """
         arr = self.tree[:]
         for i in range(self.size - 1, 0, -1):
-            j = self.next(i)
+            j = self.next_index(i)
             if j < self.size:
                 arr[j] -= arr[i]
         return arr
 
     @staticmethod
-    def next(index: int) -> int:
+    def next_index(index: int) -> int:
         return index + (index & (-index))
 
     @staticmethod
@@ -102,7 +102,7 @@ def add(self, index: int, value: int) -> None:
             return
         while index < self.size:
             self.tree[index] += value
-            index = self.next(index)
+            index = self.next_index(index)
 
     def update(self, index: int, value: int) -> None:
         """

data_structures/heap/heap.py

@@ -88,7 +88,7 @@ def build_max_heap(self, collection: Iterable[float]) -> None:
             for i in range(self.heap_size // 2 - 1, -1, -1):
                 self.max_heapify(i)
 
-    def max(self) -> float:
+    def get_max(self) -> float:
         """return the max in the heap"""
         if self.heap_size >= 1:
             return self.h[0]

data_structures/linked_list/__init__.py

@@ -11,7 +11,7 @@
 
 
 class Node:
-    def __init__(self, item: Any, next: Any) -> None:
+    def __init__(self, item: Any, next: Any) -> None:  # noqa: A002
         self.item = item
         self.next = next
 

data_structures/linked_list/merge_two_lists.py

@@ -13,7 +13,7 @@
 @dataclass
 class Node:
     data: int
-    next: Node | None
+    next: Node | None  # noqa: A003
 
 
 class SortedLinkedList:

data_structures/linked_list/singly_linked_list.py

@@ -392,7 +392,7 @@ def test_singly_linked_list_2() -> None:
     This section of the test used varying data types for input.
     >>> test_singly_linked_list_2()
     """
-    input = [
+    test_input = [
         -9,
         100,
         Node(77345112),
@@ -410,7 +410,7 @@ def test_singly_linked_list_2() -> None:
     ]
     linked_list = LinkedList()
 
-    for i in input:
+    for i in test_input:
         linked_list.insert_tail(i)
 
     # Check if it's empty or not

data_structures/queue/double_ended_queue.py

@@ -42,7 +42,7 @@ class _Node:
         """
 
         val: Any = None
-        next: Deque._Node | None = None
+        next: Deque._Node | None = None  # noqa: A003
         prev: Deque._Node | None = None
 
     class _Iterator:
@@ -179,7 +179,7 @@ def appendleft(self, val: Any) -> None:
             # make sure there were no errors
             assert not self.is_empty(), "Error on appending value."
 
-    def extend(self, iter: Iterable[Any]) -> None:
+    def extend(self, iterable: Iterable[Any]) -> None:
         """
         Appends every value of iter to the end of the deque.
         Time complexity: O(n)
@@ -205,10 +205,10 @@ def extend(self, iter: Iterable[Any]) -> None:
         >>> list(our_deque_2) == list(deque_collections_2)
         True
         """
-        for val in iter:
+        for val in iterable:
             self.append(val)
 
-    def extendleft(self, iter: Iterable[Any]) -> None:
+    def extendleft(self, iterable: Iterable[Any]) -> None:
         """
         Appends every value of iter to the beginning of the deque.
         Time complexity: O(n)
@@ -234,7 +234,7 @@ def extendleft(self, iter: Iterable[Any]) -> None:
         >>> list(our_deque_2) == list(deque_collections_2)
         True
         """
-        for val in iter:
+        for val in iterable:
             self.appendleft(val)
 
     def pop(self) -> Any:

data_structures/stacks/next_greater_element.py

@@ -17,12 +17,12 @@ def next_greatest_element_slow(arr: list[float]) -> list[float]:
     arr_size = len(arr)
 
     for i in range(arr_size):
-        next: float = -1
+        next_: float = -1
         for j in range(i + 1, arr_size):
             if arr[i] < arr[j]:
-                next = arr[j]
+                next_ = arr[j]
                 break
-        result.append(next)
+        result.append(next_)
     return result
 
 
@@ -36,12 +36,12 @@ def next_greatest_element_fast(arr: list[float]) -> list[float]:
     """
     result = []
     for i, outer in enumerate(arr):
-        next: float = -1
+        next_: float = -1
         for inner in arr[i + 1 :]:
             if outer < inner:
-                next = inner
+                next_ = inner
                 break
-        result.append(next)
+        result.append(next_)
     return result
 
 

digital_image_processing/index_calculation.py

@@ -497,9 +497,9 @@ def s(self):
         https://www.indexdatabase.de/db/i-single.php?id=77
         :return: index
         """
-        max = np.max([np.max(self.red), np.max(self.green), np.max(self.blue)])
-        min = np.min([np.min(self.red), np.min(self.green), np.min(self.blue)])
-        return (max - min) / max
+        max_ = np.max([np.max(self.red), np.max(self.green), np.max(self.blue)])
+        min_ = np.min([np.min(self.red), np.min(self.green), np.min(self.blue)])
+        return (max_ - min_) / max_
 
     def _if(self):
         """

dynamic_programming/optimal_binary_search_tree.py

@@ -104,7 +104,7 @@ def find_optimal_binary_search_tree(nodes):
     dp = [[freqs[i] if i == j else 0 for j in range(n)] for i in range(n)]
     # sum[i][j] stores the sum of key frequencies between i and j inclusive in nodes
     # array
-    sum = [[freqs[i] if i == j else 0 for j in range(n)] for i in range(n)]
+    total = [[freqs[i] if i == j else 0 for j in range(n)] for i in range(n)]
     # stores tree roots that will be used later for constructing binary search tree
     root = [[i if i == j else 0 for j in range(n)] for i in range(n)]
 
@@ -113,14 +113,14 @@ def find_optimal_binary_search_tree(nodes):
             j = i + interval_length - 1
 
             dp[i][j] = sys.maxsize  # set the value to "infinity"
-            sum[i][j] = sum[i][j - 1] + freqs[j]
+            total[i][j] = total[i][j - 1] + freqs[j]
 
             # Apply Knuth's optimization
             # Loop without optimization: for r in range(i, j + 1):
             for r in range(root[i][j - 1], root[i + 1][j] + 1):  # r is a temporal root
                 left = dp[i][r - 1] if r != i else 0  # optimal cost for left subtree
                 right = dp[r + 1][j] if r != j else 0  # optimal cost for right subtree
-                cost = left + sum[i][j] + right
+                cost = left + total[i][j] + right
 
                 if dp[i][j] > cost:
                     dp[i][j] = cost

graphs/a_star.py

@@ -40,10 +40,10 @@ def search(
         else:  # to choose the least costliest action so as to move closer to the goal
             cell.sort()
             cell.reverse()
-            next = cell.pop()
-            x = next[2]
-            y = next[3]
-            g = next[1]
+            next_cell = cell.pop()
+            x = next_cell[2]
+            y = next_cell[3]
+            g = next_cell[1]
 
             if x == goal[0] and y == goal[1]:
                 found = True

graphs/dijkstra.py

@@ -56,8 +56,8 @@ def dijkstra(graph, start, end):
         for v, c in graph[u]:
             if v in visited:
                 continue
-            next = cost + c
-            heapq.heappush(heap, (next, v))
+            next_item = cost + c
+            heapq.heappush(heap, (next_item, v))
     return -1
 
 

graphs/finding_bridges.py

@@ -72,22 +72,22 @@ def compute_bridges(graph: dict[int, list[int]]) -> list[tuple[int, int]]:
     []
     """
 
-    id = 0
+    id_ = 0
     n = len(graph)  # No of vertices in graph
     low = [0] * n
     visited = [False] * n
 
-    def dfs(at, parent, bridges, id):
+    def dfs(at, parent, bridges, id_):
         visited[at] = True
-        low[at] = id
-        id += 1
+        low[at] = id_
+        id_ += 1
         for to in graph[at]:
             if to == parent:
                 pass
             elif not visited[to]:
-                dfs(to, at, bridges, id)
+                dfs(to, at, bridges, id_)
                 low[at] = min(low[at], low[to])
-                if id <= low[to]:
+                if id_ <= low[to]:
                     bridges.append((at, to) if at < to else (to, at))
             else:
                 # This edge is a back edge and cannot be a bridge
@@ -96,7 +96,7 @@ def dfs(at, parent, bridges, id):
     bridges: list[tuple[int, int]] = []
     for i in range(n):
         if not visited[i]:
-            dfs(i, -1, bridges, id)
+            dfs(i, -1, bridges, id_)
     return bridges
 
 

graphs/prim.py

@@ -13,15 +13,15 @@
 class Vertex:
     """Class Vertex."""
 
-    def __init__(self, id):
+    def __init__(self, id_):
         """
         Arguments:
             id - input an id to identify the vertex
         Attributes:
             neighbors - a list of the vertices it is linked to
             edges     - a dict to store the edges's weight
         """
-        self.id = str(id)
+        self.id = str(id_)
         self.key = None
         self.pi = None
         self.neighbors = []

hashes/djb2.py

@@ -29,7 +29,7 @@ def djb2(s: str) -> int:
     >>> djb2('scramble bits')
     1609059040
     """
-    hash = 5381
+    hash_ = 5381
     for x in s:
-        hash = ((hash << 5) + hash) + ord(x)
-    return hash & 0xFFFFFFFF
+        hash_ = ((hash_ << 5) + hash_) + ord(x)
+    return hash_ & 0xFFFFFFFF

hashes/sdbm.py

@@ -31,7 +31,7 @@ def sdbm(plain_text: str) -> int:
     >>> sdbm('scramble bits')
     730247649148944819640658295400555317318720608290373040936089
     """
-    hash = 0
+    hash_ = 0
     for plain_chr in plain_text:
-        hash = ord(plain_chr) + (hash << 6) + (hash << 16) - hash
-    return hash
+        hash_ = ord(plain_chr) + (hash_ << 6) + (hash_ << 16) - hash_
+    return hash_