Solved codespell

AryanJadhav15 · AryanJadhav15 · commit 3f30ca2cb86e · 2025-10-01T20:07:06.000+05:30
diff --git a/ciphers/base64_cipher.py b/ciphers/base64_cipher.py
@@ -105,13 +105,13 @@ def base64_decode(encoded_data: str) -> bytes:
 
     # Check if the encoded string contains non base64 characters
     if padding:
-        assert all(char in B64_CHARSET for char in encoded_data[:-padding]), (
-            "Invalid base64 character(s) found."
-        )
+        assert all(
+            char in B64_CHARSET for char in encoded_data[:-padding]
+        ), "Invalid base64 character(s) found."
     else:
-        assert all(char in B64_CHARSET for char in encoded_data), (
-            "Invalid base64 character(s) found."
-        )
+        assert all(
+            char in B64_CHARSET for char in encoded_data
+        ), "Invalid base64 character(s) found."
 
     # Check the padding
     assert len(encoded_data) % 4 == 0 and padding < 3, "Incorrect padding"
diff --git a/computer_vision/cnn_classification.py b/computer_vision/cnn_classification.py
@@ -22,7 +22,6 @@
 # Part 1 - Building the CNN
 
 import numpy as np
-
 # Importing the Keras libraries and packages
 import tensorflow as tf
 from keras import layers, models
