Hjälp! Granskning av projekt - Python

import string

class Salad:                                                                                                                #Klass för en salad.
        
    def __init__(self, saladname, price, ingredients):                                                                      #Konstruktorn.
        self.saladname = saladname
        self.price = price
        self.ingredients = ingredients

    def get_name_of_salad(self):                                                                                            #Tar fram saladens namn.
        return self.saladname

    def get_price_of_salad(self):                                                                                           #Tar fram  saladens pris.
        return self.price

    def specific_ingredients(self):                                                                                         #Delar saladens ingredienser vid (;) och returnerar en lista med ingredienserna.
        specific_ingredients = self.ingredients.split(";")    
        return specific_ingredients

    def list_of_ingredient_to_string(self):                                                                                 #Tar saladens lista med ingredienser och gör om det till en snygg string beroende på hur många ingredienser det är i listan.
        ingredient_str = ""
        specific_ingredients = self.specific_ingredients()
        for ingredient in specific_ingredients:
            if ingredient == specific_ingredients[-1]:
                ingredient_str += ingredient.lower() + "."
            elif ingredient == specific_ingredients[-2]:
                ingredient_str += ingredient.lower() + " and "
            elif ingredient == specific_ingredients[0]:
                ingredient_str += ingredient + ", "
            else:
                ingredient_str += ingredient.lower() + ", "
        return ingredient_str 

    def display_salad(self):                                                                                                #Visar saladens namn, pris och vad den innehåller för ingredienser.                                                                                              
        return self.saladname + " costs " + self.price + " sek and contains:\n" + self.list_of_ingredient_to_string()

    def display_salad_with_most_matches(self):
        return "The salad that matched the most with your picks and also was the cheepest was:\n" + self.saladname + " which costs " + self.price + " sek and contains:\n" + self.list_of_ingredient_to_string()            #Visar namnet på saladen som mathcade bäst och var den billigaste.

    #def __repr__(self):                #Ta bort?
        #return self.ingredients


def read_salads_from_file():                                                                                                #Läser in salladerna från ingredients.txt och skapar ett salladsobjekt för varje rad och lägger varje object i en lista.                    
    salad_objects = []
    with open(r"salads.txt") as file:
        for line in file:
            line = line.strip()
            salads = line.split(",")
            salad_objects.append(Salad(salads[0], salads[1], salads[2]))
        return salad_objects


def read_options_from_file():                                                                                               #Läser in ingredienserna från ingredients.txt och gör det till ett uppslagsverk med ingridiensen och priset.
    ingredients_dict = {}
    with open(r"ingredients.txt") as file:
        for line in file:
            line = line.strip()
            (key, value) = line.split(",")
            ingredients_dict[str(key)] = value
        return ingredients_dict


def print_ingredients(ingredients_dict):                                                                                    #Skriver ut ingredienserna
    for key in ingredients_dict.keys():
        print(key)


def users_ingredients(ingredients_dict):                                                                                    #Frågar användaren vad för ingredienser användaren vill ha i sin sallad.
    users_salad = []
    print("\nPick ingredients that you would like to have in your salad.")    
    while True:    
        users_ingredient = input("\nAdd an ingredient here(type 'Done' when you are done): ")
        users_ingredient = string.capwords(users_ingredient)

        if users_ingredient == "Done":                                                                                      #Returnerar användarens önskade salad när användaren skriver in "Done"
            return users_salad
            break

        elif users_ingredient not in ingredients_dict.keys():                                                               #Om inte användarens input är en ingrediens uppslagsverket, får användaren fortsätta försöka.
            print("We don´t have that ingredient, please try enter a valid ingredient from the list above.")
        
        elif users_ingredient in users_salad:                                                                               #Om användaren matar in en ingrediens fler en en gång, får användaren fortsätta försöka.
            print("\nYou have already picked that ingreident. Try another one.")

        elif users_ingredient in ingredients_dict.keys():                                                                   #Om användaren matar in en ingredient som är i uppslagsverket läggs det till i användarens salad och användaren ser även vilka ingredienser den valt.
            users_salad.append(users_ingredient)
            print("\nYour choosen ingredients:")
            for ingredients in users_salad:
                print(ingredients)


