Updation DNF sorting algo to make hacktoberfest contribution

sorts/dutch_national_flag_sort.py

@@ -1,40 +1,36 @@
 """
 A pure implementation of Dutch national flag (DNF) sort algorithm in Python.
-Dutch National Flag algorithm is an algorithm originally designed by Edsger Dijkstra.
-It is the most optimal sort for 3 unique values (eg. 0, 1, 2) in a sequence.  DNF can
-sort a sequence of n size with [0 <= a[i] <= 2] at guaranteed O(n) complexity in a
-single pass.
+Originally designed by Edsger Dijkstra, it optimally sorts a sequence of three unique values
+(e.g., 0, 1, 2) with [0 <= a[i] <= 2] in O(n) complexity in a single pass.
 
-The flag of the Netherlands consists of three colors: white, red, and blue.
-The task is to randomly arrange balls of white, red, and blue in such a way that balls
-of the same color are placed together.  DNF sorts a sequence of 0, 1, and 2's in linear
-time that does not consume any extra space.  This algorithm can be implemented only on
-a sequence that contains three unique elements.
+The task is to randomly arrange balls of white, red, and blue so that balls of the same color
+are grouped together. DNF sorts a sequence of 0, 1, and 2's in linear time without consuming
+extra space. The algorithm works only on sequences with three unique elements.
 
 1) Time complexity is O(n).
 2) Space complexity is O(1).
 
-More info on: https://en.wikipedia.org/wiki/Dutch_national_flag_problem
+For more info: https://en.wikipedia.org/wiki/Dutch_national_flag_problem
 
-For doctests run following command:
+For doctests run:
 python3 -m doctest -v dutch_national_flag_sort.py
 
 For manual testing run:
 python dnf_sort.py
 """
 
-# Python program to sort a sequence containing only 0, 1 and 2 in a single pass.
-red = 0  # The first color of the flag.
-white = 1  # The second color of the flag.
-blue = 2  # The third color of the flag.
-colors = (red, white, blue)
+# Python program to sort a sequence containing only 0, 1, and 2 in a single pass.
+RED = 0  # The first color (red).
+WHITE = 1  # The second color (white).
+BLUE = 2  # The third color (blue).
+ALLOWED_VALUES = (RED, WHITE, BLUE)
 
 
 def dutch_national_flag_sort(sequence: list) -> list:
     """
-    A pure Python implementation of Dutch National Flag sort algorithm.
-    :param data: 3 unique integer values (e.g., 0, 1, 2) in an sequence
-    :return: The same collection in ascending order
+    A Python implementation of the Dutch National Flag sorting algorithm.
+    :param sequence: A list of integers containing only 0, 1, and 2
+    :return: Sorted sequence with the values 0, 1, 2 in ascending order
 
     >>> dutch_national_flag_sort([])
     []
@@ -47,44 +43,42 @@
     >>> dutch_national_flag_sort("abacab")
     Traceback (most recent call last):
       ...
-    ValueError: The elements inside the sequence must contains only (0, 1, 2) values
-    >>> dutch_national_flag_sort("Abacab")
-    Traceback (most recent call last):
-      ...
-    ValueError: The elements inside the sequence must contains only (0, 1, 2) values
+    ValueError: The elements inside the sequence must contain only (0, 1, 2) values
     >>> dutch_national_flag_sort([3, 2, 3, 1, 3, 0, 3])
     Traceback (most recent call last):
       ...
-    ValueError: The elements inside the sequence must contains only (0, 1, 2) values
+    ValueError: The elements inside the sequence must contain only (0, 1, 2) values
     >>> dutch_national_flag_sort([-1, 2, -1, 1, -1, 0, -1])
     Traceback (most recent call last):
       ...
-    ValueError: The elements inside the sequence must contains only (0, 1, 2) values
+    ValueError: The elements inside the sequence must contain only (0, 1, 2) values
     >>> dutch_national_flag_sort([1.1, 2, 1.1, 1, 1.1, 0, 1.1])
     Traceback (most recent call last):
       ...
-    ValueError: The elements inside the sequence must contains only (0, 1, 2) values
+    ValueError: The elements inside the sequence must contain only (0, 1, 2) values
     """
     if not sequence:
         return []
     if len(sequence) == 1:
-        return list(sequence)
-    low = 0
-    high = len(sequence) - 1
-    mid = 0
+        return sequence
+
+    low, mid, high = 0, 0, len(sequence) - 1
+
     while mid <= high:
-        if sequence[mid] == colors[0]:
+        if sequence[mid] == RED:
             sequence[low], sequence[mid] = sequence[mid], sequence[low]
             low += 1
             mid += 1
-        elif sequence[mid] == colors[1]:
+        elif sequence[mid] == WHITE:
             mid += 1
-        elif sequence[mid] == colors[2]:
+        elif sequence[mid] == BLUE:
             sequence[mid], sequence[high] = sequence[high], sequence[mid]
             high -= 1
         else:
-            msg = f"The elements inside the sequence must contains only {colors} values"
-            raise ValueError(msg)
+            raise ValueError(
+                f"The elements inside the sequence must contain only {ALLOWED_VALUES} values"
+            )
+
     return sequence
 
 
@@ -93,6 +87,13 @@
 
     doctest.testmod()
 
-    user_input = input("Enter numbers separated by commas:\n").strip()
-    unsorted = [int(item.strip()) for item in user_input.split(",")]
-    print(f"{dutch_national_flag_sort(unsorted)}")
+    # User input for manual testing
+    user_input = input("Enter numbers separated by commas (0, 1, 2 only):\n").strip()
+    try:
+        unsorted = [int(item.strip()) for item in user_input.split(",")]
+        if all(x in ALLOWED_VALUES for x in unsorted):
+            print(f"Sorted sequence: {dutch_national_flag_sort(unsorted)}")
+        else:
+            print("Error: Input must only contain the values 0, 1, and 2.")
+    except ValueError:
+        print("Error: Invalid input. Please enter integers only.")