diff --git a/data_structures/hashing/number_theory/prime_numbers.py b/data_structures/hashing/number_theory/prime_numbers.py
@@ -32,9 +32,9 @@ def is_prime(number: int) -> bool:
     """
 
     # precondition
-    assert isinstance(number, int) and (number >= 0), (
-        "'number' must been an int and positive"
-    )
+    assert isinstance(number, int) and (
+        number >= 0
+    ), "'number' must been an int and positive"
 
     if 1 < number < 4:
         # 2 and 3 are primes
diff --git a/data_structures/heap/min_heap.py b/data_structures/heap/min_heap.py
@@ -124,9 +124,9 @@ def is_empty(self):
         return len(self.heap) == 0
 
     def decrease_key(self, node, new_value):
-        assert self.heap[self.idx_of_element[node]].val > new_value, (
-            "newValue must be less that current value"
-        )
+        assert (
+            self.heap[self.idx_of_element[node]].val > new_value
+        ), "newValue must be less that current value"
         node.val = new_value
         self.heap_dict[node.name] = new_value
         self.sift_up(self.idx_of_element[node])
diff --git a/data_structures/kd_tree/example/example_usage.py b/data_structures/kd_tree/example/example_usage.py
@@ -10,7 +10,8 @@
 
 from data_structures.kd_tree.build_kdtree import build_kdtree
 from data_structures.kd_tree.example.hypercube_points import hypercube_points
-from data_structures.kd_tree.nearest_neighbour_search import nearest_neighbour_search
+from data_structures.kd_tree.nearest_neighbour_search import \
+    nearest_neighbour_search
 
 
 def main() -> None:
diff --git a/data_structures/kd_tree/tests/test_kdtree.py b/data_structures/kd_tree/tests/test_kdtree.py
@@ -12,7 +12,8 @@
 from data_structures.kd_tree.build_kdtree import build_kdtree
 from data_structures.kd_tree.example.hypercube_points import hypercube_points
 from data_structures.kd_tree.kd_node import KDNode
-from data_structures.kd_tree.nearest_neighbour_search import nearest_neighbour_search
+from data_structures.kd_tree.nearest_neighbour_search import \
+    nearest_neighbour_search
 
 
 @pytest.mark.parametrize(
@@ -48,14 +49,14 @@ def test_build_kdtree(num_points, cube_size, num_dimensions, depth, expected_res
         assert kdtree is not None, "Expected a KDNode, got None"
 
         # Check if root has correct dimensions
-        assert len(kdtree.point) == num_dimensions, (
-            f"Expected point dimension {num_dimensions}, got {len(kdtree.point)}"
-        )
+        assert (
+            len(kdtree.point) == num_dimensions
+        ), f"Expected point dimension {num_dimensions}, got {len(kdtree.point)}"
 
         # Check that the tree is balanced to some extent (simplistic check)
-        assert isinstance(kdtree, KDNode), (
-            f"Expected KDNode instance, got {type(kdtree)}"
-        )
+        assert isinstance(
+            kdtree, KDNode
+        ), f"Expected KDNode instance, got {type(kdtree)}"
 
 
 def test_nearest_neighbour_search():
diff --git a/data_structures/suffix_tree/tests/test_suffix_tree.py b/data_structures/suffix_tree/tests/test_suffix_tree.py
@@ -22,37 +22,37 @@ def test_search_existing_patterns(self) -> None:
         patterns = ["ana", "ban", "na"]
         for pattern in patterns:
             with self.subTest(pattern=pattern):
-                assert self.suffix_tree.search(pattern), (
-                    f"Pattern '{pattern}' should be found."
-                )
+                assert self.suffix_tree.search(
+                    pattern
+                ), f"Pattern '{pattern}' should be found."
 
     def test_search_non_existing_patterns(self) -> None:
         """Test searching for patterns that do not exist in the suffix tree."""
         patterns = ["xyz", "apple", "cat"]
         for pattern in patterns:
             with self.subTest(pattern=pattern):
-                assert not self.suffix_tree.search(pattern), (
-                    f"Pattern '{pattern}' should not be found."
-                )
+                assert not self.suffix_tree.search(
+                    pattern
+                ), f"Pattern '{pattern}' should not be found."
 
     def test_search_empty_pattern(self) -> None:
         """Test searching for an empty pattern."""
         assert self.suffix_tree.search(""), "An empty pattern should be found."
 
     def test_search_full_text(self) -> None:
         """Test searching for the full text."""
-        assert self.suffix_tree.search(self.text), (
-            "The full text should be found in the suffix tree."
-        )
+        assert self.suffix_tree.search(
+            self.text
+        ), "The full text should be found in the suffix tree."
 
     def test_search_substrings(self) -> None:
         """Test searching for substrings of the full text."""
         substrings = ["ban", "ana", "a", "na"]
         for substring in substrings:
             with self.subTest(substring=substring):
-                assert self.suffix_tree.search(substring), (
-                    f"Substring '{substring}' should be found."
-                )
+                assert self.suffix_tree.search(
+                    substring
+                ), f"Substring '{substring}' should be found."
 
 
 if __name__ == "__main__":
diff --git a/digital_image_processing/filters/gabor_filter.py b/digital_image_processing/filters/gabor_filter.py
@@ -1,7 +1,8 @@
 # Implementation of the Gaborfilter
 # https://en.wikipedia.org/wiki/Gabor_filter
 import numpy as np
-from cv2 import COLOR_BGR2GRAY, CV_8UC3, cvtColor, filter2D, imread, imshow, waitKey
+from cv2 import (COLOR_BGR2GRAY, CV_8UC3, cvtColor, filter2D, imread, imshow,
+                 waitKey)
 
 
 def gabor_filter_kernel(
@@ -48,9 +49,9 @@ def gabor_filter_kernel(
             _y = -sin_theta * px + cos_theta * py
 
             # fill kernel
-            gabor[y, x] = np.exp(-(_x**2 + gamma**2 * _y**2) / (2 * sigma**2)) * np.cos(
-                2 * np.pi * _x / lambd + psi
-            )
+            gabor[y, x] = np.exp(
+                -(_x**2 + gamma**2 * _y**2) / (2 * sigma**2)
+            ) * np.cos(2 * np.pi * _x / lambd + psi)
 
     return gabor
 
diff --git a/digital_image_processing/filters/laplacian_filter.py b/digital_image_processing/filters/laplacian_filter.py
@@ -3,16 +3,8 @@
 # @Date    : 10/04/2023
 
 import numpy as np
-from cv2 import (
-    BORDER_DEFAULT,
-    COLOR_BGR2GRAY,
-    CV_64F,
-    cvtColor,
-    filter2D,
-    imread,
-    imshow,
-    waitKey,
-)
+from cv2 import (BORDER_DEFAULT, COLOR_BGR2GRAY, CV_64F, cvtColor, filter2D,
+                 imread, imshow, waitKey)
 
 from digital_image_processing.filters.gaussian_filter import gaussian_filter
 
diff --git a/dynamic_programming/climbing_stairs.py b/dynamic_programming/climbing_stairs.py
@@ -25,9 +25,9 @@ def climb_stairs(number_of_steps: int) -> int:
         ...
     AssertionError: number_of_steps needs to be positive integer, your input -7
     """
