chore: Refactor Stack class and add new features

Author: ofou

data_structures/stack/stack.py

@@ -1,27 +1,50 @@
 class Stack:
-    """
-    Simple stack implementation using a list
-    """
 
-    def __init__(self) -> None:
-        self.items = []
+    def __init__(self, max_size=None):
+        self._items = []
+        self._max_size = max_size
 
-    def is_empty(self) -> bool:
-        """check if the stack is empty"""
-        return self.items == []
+    def push(self, item):
+        if self._max_size is not None and len(self._items) >= self._max_size:
+            raise OverflowError("Stack has reached its maximum size")
+        self._items.append(item)
 
-    def push(self, item: any) -> None:
-        """push an item to the top of the stack"""
-        self.items.append(item)
+    def pop(self):
+        if self.is_empty():
+            raise IndexError("Stack is empty")
+        return self._items.pop()
 
-    def pop(self) -> any:
-        """pop the top item of the stack"""
-        return self.items.pop()
+    def peek(self):
+        if self.is_empty():
+            raise IndexError("Stack is empty")
+        return self._items[-1]
 
-    def peek(self) -> any:
-        """peek at the top item of the stack"""
-        return self.items[len(self.items)-1]
+    def is_empty(self):
+        return not bool(self._items)
 
-    def size(self) -> int:
-        """return the size of the stack"""
-        return len(self.items)
+    def size(self):
+        return len(self._items)
+
+    def clear(self):
+        self._items.clear()
+
+    def copy(self):
+        new_stack = Stack(max_size=self._max_size)
+        new_stack._items = self._items.copy()
+        return new_stack
+
+    def __eq__(self, other):
+        if not isinstance(other, Stack):
+            return NotImplemented
+        return self._items == other._items and self._max_size == other._max_size
+
+    def __iter__(self):
+        return reversed(self._items)
+
+    def __repr__(self):
+        return (
+            f"{self.__class__.__name__}(size={self.size()}, max_size={self._max_size})"
+        )
+
+    def __bool__(self):
+        return bool(self._items)

data_structures/stack/test_stack.py

@@ -0,0 +1,123 @@
+import unittest
+from .stack import Stack
+import sys
+import time
+
+
+class TestStack(unittest.TestCase):
+    def setUp(self):
+        self.stack = Stack()
+
+    def test_push_pop_large_number_of_items(self):
+        """Test pushing and popping a large number of items."""
+        num_items = 1000000
+        for i in range(num_items):
+            self.stack.push(i)
+        self.assertEqual(self.stack.size(), num_items)
+        for i in reversed(range(num_items)):
+            self.assertEqual(self.stack.pop(), i)
+        self.assertTrue(self.stack.is_empty())
+
+    def test_push_pop_performance(self):
+        """Test the performance of push and pop operations."""
+        num_operations = 100000
+        start_time = time.time()
+        for i in range(num_operations):
+            self.stack.push(i)
+        for _ in range(num_operations):
+            self.stack.pop()
+        end_time = time.time()
+        self.assertLess(
+            end_time - start_time, 1.0
+        )  # Assert that 100,000 push/pop operations take less than 1 second
+
+    def test_memory_usage(self):
+        """Test that the stack doesn't use excessive memory."""
+        initial_memory = sys.getsizeof(self.stack)
+        for i in range(1000):
+            self.stack.push(i)
+        final_memory = sys.getsizeof(self.stack)
+        self.assertLess(
+            final_memory - initial_memory, 10000
+        )  # Assert that 1000 pushes use less than 10KB additional memory
+
+    def test_push_different_types(self):
+        """Test pushing items of different types onto the stack."""
+        items = [1, "string", [1, 2, 3], {"key": "value"}, (1, 2), set([1, 2, 3])]
+        for item in items:
+            self.stack.push(item)
+        for item in reversed(items):
+            self.assertEqual(self.stack.pop(), item)
+
+    def test_clear_stack(self):
+        """Test clearing the stack."""
+        for i in range(10):
+            self.stack.push(i)
+        self.stack.clear()
+        self.assertTrue(self.stack.is_empty())
+        self.assertEqual(self.stack.size(), 0)
+
+    def test_push_pop_alternating(self):
+        """Test alternating push and pop operations."""
+        for i in range(100):
+            self.stack.push(i)
+            if i % 2 == 0:
+                self.assertEqual(self.stack.pop(), i)
+        self.assertEqual(self.stack.size(), 50)
+
+    def test_stack_with_none_values(self):
+        """Test stack operations with None values."""
+        self.stack.push(None)
+        self.assertEqual(self.stack.size(), 1)
+        self.assertIsNone(self.stack.peek())
+        self.assertIsNone(self.stack.pop())
+
+    def test_stack_representation(self):
+        """Test the string representation of the stack."""
+        for i in range(5):
+            self.stack.push(i)
+        self.assertIn("Stack", str(self.stack))
+        self.assertIn("5", str(self.stack))  # Size should be mentioned
+
+    def test_stack_copy(self):
+        """Test creating a copy of the stack."""
+        for i in range(5):
+            self.stack.push(i)
+        stack_copy = self.stack.copy()
+        self.assertEqual(self.stack.size(), stack_copy.size())
+        while not self.stack.is_empty():
+            self.assertEqual(self.stack.pop(), stack_copy.pop())
+
+    def test_stack_comparison(self):
+        """Test comparing two stacks."""
+        stack1 = Stack()
+        stack2 = Stack()
+        for i in range(5):
+            stack1.push(i)
+            stack2.push(i)
+        self.assertEqual(stack1, stack2)
+        stack1.push(5)
+        self.assertNotEqual(stack1, stack2)
+
+    def test_stack_iterable(self):
+        """Test if the stack is iterable."""
+        items = list(range(5))
+        for item in items:
+            self.stack.push(item)
+        self.assertEqual(list(self.stack), list(reversed(items)))
+
+    def test_stack_max_size(self):
+        """Test stack with a maximum size limit."""
+        max_size = 5
+        limited_stack = Stack(max_size=max_size)
+        for i in range(10):
+            if i < max_size:
+                limited_stack.push(i)
+            else:
+                with self.assertRaises(OverflowError):
+                    limited_stack.push(i)
+        self.assertEqual(limited_stack.size(), max_size)
+
+
+if __name__ == "__main__":
+    unittest.main()