Merge branch 'TheAlgorithms:master' into master

Author: MaximSmolskiy

audio_filters/show_response.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from abc import abstractmethod
 from math import pi
 from typing import Protocol
 
@@ -8,14 +9,14 @@
 
 
 class FilterType(Protocol):
+    @abstractmethod
     def process(self, sample: float) -> float:
         """
         Calculate y[n]
 
         >>> issubclass(FilterType, Protocol)
         True
         """
-        return 0.0
 
 
 def get_bounds(

data_structures/hashing/hash_table.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+from abc import abstractmethod
+
 from .number_theory.prime_numbers import next_prime
 
 
@@ -173,6 +175,7 @@ def _set_value(self, key, data):
         self.values[key] = data
         self._keys[key] = data
 
+    @abstractmethod
     def _collision_resolution(self, key, data=None):
         """
         This method is a type of open addressing which is used for handling collision.

data_structures/hashing/quadratic_probing.py

@@ -11,7 +11,7 @@ class QuadraticProbing(HashTable):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-    def _collision_resolution(self, key, data=None):
+    def _collision_resolution(self, key, data=None):  # noqa: ARG002
         """
         Quadratic probing is an open addressing scheme used for resolving
         collisions in hash table.

pyproject.toml

@@ -76,11 +76,8 @@ max-complexity = 17  # default: 10
 
 [tool.ruff.lint.per-file-ignores]
 "arithmetic_analysis/newton_raphson.py" = ["PGH001"]
-"audio_filters/show_response.py" = ["ARG002"]
 "data_structures/binary_tree/binary_search_tree_recursive.py" = ["BLE001"]
 "data_structures/binary_tree/treap.py" = ["SIM114"]
-"data_structures/hashing/hash_table.py" = ["ARG002"]
-"data_structures/hashing/quadratic_probing.py" = ["ARG002"]
 "data_structures/hashing/tests/test_hash_map.py" = ["BLE001"]
 "data_structures/heap/max_heap.py" = ["SIM114"]
 "graphs/minimum_spanning_tree_prims.py" = ["SIM114"]

sorts/odd_even_transposition_parallel.py

@@ -11,11 +11,11 @@
 synchronization could be used.
 """
 
-from multiprocessing import Lock, Pipe, Process
+import multiprocessing as mp
 
 # lock used to ensure that two processes do not access a pipe at the same time
 # NOTE This breaks testing on build runner. May work better locally
-# process_lock = Lock()
+# process_lock = mp.Lock()
 
 """
 The function run by the processes that sorts the list
@@ -29,36 +29,41 @@
 """
 
 
-def oe_process(position, value, l_send, r_send, lr_cv, rr_cv, result_pipe):
-    process_lock = Lock()
+def oe_process(
+    position,
+    value,
+    l_send,
+    r_send,
+    lr_cv,
+    rr_cv,
+    result_pipe,
+    multiprocessing_context,
+):
+    process_lock = multiprocessing_context.Lock()
 
     # we perform n swaps since after n swaps we know we are sorted
     # we *could* stop early if we are sorted already, but it takes as long to
     # find out we are sorted as it does to sort the list with this algorithm
     for i in range(10):
         if (i + position) % 2 == 0 and r_send is not None:
             # send your value to your right neighbor
-            process_lock.acquire()
-            r_send[1].send(value)
-            process_lock.release()
+            with process_lock:
+                r_send[1].send(value)
 
             # receive your right neighbor's value
-            process_lock.acquire()
-            temp = rr_cv[0].recv()
-            process_lock.release()
+            with process_lock:
+                temp = rr_cv[0].recv()
 
             # take the lower value since you are on the left
             value = min(value, temp)
         elif (i + position) % 2 != 0 and l_send is not None:
             # send your value to your left neighbor
-            process_lock.acquire()
-            l_send[1].send(value)
-            process_lock.release()
+            with process_lock:
+                l_send[1].send(value)
 
             # receive your left neighbor's value
-            process_lock.acquire()
-            temp = lr_cv[0].recv()
-            process_lock.release()
+            with process_lock:
+                temp = lr_cv[0].recv()
 
             # take the higher value since you are on the right
             value = max(value, temp)
@@ -94,39 +99,60 @@ def odd_even_transposition(arr):
     >>> odd_even_transposition(unsorted_list) == sorted(unsorted_list + [1])
     False
     """
+    # spawn method is considered safer than fork
+    multiprocessing_context = mp.get_context("spawn")
+
     process_array_ = []
     result_pipe = []
     # initialize the list of pipes where the values will be retrieved
     for _ in arr:
-        result_pipe.append(Pipe())
+        result_pipe.append(multiprocessing_context.Pipe())
     # creates the processes
     # the first and last process only have one neighbor so they are made outside
     # of the loop
-    temp_rs = Pipe()
-    temp_rr = Pipe()
+    temp_rs = multiprocessing_context.Pipe()
+    temp_rr = multiprocessing_context.Pipe()
     process_array_.append(
-        Process(
+        multiprocessing_context.Process(
             target=oe_process,
-            args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]),
+            args=(
+                0,
+                arr[0],
+                None,
+                temp_rs,
+                None,
+                temp_rr,
+                result_pipe[0],
+                multiprocessing_context,
+            ),
         )
     )
     temp_lr = temp_rs
     temp_ls = temp_rr
 
     for i in range(1, len(arr) - 1):
-        temp_rs = Pipe()
-        temp_rr = Pipe()
+        temp_rs = multiprocessing_context.Pipe()
+        temp_rr = multiprocessing_context.Pipe()
         process_array_.append(
-            Process(
+            multiprocessing_context.Process(
                 target=oe_process,
-                args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i]),
+                args=(
+                    i,
+                    arr[i],
+                    temp_ls,
+                    temp_rs,
+                    temp_lr,
+                    temp_rr,
+                    result_pipe[i],
+                    multiprocessing_context,
+                ),
             )
         )
         temp_lr = temp_rs
         temp_ls = temp_rr
 
     process_array_.append(
-        Process(
+        multiprocessing_context.Process(
             target=oe_process,
             args=(
                 len(arr) - 1,
@@ -136,6 +162,7 @@ def odd_even_transposition(arr):
                 temp_lr,
                 None,
                 result_pipe[len(arr) - 1],
+                multiprocessing_context,
             ),
         )
     )