Warehouse-inventory-with-Dictionary.py

"""
This program is an Inventory Management System for a warehouse.
It uses a Python dictionary to keep track of items.
You can add new items, sell, modify, search and check an item's details from the Inventory system.
"""
#importing pretty table for showing data in table format
from prettytable import PrettyTable

def print_lines():
    dashed_line = "-" * 110

    #printing the header with print_lines
    print("\n")
    print(dashed_line)


def add_item_to_inventory(inventory_stock):
    """
    Function 2 : add_item_to_inventory
    Purpose: To add a brand new item to the warehouse inventory, or update an item from existing stock. If the iteam_name
    """
    print("\n\t\t\t Add inventory item.....")
    #promting for user's input to add the item
    item_name = input("Enter item name: ").strip()
    item_id = input("Enter item ID: ").strip()
    item_location = input("Enter location of item in shelf: ").strip()

    # Checking the validity for quantity.
    while True:
        try:
            quantity = int(input("Enter quantity of item: "))
            if quantity <= 0:
                print("Quantity must be a whole number (more than 0). Please try again.")
            else:
                break  # If valid, exit the loop.
        except ValueError:  # If the input wasn't a number.
            print("That's not a valid number for quantity. Please enter a whole number.")

    # Loop to make sure the user enters a valid number for price.
    while True:
        try:
            price = float(input("Enter price per unit of item: "))  # Try to convert input to a decimal number.
            if price <= 0:  # Price must be positive.
                print("Price must be a positive number (more than $0). Please try again.")
            else:
                break  # If valid, exit the loop.
        except ValueError:  # If the input wasn't a number.
            print("That's not a valid number for price. Please enter a number.")

    # Condition 1: Check if the inventory is empty
    if not inventory_stock:
        # If it's empty, add the item directly.
        inventory_stock[item_id] = {
            'name': item_name,
            'item_ID': item_id,
            'item_location': item_location,
            'quantity': quantity,
            'price': price
        }
        print("No items in inventory...Adding new item to inventory...")

    else:
        # Condition 2 & 3: Inventory has items, so check if this item already exists.
        # Check if the 'item_id' already exists in inventory dictionary.
        if item_id in inventory_stock:
            # If the item ID exists, check if the item name also matches exactly.
            # We convert both names to lowercase for a case-insensitive comparison (e.g., "apple" is same as "Apple").
            if inventory_stock[item_id]['name'].lower() == item_name.lower():
                # Condition 3: Item (ID and Name) already exists. update it.
                print(f"Item '{item_name}' (ID: {item_id}) is already in stock.")
                print("Increasing item quantity, updating location, and price.")
                inventory_stock[item_id]['quantity'] += quantity  # Add the new quantity to the existing.
                inventory_stock[item_id]['item_location'] = item_location  # Update the location.
                inventory_stock[item_id]['price'] = price  # Update the price.
            else:
                # Condition 2: Item ID exists, but the name is different. This means it's a new item.
                # Example: ID "P123" exists for "Printers", but user tries to add "Paper" with ID "P123".
                # We treat this as a new item because the name doesn't match the existing ID.
                print(f"Item ID '{item_id}' is being used for a different item.")
                print("This is a new item with a new Item ID, so we're adding it to stock.")
                inventory_stock[item_id] = {
                    'name': item_name,
                    'item_ID': item_id,
                    'item_location': item_location,
                    'quantity': quantity,
                    'price': price
                }
        else:
            # Condition 2: Item ID does not exist at all. This is definitely a new item.
            print(f"Item ID '{item_id}' is for a new item and is currently NOT in stock; So, include this item in stock...")
            inventory_stock[item_id] = {
                'name': item_name,
                'item_ID': item_id,
                'item_location': item_location,
                'quantity': quantity,
                'price': price
            }
    return inventory_stock  # Send back the updated inventory.


