fix: I revised previous changes to meet contributing.md guidelines

I reviewed and revised the changes from the previous commits and made sure that they follow the CONTRIBUTING.md guidelines. The revisions I made include:

1.Correcting and expanding doctests.
2. Adding missing type hints and docstrings.
3. Handling invalid input with ValueError.
4. Improving variable naming and code readability.
5. Cleaning up formatting and spacing.
6. Maintaining the original patience sort implementation and the  added mixed integer, float, and string functionality.

Author: Obed-727

sorts/patience_sort.py

@@ -1,22 +1,27 @@
 from __future__ import annotations
+
 from bisect import bisect_left
 from functools import total_ordering
 from heapq import merge
 
 """
-A pure Python implementation of the patience sort algorithm
+A pure Python implementation of the patience sort algorithm.
 
 For more information: https://en.wikipedia.org/wiki/Patience_sorting
 
-This algorithm is based on the card game patience
+This algorithm is based on the card game patience.
+
+This version can sort integers, floats, and strings using
+mixed_patience_sort().
 
-For doctests run following command:
+For doctests run the following command:
 python3 -m doctest -v patience_sort.py
 
 For manual testing run:
 python3 patience_sort.py
 """
 
+
 @total_ordering
 class Stack(list):
     def __lt__(self, other):
@@ -25,13 +30,11 @@ def __lt__(self, other):
     def __eq__(self, other):
         return self[-1] == other[-1]
 
-def patience_sort(collection: list) -> list:
-    """A pure implementation of patience sort algorithm in Python
-
-    :param collection: some mutable ordered collection with heterogeneous
-    comparable items inside
-    :return: the same collection ordered by ascending
 
+def patience_sort(collection: list) -> list:
+    """Sort a collection using the patience sort algorithm.
+    :param collection: A mutable ordered collection containing comparable items.
+    :return: The same collection ordered in ascending order.
     Examples:
     >>> patience_sort([1, 9, 5, 21, 17, 6])
     [1, 5, 6, 9, 17, 21]
@@ -43,47 +46,87 @@ def patience_sort(collection: list) -> list:
     [-48, -17, -3]
     """
     stacks: list[Stack] = []
-    # sort into stacks
+
+    # Place each element on the first suitable stack, following
+    # the rules of the patience sort algorithm.
     for element in collection:
-        new_stacks = Stack([element])
-        i = bisect_left(stacks, new_stacks)
-        if i != len(stacks):
-            stacks[i].append(element)
+        new_stack:  list = Stack([element])
+        stack_index:  list = bisect_left(stacks, new_stack)
+
+        if stack_index != len(stacks):
+            stacks[stack_index].append(element)
         else:
-            stacks.append(new_stacks)
-            
-    # use a heap-based merge to merge stack efficiently
+            stacks.append(new_stack)
+
+    # Merge the stacks to produce the final sorted collection.
     collection[:] = merge(*(reversed(stack) for stack in stacks))
     return collection
-    
+
+
 def mixed_patience_sort(collection: list) -> list:
-    """
-    With this block of code, numbers are sorted according to their
-    magnitude, the strings are arranged in alphbetical order. And the numbers
-    are arranged before the alphabets.
-    """
+    """Sort integers, floats, and strings using patience sort.
+
+    Numbers are sorted by magnitude and placed before strings.
+    Strings are sorted alphabetically according to Python's
+    standard string ordering.
 
-    number_items = []
-    string_items = []
+    :param collection: A mutable collection containing integers,
+        floats, and strings.
+    :return: The same collection with numbers followed by strings.
+
+    Examples:
+    >>> mixed_patience_sort([1, 9, 3.64, "Apple", "letter", 23.65])
+    [1, 3.64, 9, 23.65, 'Apple', 'letter']
+
+    >>> mixed_patience_sort(["banana", "Apple", "letter"])
+    ['Apple', 'banana', 'letter']
+
+    >>> mixed_patience_sort([3.5, 1, 8.2])
+    [1, 3.5, 8.2]
+
+    >>> mixed_patience_sort([])
+    []
+
+    >>> mixed_patience_sort([1, {"name": "Obed"}])
+    Traceback (most recent call last):
+    ValueError: Only integers, floats, and strings are allowed.
+    """
+    number_items: list[int | float] = []
+    string_items: list[str] = []
 
     for element in collection:
         if isinstance(element, (int, float)):
             number_items.append(element)
         elif isinstance(element, str):
             string_items.append(element)
         else:
-            print("Only integers, floats, and strings are allowed.")
+            raise ValueError("Only integers, floats, and strings are allowed.")
 
-    # The user input is sort by using the patience sort algorithm
-    sorted_numbers = patience_sort(number_items)
-    sorted_strings = patience_sort(string_items)
+    sorted_numbers:  int = patience_sort(number_items)
+    sorted_strings:  str = patience_sort(string_items)
 
-    # use a heap-based merge to merge stack efficiently
     collection[:] = sorted_numbers + sorted_strings
     return collection
 
-def convert_item(item):
+
+def convert_item(item: str) -> int | float | str:
+    """Convert a string into an integer, float, or string.
+
+    :param item: The input string to convert.
+    :return: An integer, float, or the original string.
+
+    Examples:
+    >>> convert_item("25")
+    25
+
+    >>> convert_item("3.14")
+    3.14
+
+    >>> convert_item("Apple")
+    'Apple'
+    """
     item = item.strip()
+
     try:
         return int(item)
     except ValueError:
@@ -92,7 +135,8 @@ def convert_item(item):
         except ValueError:
             return item
 
+
 if __name__ == "__main__":
-    user_input = input("Enter numbers separated by a comma:\n").strip()
-    unsorted = [convert_item(item) for item in user_input.split(",")]
+    user_input:  str| int|float = input("Enter integers, floats, and strings separated by commas:\n").strip()
+    unsorted: str| int|float = [convert_item(item) for item in user_input.split(",")]
     print(mixed_patience_sort(unsorted))