def wanted_salad_if_subset(salad_objects,users_salad):                                                                      #Tar fram de sallader om alla ingredienser finns i en sallad.
    users_set = set(users_salad)
    wanted_salad = []
    salad_sets = []
    for salad_object in salad_objects:                                                                     
        ingredients = Salad.specific_ingredients(salad_object)                  #kolla denna
        ingredients = set(ingredients)
        salad_sets.append(ingredients)
        for salad in salad_sets:
            if users_set.issubset(salad):
                wanted_salad.append(salad_object)
                salad_sets = []
    return wanted_salad


def wanted_salad_if_superset(salad_objects,users_salad):                                                                    #Tar fram sallader om inte alla ingredienser finns i en sallad.
    users_set = set(users_salad)
    wanted_salad_2 = []
    salad_sets = []
    for salad_object in salad_objects:                                                                     
        ingredients = Salad.specific_ingredients(salad_object)                  #kolla denna
        ingredients = set(ingredients)
        salad_sets.append(ingredients)
        for salad in salad_sets:
            if users_set.issuperset(salad) == False:
                wanted_salad_2.append(salad_object)
                salad_sets = []
    return wanted_salad_2


def find_max_sets(sets):                                                                                                    #Tar fram de längsta setet i en lista.  #copy from the net.           
    sets_len = [len(i) for i in sets]
    return max(sets_len)


def compare_salads(wanted_salad,wanted_salad_2,salad_objects,users_salad):                                                  #Jämför användarens sallad med salladsobjekten.
    correct_salads = []
    
    if len(wanted_salad) != 0:
        print("Down below you can see the salad/salads that matched with your ingredient/ingredients:\n")
        for salad in wanted_salad:
            print(Salad.display_salad(salad),"\n")                              #kolla denna
            correct_salads.append(salad)
        return correct_salads, False

    elif len(wanted_salad_2) != 0:                    
        users_set = set(users_salad)
        salad_sets = []
        salad_sets_2 = []
        common_ingredients = []
        slads_with_most_ing = []
        correct_salads = []
        print("Sorry, no one of our salads matched with the ingredient/s you picked.\n")
        for salad_object in salad_objects:
            ingredients = Salad.specific_ingredients(salad_object)      
            ingredients = set(ingredients)
            salad_sets.append(ingredients)               

        for salad in salad_sets:
            common_ingredients.append(users_set.intersection(salad))
            common_ingredients = [x for x in common_ingredients if]

        for salad in common_ingredients:
            if len(salad) == find_max_sets(common_ingredients):
                slads_with_most_ing.append(salad)

        for salad in slads_with_most_ing:
            for salad_set in salad_sets:
                if salad.union(salad_set) in salad_sets:
                    if salad_set not in wanted_salad:
                        wanted_salad.append(salad_set)
                        salad_sets.remove(salad_set)

        for salad_object in salad_objects:
            ingredients = Salad.specific_ingredients(salad_object)      
            ingredients = set(ingredients)
            salad_sets_2.append(ingredients)

            for salad in wanted_salad:
                if salad in salad_sets_2:
                    correct_salads.append(salad_object)
                    salad_sets_2.remove(salad)
        return correct_salads, True


def compare_price(correct_salads,need_price_comparison):                                                              #Om det finns flera sallader med lika många matchningar väljs den biligaste.
    if need_price_comparison == True:
        correct_salad = []
        salad_prices = []
        for salad in correct_salads:
            salad_prices.append(Salad.get_price_of_salad(salad))
        for salad in correct_salads:
            if Salad.get_price_of_salad(salad) == min(salad_prices):
                correct_salad.append(salad)
        for salad in correct_salad:
            print(Salad.display_salad_with_most_matches(salad),"\n")
        return correct_salad