-    assert isinstance(number_of_steps, int) and number_of_steps > 0, (
-        f"number_of_steps needs to be positive integer, your input {number_of_steps}"
-    )
+    assert (
+        isinstance(number_of_steps, int) and number_of_steps > 0
+    ), f"number_of_steps needs to be positive integer, your input {number_of_steps}"
     if number_of_steps == 1:
         return 1
     previous, current = 1, 1
diff --git a/dynamic_programming/iterating_through_submasks.py b/dynamic_programming/iterating_through_submasks.py
@@ -37,9 +37,9 @@ def list_of_submasks(mask: int) -> list[int]:
 
     """
 
-    assert isinstance(mask, int) and mask > 0, (
-        f"mask needs to be positive integer, your input {mask}"
-    )
+    assert (
+        isinstance(mask, int) and mask > 0
+    ), f"mask needs to be positive integer, your input {mask}"
 
     """
     first submask iterated will be mask itself then operation will be performed
diff --git a/financial/time_and_half_pay.py b/financial/time_and_half_pay.py
@@ -17,15 +17,15 @@ def pay(hours_worked: float, pay_rate: float, hours: float = 40) -> float:
     10.0
     """
     # Check that all input parameters are float or integer
-    assert isinstance(hours_worked, (float, int)), (
-        "Parameter 'hours_worked' must be of type 'int' or 'float'"
-    )
-    assert isinstance(pay_rate, (float, int)), (
-        "Parameter 'pay_rate' must be of type 'int' or 'float'"
-    )
-    assert isinstance(hours, (float, int)), (
-        "Parameter 'hours' must be of type 'int' or 'float'"
-    )
+    assert isinstance(
+        hours_worked, (float, int)
+    ), "Parameter 'hours_worked' must be of type 'int' or 'float'"
+    assert isinstance(
+        pay_rate, (float, int)
+    ), "Parameter 'pay_rate' must be of type 'int' or 'float'"
+    assert isinstance(
+        hours, (float, int)
+    ), "Parameter 'hours' must be of type 'int' or 'float'"
 
     normal_pay = hours_worked * pay_rate
     over_time = max(0, hours_worked - hours)
diff --git a/linear_algebra/src/test_linear_algebra.py b/linear_algebra/src/test_linear_algebra.py
@@ -11,14 +11,8 @@
 
 import pytest
 
-from .lib import (
-    Matrix,
-    Vector,
-    axpy,
-    square_zero_matrix,
-    unit_basis_vector,
-    zero_vector,
-)
+from .lib import (Matrix, Vector, axpy, square_zero_matrix, unit_basis_vector,
+                  zero_vector)
 
 
 class Test(unittest.TestCase):
diff --git a/maths/numerical_analysis/integration_by_simpson_approx.py b/maths/numerical_analysis/integration_by_simpson_approx.py
@@ -88,18 +88,18 @@ def simpson_integration(function, a: float, b: float, precision: int = 4) -> flo
     AssertionError: precision should be positive integer your input : -1
 
     """
-    assert callable(function), (
-        f"the function(object) passed should be callable your input : {function}"
-    )
+    assert callable(
+        function
+    ), f"the function(object) passed should be callable your input : {function}"
     assert isinstance(a, (float, int)), f"a should be float or integer your input : {a}"
     assert isinstance(function(a), (float, int)), (
         "the function should return integer or float return type of your function, "
         f"{type(a)}"
     )
     assert isinstance(b, (float, int)), f"b should be float or integer your input : {b}"
-    assert isinstance(precision, int) and precision > 0, (
-        f"precision should be positive integer your input : {precision}"
-    )
+    assert (
+        isinstance(precision, int) and precision > 0
+    ), f"precision should be positive integer your input : {precision}"
 
     # just applying the formula of simpson for approximate integration written in
     # mentioned article in first comment of this file and above this function
