IN PYTHON $7\mathrm{.}9$ LAB: Grocery list editor with undo stack

In this lab a grocery list editor with undo functionality is implemented.

Step $1$: Inspect the UndoCommand abstract base class

The read$-$only UndoCommand.py file has a declaration for the UndoCommand abstract base class. Access UndoCommand.py by clicking on the orange arrow next to main.py at the top of the coding window. The UndoCommand class represents a command object: an object that stores all needed information to execute an action at a later point in time. For this lab, a command object stores information to undo a grocery list change made by the user.

Step $2$: Inspect the incomplete GroceryList class

The GroceryList class is declared in GroceryList.py$.$ Two attributes are declared:

A list of strings for list items

A stack of UndoCommand references for undo commands

A simple list implementation of stack ADT is provided in Stack.py$.$

Note that the add$\_$with$\_$undo$()$ method is already implemented. The method adds a new item to the list and pushes a new RemoveLastCommand object onto the undo stack.

Step $3$: Implement RemoveLastCommand's execute$()$ method

The RemoveLastCommand class inherits from UndoCommand and is declared in RemoveLastCommand.py$.$ When a RemoveLastCommand object is executed, the string list's last element is removed. So when the user appends a new item to the grocery list, a RemoveLastCommand is pushed onto the stack of undo commands. Popping and executing the RemoveLastCommand then removes the item most recently added by the user.

RemoveLastCommand's source$\_$list attribute and constructor are already declared:

source$\_$list is a reference to a GroceryList object's list of strings.

The constructor takes a reference to a list of strings as a parameter, and assigns source$\_$list with the reference.

Implement RemoveLastCommand's execute$()$ method to remove source$\_$list's last element.

Step $4$: Implement GroceryList's execute$\_$undo$()$ method

Implement GroceryList's execute$\_$undo$()$ method to do the following:

Pop an UndoCommand off the undo stack

Execute the popped undo command

File main.py has code that reads in a list of commands, one per line, that allow for basic testing of basic operations. So after implementing execute$\_$undo$(),$ run your program with the following input:

add bananas

add grapes

add strawberries

print

undo

print

undo

print

quit

Verify that the corresponding output is:

$0.$ bananas

$1.$ grapes

$2.$ strawberries

$0.$ bananas

$1.$ grapes

$0.$ bananas

The program's output does not affect grading, so additional test cases can be added, if desired.

Submitting code written so far to obtain partial credit is recommended before proceeding to the next step.

Step $5$: Implement the SwapCommand class and GroceryList's swap$\_$with$\_$undo$()$ method

Implement the SwapCommand class in SwapCommand.py$.$ The class itself is declared, but no attributes yet exist. Add necessary attributes and methods so that the command can undo swapping two items in the grocery list.

Implement GroceryList's swap$\_$with$\_$undo$()$ method. The method swaps list items at the specified indices, then pushes a SwapCommand, to undo that swap, onto the undo stack.

Step $6$: Implement the InsertAtCommand class and GroceryList's remove$\_$at$\_$with$\_$undo$()$ method

Implement the InsertAtCommand class in InsertAtCommand.py$.$ Add necessary fields and methods so that the command can undo removing a grocery list item at an arbitrary index.

Implement GroceryList's remove$\_$at$\_$with$\_$undo$()$ method. The method removes the list item at the specified index, then pushes an InsertAtCommand, to undo that removal, onto the undo stack.

Main.py

import sys

from GroceryList import GroceryList

def main$()$:

grocery$\_$list $=$ GroceryList$()$

quit $=$ False

while not quit:

command $=$ input$()$

# Process user input

if command $==$ "print":

grocery$\_$list.print$\_$list$($sys$.$stdout$)$

elif $0==$ command.find$("$add $")$:

grocery$\_$list.add$\_$with$\_$undo$($command$[4$:$])$

elif $0==$ command.find$("$removeat $")$:

grocery$\_$list.remove$\_$at$\_$with$\_$undo$($int$($command$[9$:$]))$

elif $0==$ command.find$("$swap $")$:

index$1,$ index$2=$ parse$\_$indices$($command$[5$:$])$

if index$2<0$:

print$(\text{'}"$swap$"$ command requires two indices, separated by a space. ex$\_$: swap $25\text{'})$

else:

grocery$\_$list.swap$\_$with$\_$undo$($index$1,$ index$2)$

elif command $==$ "undo":

if $0==$ grocery$\_$list.get$\_$undo$\_$stack$\_$size$()$:

print$("$Cannot execute undo because undo stack is empty"$)$

else:

grocery$\_$list.execute$\_$undo$()$

elif command $==$ "quit":

quit $=$ True

else:

print$("$unknown command:", command$)$

def parse$\_$indices$($str$)$:

indices $=[$int$($n$)$ for n in str$.$split$()]$

if len$($indices$)!=2$:

return $-1,-1$

else:

return indices

if $\_\_$name$\_\_==\text{'}\_\_$main$\_\_\text{'}$:

main$()$

UndoCommand.py

from abc import AB