def get_missing_ingredients(users_salad,correct_salad,need_price_comparison):                                          #Om det saknas mest matchade salladen saknar några av användarens ingredienser skrivs de ut.
    missing_ing_text = ""
    users_set = set(users_salad)
    if need_price_comparison == True:
        for salad in correct_salad:
            set_of_correct_salad = set(Salad.specific_ingredients(salad))    
        missing_ingredients = list(users_set.difference(set_of_correct_salad))
        print("The salad is missing following ingredient/s that you picked:")
        for ingredient in missing_ingredients:
            if len(missing_ingredients) >=3:
                if ingredient == missing_ingredients[-2]:
                    missing_ing_text += ingredient.lower() + " and "
                elif ingredient == missing_ingredients[0]:
                    missing_ing_text += ingredient + ", "
                elif ingredient == missing_ingredients[-1]:
                    missing_ing_text += ingredient.lower() + "."
                else:
                    missing_ing_text += ingredient.lower() + ", "
            elif len(missing_ingredients) == 2:
                if ingredient == missing_ingredients[0]:
                    missing_ing_text += ingredient + " and "
                elif ingredient == missing_ingredients[1]:
                    missing_ing_text += ingredient.lower() + "."   
            else:
                missing_ing_text += ingredient + ". "
        print(missing_ing_text)


def pick_salad(correct_salad,correct_salads,need_price_comparison):                                                     #Om det saknas mest matchade salladen saknar några av användarens ingredienser skrivs de ut.
    users_picked_salad = []
    users_ingredient = None

    if need_price_comparison == True:
        for salad in correct_salad:
            users_picked_salad.append(salad)
            print("\nYour salad is",Salad.get_name_of_salad(salad))
        return users_picked_salad

    elif need_price_comparison == False:

        if len(correct_salads) > 1:
            print("Choose one of the salads below:")
            for salad in correct_salads:
                print(Salad.get_name_of_salad(salad))
            while True:
                users_ingredient = input("\nChoose your salad here(name of salad):")
                users_ingredient = string.capwords(users_ingredient)
                for salad in correct_salads:
                    if users_ingredient == str(Salad.get_name_of_salad(salad)):
                        users_picked_salad.append(salad)
                        print("\nYour salad is",Salad.get_name_of_salad(salad))
                        return users_picked_salad
                        break

                if users_ingredient != str(Salad.get_name_of_salad(salad)):
                    print("That is not a salad in the list, please try again.")

        else:
            for salad in correct_salads:
                users_picked_salad.append(salad)
                print("\nYour salad is",Salad.get_name_of_salad(salad))
                return users_picked_salad


def add_options_or_not(users_picked_salad):                                                                                     #Frågar användaren om den vill lägga till någon ingrediens i salladen.
    while True:
        users_choice = input("\nWould you like to add something to your salad? Yes/No: ")
        users_choice = string.capwords(users_choice)
        if users_choice == "No":
            return users_choice
        elif users_choice == "Yes":
            return users_choice
        else:
            print("Please type 'Yes' or 'No'.")


def print_options(ingredients_dict,users_choice):                                                                               #Skriver ut tillval och tillvalets pris. 
    if users_choice == "Yes":
        print("\nDown below you can see all ingredients that you can add to your salad.\n")
        max_key_len = max(map(len, ingredients_dict.keys()))                                                            #copy
        format_string = '{{key:{}}}  {{value}}'.format(max_key_len)
        for key, value in ingredients_dict.items():
            print(format_string.format(key=key, value=value + " sek"))


def get_wanted_options(users_picked_salad,ingredients_dict,users_choice):                                                       #Frågar användaren om den vad den vill lägga till i sin sallad.
    users_added_ingredients = []
    for salad in users_picked_salad:
        ingredients_allready_in_salad = Salad.specific_ingredients(salad)
    if users_choice == "Yes":
        for salad in users_picked_salad:
            print("\nPick ingredients that you would like to add to", Salad.get_name_of_salad(salad)+" from the list above.")
        while True:
            users_ingredient = input("\nAdd an ingredient here(Type 'Done' when you are done): ")
            users_ingredient = string.capwords(users_ingredient)
            if users_ingredient == "Done":
                return users_added_ingredients
                break
            elif users_ingredient in ingredients_allready_in_salad:
                print("That ingredient is already in your salad. Try another one.")
            elif users_ingredient not in ingredients_dict.keys():
                    print("We don´t have that ingredient, please try enter a valid ingredient from the list above. Try another one.")
            elif users_ingredient in users_added_ingredients:
                    print("\nYou have allready added that ingreident. Try another one.")
            elif users_ingredient in ingredients_dict.keys():
                    users_added_ingredients.append(users_ingredient)
                    print("\nYour added ingredients:")
                    for ingredient in users_added_ingredients:
                        print(ingredient)