def perform_inventory_sales(inventory_stock):
    """
    Function 3 : perform_inventory_sales
    Purpose: To handle selling items from our inventory. When an item is sold, its quantity in stock goes down.
    """
    print("\n--- Inventory Sales Application ---")
    # Condition 1: Check if there are any items in the inventory first.
    if not inventory_stock:
        print("Sorry, there are no items in the stock right now to sell.")
        return inventory_stock  # Return without changes if inventory is empty.

    # Ask the user for the name of the item they want to buy.
    item_name_to_purchase = input("Enter the name of the item you want to buy: ").strip()

    found_item_id = None  # A variable to store the ID if we find the item.
    for item_id, item_details in inventory_stock.items():
        if item_details['name'].lower() == item_name_to_purchase.lower():
            found_item_id = item_id
            break

    # Condition 4: If the item was not found after checking all items.
    if found_item_id is None:
        print(f"Sorry, the item '{item_name_to_purchase}' is NOT in stock at all.")
        return inventory_stock

    # If found the item, proceed with checking quantity.
    print(f"Good news! Item '{item_name_to_purchase}' is in stock.")
    item_details = inventory_stock[found_item_id]  # Get all details for the found item.

    # Loop to ensure a valid quantity to purchase is entered.
    while True:
        try:
            quantity_to_purchase = int(input(f"Enter quantity of '{item_name_to_purchase}' to purchase: "))
            if quantity_to_purchase <= 0:
                print("Quantity to purchase must be a positive number. Please try again.")
            else:
                break
        except ValueError:
            print("Invalid input for quantity. Please enter a whole number.")

    # Condition 2 & 3: Check if we have enough items in stock.
    if item_details['quantity'] >= quantity_to_purchase:
        # Condition 2: Purchase is successful!
        print("We have enough stock. Preparing your invoice...")
        item_details['quantity'] -= quantity_to_purchase

        print_lines()
        print("\n--- Your Sales Invoice ---")

       #show the inventory details
        invoice_table = PrettyTable()
        invoice_table.field_names = ["Item Name", "Item ID", "Quantity Purchased", "Unit Price", "Subtotal"]

        total_item_price = quantity_to_purchase * item_details['price']  # Calculate price before tax.
        tax_rate = 0.13  # Example: 13% tax rate.
        tax_amount = total_item_price * tax_rate  # Calculate the tax amount.
        total_amount_to_pay = total_item_price + tax_amount  # Calculate the final total.

        # Add the row of data to the table.
        invoice_table.add_row([
            item_details['name'],
            item_details['item_ID'],
            quantity_to_purchase,
            f"${item_details['price']:.2f}",  # Format price to 2 decimal places.
            f"${total_item_price:.2f}"  # Format subtotal to 2 decimal places.
        ])

        print(invoice_table)  # Print the formatted table.

        # Print tax and final total.
        print(f"{'Tax Amount:':<50} ${tax_amount:.2f}")  # Format for nice alignment.
        print(f"{'Total Amount to Pay:':<50} ${total_amount_to_pay:.2f}")  # Format for nice alignment.
        print(f"\nThank you for buying {quantity_to_purchase} '{item_details['name']}'.")

    else:
        # Condition 3: Not enough items in stock.
        print(f'\nSorry! We do not have enough {item_name_to_purchase} in stock right now. Please try to buy later....')
        print(f"You asked for {quantity_to_purchase}, but we only have {item_details['quantity']} left.")

    return inventory_stock  # Send back the updated inventory.


def display_all_inventory(inventory_stock):
    """
    Function 4 : display_all_inventory
    Purpose: To show a list of all items currently stored in our warehouse inventory.
             It presents the information in a neat table.
    """
    print("\n--- Displaying All Inventory Items ---")
    # Condition 1: Check if the inventory is empty.
    if not inventory_stock:
        print("There are no items in the inventory to display yet.")
    else:
        # Condition 2: Inventory has items, so display them.
        print_lines()  # Display developer info at the top of the list.
        print("\n--- List of All Inventory Items ---")

        # Create a new PrettyTable instance.
        inventory_table = PrettyTable()
        # Set the column names (headers).
        inventory_table.field_names = ["Item Name", "Item ID", "Location in Pods", "Price/Unit", "Quantity in Stock"]

        # Loop through each item in the inventory_stock dictionary.
        for item_id, item_details in inventory_stock.items():
            # Add each item's details as a row to our table.
            inventory_table.add_row([
                item_details['name'],
                item_details['item_ID'],
                item_details['item_location'],
                f"${item_details['price']:.2f}",  # Format price to 2 decimal places.
                item_details['quantity']
            ])

        print(inventory_table)  # Print the formatted table.