diff --git a/maths/prime_check.py b/maths/prime_check.py
@@ -73,12 +73,12 @@ def test_primes(self):
     def test_not_primes(self):
         with pytest.raises(ValueError):
             is_prime(-19)
-        assert not is_prime(0), (
-            "Zero doesn't have any positive factors, primes must have exactly two."
-        )
-        assert not is_prime(1), (
-            "One only has 1 positive factor, primes must have exactly two."
-        )
+        assert not is_prime(
+            0
+        ), "Zero doesn't have any positive factors, primes must have exactly two."
+        assert not is_prime(
+            1
+        ), "One only has 1 positive factor, primes must have exactly two."
         assert not is_prime(2 * 2)
         assert not is_prime(2 * 3)
         assert not is_prime(3 * 3)
diff --git a/maths/primelib.py b/maths/primelib.py
@@ -66,9 +66,9 @@ def is_prime(number: int) -> bool:
     """
 
     # precondition
-    assert isinstance(number, int) and (number >= 0), (
-        "'number' must been an int and positive"
-    )
+    assert isinstance(number, int) and (
+        number >= 0
+    ), "'number' must been an int and positive"
 
     status = True
 
@@ -254,9 +254,9 @@ def greatest_prime_factor(number):
     """
 
     # precondition
-    assert isinstance(number, int) and (number >= 0), (
-        "'number' must been an int and >= 0"
-    )
+    assert isinstance(number, int) and (
+        number >= 0
+    ), "'number' must been an int and >= 0"
 
     ans = 0
 
@@ -296,9 +296,9 @@ def smallest_prime_factor(number):
     """
 
     # precondition
-    assert isinstance(number, int) and (number >= 0), (
-        "'number' must been an int and >= 0"
-    )
+    assert isinstance(number, int) and (
+        number >= 0
+    ), "'number' must been an int and >= 0"
 
     ans = 0
 
@@ -399,9 +399,9 @@ def goldbach(number):
     """
 
     # precondition
-    assert isinstance(number, int) and (number > 2) and is_even(number), (
-        "'number' must been an int, even and > 2"
-    )
+    assert (
+        isinstance(number, int) and (number > 2) and is_even(number)
+    ), "'number' must been an int, even and > 2"
 
     ans = []  # this list will returned
 
@@ -525,9 +525,9 @@ def kg_v(number1, number2):
             done.append(n)
 
     # precondition
-    assert isinstance(ans, int) and (ans >= 0), (
-        "'ans' must been from type int and positive"
-    )
+    assert isinstance(ans, int) and (
+        ans >= 0
+    ), "'ans' must been from type int and positive"
 
     return ans
 
@@ -574,9 +574,9 @@ def get_prime(n):
             ans += 1
 
     # precondition
-    assert isinstance(ans, int) and is_prime(ans), (
-        "'ans' must been a prime number and from type int"
-    )
+    assert isinstance(ans, int) and is_prime(
+        ans
+    ), "'ans' must been a prime number and from type int"
 
     return ans
 
@@ -705,9 +705,9 @@ def is_perfect_number(number):
     """
 
     # precondition
-    assert isinstance(number, int) and (number > 1), (
-        "'number' must been an int and >= 1"
-    )
+    assert isinstance(number, int) and (
+        number > 1
+    ), "'number' must been an int and >= 1"
 
     divisors = get_divisors(number)
 
diff --git a/matrix/tests/test_matrix_operation.py b/matrix/tests/test_matrix_operation.py
@@ -7,7 +7,6 @@
 """
 
 import logging
-
 # standard libraries
 import sys
 
diff --git a/neural_network/input_data.py b/neural_network/input_data.py
diff --git a/other/password.py b/other/password.py
diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py
diff --git a/quantum/quantum_teleportation.py.DISABLED.txt b/quantum/quantum_teleportation.py.DISABLED.txt
diff --git a/scripts/validate_solutions.py b/scripts/validate_solutions.py
diff --git a/strings/string_to_num.py b/strings/string_to_num.py