def add_wanted_options(users_choice,users_added_ingredients,users_picked_salad,ingredients_dict):                                   #Adderar pris och ingredienser och returnera saladen med tilläggen och nytt totalpris.
    price_for_ingredients = []
    added_price = 0
    message = ""
    if users_choice == "Yes":
        for ingredient in users_added_ingredients:
            for name, price in ingredients_dict.items():
                if name == ingredient:
                    price_for_ingredients.append(int(price))
        for price in price_for_ingredients:
            added_price += price
        for salad in users_picked_salad:
            total_cost = int(Salad.get_price_of_salad(salad)) + added_price
        for salad in users_added_ingredients:                                            #eventuellt funktion
            if len(users_added_ingredients) >=3:
                if salad == users_added_ingredients[-2]:
                    message += salad.lower() + " and "
                elif salad == users_added_ingredients[-1]:
                    message += salad.lower() + "."
                else:                                                   
                    message += salad.lower() + ", "
            elif len(users_added_ingredients) == 2:    
                if salad == users_added_ingredients[0]:
                    message += salad.lower() + " and "
                elif salad == users_added_ingredients[1]:
                    message += salad.lower() + "."
                else:
                    message += salad.lower() + ", "
            else:
                message += salad.lower() + "."

        if users_added_ingredients == []:
            for salad in users_picked_salad:
                message_to_user = "\nThank you! Enjoy your " + Salad.get_name_of_salad(salad) + " that costs " + str(total_cost) + " sek."
                print(message_to_user)
                return message_to_user

        else:
            for salad in users_picked_salad:
                message_to_user = "\nThank you! Enjoy your " + Salad.get_name_of_salad(salad) + " that costs " + str(total_cost) + " sek that also contains " + message 
            print(message_to_user)
            return message_to_user

    elif users_choice == "No":
        for salad in users_picked_salad:
            message_to_user = "\nThank you! Enjoy your " + Salad.get_name_of_salad(salad) + " that costs " + Salad.get_price_of_salad(salad) + " sek."
            print(message_to_user)
            return message_to_user


def send_message_file(message_to_user):                         #Skickar kvitto till fil  
    with open("receipt.txt", "w") as receipt:
        receipt.write("KTH Salads\n")
        receipt.write("Receipt\n")
        receipt.write(message_to_user)


def main():                                                     #Main
    ingredients_dict = read_options_from_file()
    salad_objects = read_salads_from_file()
    print("\nWelcome to KTH Salads!\n\nHere are all of our ingredients that we\nhave available in our premade salads:\n")
    print_ingredients(ingredients_dict)
    users_salad = users_ingredients(ingredients_dict)
    wanted_salad = wanted_salad_if_subset(salad_objects,users_salad)
    wanted_salad_2 = wanted_salad_if_superset(salad_objects,users_salad)
    correct_salads,need_price_comparison = compare_salads(wanted_salad,wanted_salad_2,salad_objects,users_salad)
    correct_salad = compare_price(correct_salads,need_price_comparison)
    missing_ingredients = get_missing_ingredients(users_salad,correct_salad,need_price_comparison)                 
    users_picked_salad = pick_salad(correct_salad,correct_salads,need_price_comparison)
    users_choice = add_options_or_not(users_picked_salad)
    print_options(ingredients_dict,users_choice)
    users_added_ingredients = get_wanted_options(users_picked_salad,ingredients_dict,users_choice)
    message_to_user = add_wanted_options(users_choice,users_added_ingredients,users_picked_salad,ingredients_dict)
    send_message_file(message_to_user)

if __name__ =="__main__":
    main()