def check_inventory_status(inventory_stock):
    """
    Function 5 : check_inventory_status
    Purpose: To check if a specific item exists in our inventory and show its details
             if it does.
    """
    print("\n--- Check Item Status in Inventory ---")
    # Condition 1: Check if the inventory is empty.
    if not inventory_stock:
        print("There are no items in the stock right now to check.")
        return [False, None]  # Return False because no item was found.

    # Ask the user for the name of the item they want to check.
    item_name_to_check = input("Enter the name of the item you want to check: ").strip()

    found_item = None  # A variable to hold the item's details if found.
    # Loop through each item in the inventory to find a match by name (case-insensitive).
    for item_id, item_details in inventory_stock.items():
        if item_details['name'].lower() == item_name_to_check.lower():
            found_item = item_details  # We found the item! Store its details.
            break  # Stop searching.

    # Condition 2: If the item was found.
    if found_item:
        print("\nItem found! Here are the details from our inventory:")
        print_lines()  # Display developer info.

        # Create a new PrettyTable instance.
        status_table = PrettyTable()
        # Set the column names (headers).
        status_table.field_names = ["Item Name", "Item ID", "Location in Pods", "Price/Unit", "Quantity in Stock"]

        # Add the row of data for the found item.
        status_table.add_row([
            found_item['name'],
            found_item['item_ID'],
            found_item['item_location'],
            f"${found_item['price']:.2f}",  # Format price.
            found_item['quantity']
        ])

        print(status_table)  # Print the formatted table.
        # Also print the raw dictionary data for the item, as specified in the lab.
        print("\nRaw item data:")
        print(found_item)
        return [True, found_item]  # Return True and the item's details.
    else:
        # Condition 3: If the item was not found.
        print(f"Sorry, the item '{item_name_to_check}' is NOT in stock.")
        return [False, None]  # Return False because no item was found.


def main_menu():
    """
    Function 6 : print main_menu
    Purpose: To simply show the user the main options they can choose from in the program.
    This helps keep the main part of the program tidy.
    """
    menu = """
    Please choose an option:
    a) Enter 'a' to Add to new inventory
    b) Enter 'b' to Perform inventory sales
    c) Enter 'c' to Display all inventory
    d) Enter 'd' to Check inventory item in stock
    e) Enter 'e' to End application.
    """
    print(menu)  # Print main_menu


def main():
    """
    Function 7: main function
    Purpose: This is the starting point of our entire Inventory Management System.
             It sets up the main inventory, shows the menu repeatedly, and calls
             the correct function based on what the user chooses.
    """
    # Start with an empty dictionary.
    inventory_stock = {}

    # This loop keeps the program running until the user chooses to exit.
    while True:
        main_menu()
        # Get the user's choice, convert it to lowercase, and remove spaces.
        choice = input("Enter your choice here: ").lower().strip()

        # Check which option the user picked and call the right function.
        if choice == 'a':
            inventory_stock = add_item_to_inventory(inventory_stock)  # Call add function.
        elif choice == 'b':
            inventory_stock = perform_inventory_sales(inventory_stock)  # Call sales function.
        elif choice == 'c':
            display_all_inventory(inventory_stock)  # Call display function.
        elif choice == 'd':
            check_inventory_status(inventory_stock)  # Call check status function.
        elif choice == 'e':
            print("Application ends now......")
            break  # Exit the 'while True' loop, which stops the program.
        else:
            # If the user enters something invalid.
            print("Enter a valid choice 'a', 'b', 'c', 'd', or 'e'....")


# This special line makes sure that the 'main()' function is called only when
# the script is run directly (not when imported as a module into another script).
if __name__ == "__main__":
    main()