LT-Ingr2 (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# INGREDIENTS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import csv\n",
    "import collections\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('det_ingrs.json','r')              #make sure this flle is in the same directory as the notebook file\n",
    "#with open('det_ingrs.json','r') as file:\n",
    "data = json.load(file)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'valid': [True, True, True, True, True, True, True, True, False, False, True, True, True, False], 'id': '000018c8a5', 'ingredients': [{'text': 'penne'}, {'text': 'cheese sauce'}, {'text': 'cheddar cheese'}, {'text': 'gruyere cheese'}, {'text': 'dried chipotle powder'}, {'text': 'unsalted butter'}, {'text': 'all - purpose flour'}, {'text': 'milk'}, {'text': '14 ounces semihard cheese (page 23), grated (about 3 1/2 cups)'}, {'text': '2 ounces semisoft cheese (page 23), grated (1/2 cup)'}, {'text': 'kosher salt'}, {'text': 'dried chipotle powder'}, {'text': 'garlic powder'}, {'text': '(makes about 4 cups)'}]}\n"
     ]
    }
   ],
   "source": [
    "print(data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ingr = set()\n",
    "ingrGroups = []\n",
    "for x in data[:30000]:            #change the number in here for the amount of recipes you want to use\n",
    "    ingrGroups.append([])\n",
    "    for i in range(len(x['ingredients'])):\n",
    "        if x['valid'][i]:\n",
    "            ingr.add(x['ingredients'][i]['text'])\n",
    "            ingrGroups[-1].append(x['ingredients'][i]['text'])\n",
    "ingrSorted = sorted(ingr)\n",
    "ingrSorted.remove('')\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['penne', 'cheese sauce', 'cheddar cheese', 'gruyere cheese', 'dried chipotle powder', 'unsalted butter', 'all - purpose flour', 'milk', 'kosher salt', 'dried chipotle powder', 'garlic powder'], ['elbow macaroni', 'American cheese', 'celery', 'green peppers', 'pimentos', 'mayonnaise', 'vinegar', 'salt', 'dry dill weed'], ['tomatoes', 'kosher salt', 'red onion', 'green bell pepper', 'red bell pepper', 'yellow bell pepper', 'cucumber', 'olive oil', 'fresh basil']]\n"
     ]
    }
   ],
   "source": [
    "#print(ingrSorted)\n",
    "print(ingrGroups[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8183\n",
      "30000\n"
     ]
    }
   ],
   "source": [
    "print(len(ingr))\n",
    "print(len(ingrGroups))\n",
    "#Writes a CSV file with the ingredients and the ingredient groups. Groups don't work yet\n",
    "#with open(\"ingredients.csv\", 'w') as ingrFile:\n",
    "#    wr = csv.writer(ingrFile, delimiter = ',', dialect='excel')\n",
    "#    wr.writerow(ingr)\n",
    "#with open(\"ingredientGroups.csv\", 'w') as ingrGroupFile:\n",
    "#    wr = csv.writer(ingrGroupFile, delimiter = ',', dialect='excel')\n",
    "#    wr.writerow(ingrGroups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Finds the amount of times an ingredient occurs with another ingredient\n",
    "def findQuant():\n",
    "    cnt = collections.Counter()\n",
    "    for grp in ingrGroups:\n",
    "        for ingr in grp:\n",
    "            cnt[ingr] += 1\n",
    "    return cnt\n",
    "\n",
    "cnt = findQuant()\n",
    "\n",
    "#for i in ingrSorted:\n",
    "#    probs[i] = {}\n",
    "#    for x in ingrSorted:\n",
    "#        if i != x:\n",
    "#            for grp in ingrGroups:\n",
    "#                if x in grp and i in grp:\n",
    "#                    if x in probs[i].keys():\n",
    "#                        probs[i][x] = probs[i][x] + 1\n",
    "#                    else:\n",
    "#                        probs[i][x] = 1\n",
    "\n",
    "def getProbs(ingredient):\n",
    "    probs = {}\n",
    "    for i in ingrSorted:\n",
    "        if i != ingredient:\n",
    "            for grp in ingrGroups:\n",
    "                if ingredient in grp and i in grp:\n",
    "                    if i in probs.keys():\n",
    "                        probs[i] = probs[i] + 1\n",
    "                    else:\n",
    "                        probs[i] = 1\n",
    "                #u += 1\n",
    "                #b = str(u) + \"/\" + str(1*len(ingr)*len(ingrGroups))\n",
    "                #print(b, end=\"\\r\")\n",
    "    return probs\n",
    "\n",
    "def getTrigram(ingredient, scndIngr):\n",
    "    probs = {}\n",
    "    for i in ingrSorted:\n",
    "        if i != ingredient and i != scndIngr:\n",
    "            for grp in ingrGroups:\n",
    "                \n",
    "                if ingredient in grp and i in grp and scndIngr in grp:\n",
    "                    if i in probs.keys():\n",
    "                        probs[i] = probs[i] + 1\n",
    "                    else:\n",
    "                        probs[i] = 1\n",
    "    return probs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TL;DR : 18253 x 18253 x 1029720 = 343,073,881,107,480 iterations = 343 trillion iterations = a big fucking amount of iterations.\n",
    "\n",
    "According to https://startdebugging.net/counting-up-to-one-trillion/, it would take 4 hours and 10 minutes for a computer to count up to 1 trillion; so 343 trillion would take at least 1,429 hours, 28 minutes and 28.2 seconds. We don't have 59 days to train the probabilities..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37\n",
      "{'Arabic seven spice': 1, 'alfredo sauce': 1, 'bay leaf': 1, 'black pepper': 1, 'butter': 1, 'cardamom powder': 1, 'carrots': 1, 'celery': 1, 'chicken broth': 1, 'chicken stock': 2, 'chutney': 1, 'coconut': 1, 'cooked wild rice': 1, 'cream of coconut': 1, 'cream of mushroom soup': 1, 'cumin': 2, 'curry powder': 1, 'dry sherry': 1, 'flour': 1, 'fresh garlic': 1, 'fresh ginger': 1, 'frozen peas': 1, 'ground beef': 1, 'heavy cream': 1, 'lemons': 1, 'lime zest': 1, 'long grain rice': 1, 'onion': 1, 'onions': 1, 'parmesan cheese': 1, 'parsley': 1, 'pepper': 1, 'pine nuts': 1, 'pineapple': 1, 'pineapple juice': 1, 'salt': 1, 'sambal oelek chili paste': 1, 'seasoning salt': 1, 'sliced mushrooms': 1, 'turmeric powder': 1, 'vermicelli': 1}\n"
     ]
    }
   ],
   "source": [
    "#Prints the probabilities of chicken\n",
    "print(cnt[\"chicken breast\"])\n",
    "#print(getProbs(\"chicken breast\"))\n",
    "print(getTrigram(\"chicken\", \"almonds\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for k in range(6):\n",
    "#    rand = random.randint(0, cnt[\"chicken\"])\n",
    "#    i = 0\n",
    "#    for key in probs.keys():\n",
    "#        i += probs[key]\n",
    "#        if i > rand:\n",
    "#            print(key)\n",
    "#            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This function prints the random ingredients based on the main ingredient, or based on the last ingredient.\n",
    "#param main = The main ingredient for the recipe\n",
    "#param nmbrOfIngr = The number of ingredients the recipe contains\n",
    "#returns a list of ingredients\n",
    "def getIngr(main, nmbrOfIngr):\n",
    "    print(main)\n",
    "    ingrs = []\n",
    "    ingrs.append(main)\n",
    "    ingr = main\n",
    "    for n in range(nmbrOfIngr):\n",
    "        #ingr = main #comment this out if you want to have ingredients based on the last added ingredient\n",
    "        #print(\"ingr: \", ingr)\n",
    "        rand = random.randint(0, cnt[ingr])\n",
    "        i = 0\n",
    "        probs = getProbs(ingr)\n",
    "        for key in probs.keys():\n",
    "            i += probs[key]\n",
    "            if i >= rand and key not in ingrs:\n",
    "                print(key)\n",
    "                ingr = key\n",
    "                ingrs.append(key)\n",
    "                break\n",
    "    return ingrs\n",
    "\n",
    "#Generates ingredients based on the last two ingredients of the list, or on the last and main ingredient.\n",
    "#param main = The main ingredient for the recipe\n",
    "#param nmbrOfIngr = The number of ingredients the recipe contains\n",
    "#returns a list of ingredients\n",
    "def getIngrTri(main, nmbrOfIngr):\n",
    "    print(main)\n",
    "    ingrs = []\n",
    "    ingrs.append(main)\n",
    "    ingr = main\n",
    "    rand = random.randint(0, cnt[ingr])\n",
    "    i = 0\n",
    "    probs = getProbs(ingr)\n",
    "    for key in probs.keys():\n",
    "        i += probs[key]\n",
    "        if i >= rand and key not in ingrs:\n",
    "            print(key)\n",
    "            ingr = key\n",
    "            ingrs.append(key)\n",
    "            break\n",
    "    for n in range(nmbrOfIngr-1):\n",
    "        #ingr = main #comment this out if you want to have ingredients based on the last added ingredient\n",
    "        #print(\"ingr: \", ingr)\n",
    "        i = 0\n",
    "        probs = getTrigram(ingr, ingrs[-2])\n",
    "        rand = random.randint(0, len(probs))\n",
    "        #print(probs)\n",
    "        for key in probs.keys():\n",
    "            i += probs[key]\n",
    "            if i >= rand and key not in ingrs:\n",
    "                print(key)\n",
    "                ingr = key\n",
    "                ingrs.append(key)\n",
    "                break\n",
    "    return ingrs\n",
    "\n",
    "#getIngrTri(\"minced beef\", 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def average_ingr(ingredient):\n",
    "    total_length = []\n",
    "    for ingrGroup in ingrGroups:\n",
    "        if ingredient in ingrGroup:\n",
    "            total_length.append(len(ingrGroup))\n",
    "    average_len = sum(total_length)/len(total_length)\n",
    "    print(int(average_len))\n",
    "    return int(average_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "11\n",
      "beef\n",
      "Worcestershire sauce\n",
      "bay leaves\n",
      "beef broth\n",
      "black pepper\n",
      "dry sherry\n",
      "cooked ham\n",
      "pumpkin puree\n",
      "onions\n",
      "chicken\n",
      "cinnamon sticks\n",
      "carrot\n"
     ]
    }
   ],
   "source": [
    "#bigrams = getIngr(\"chicken breast\", 5)\n",
    "print(\"\\n\")\n",
    "#trigrams = getIngrTri(\"flour\", 5)\n",
    "trigrams = getIngrTri(\"beef\", average_ingr(\"beef\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# INSTRUCTIONS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('layer1.json','r')              #make sure this file is in the same directory as the notebook file\n",
    "#with open('det_ingrs.json','r') as file:\n",
    "data = json.load(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'text': 'Preheat the oven to 350 F. Butter or oil an 8-inch baking dish.'}, {'text': 'Cook the penne 2 minutes less than package directions.'}, {'text': '(It will finish cooking in the oven.)'}, {'text': 'Rinse the pasta in cold water and set aside.'}, {'text': 'Combine the cooked pasta and the sauce in a medium bowl and mix carefully but thoroughly.'}, {'text': 'Scrape the pasta into the prepared baking dish.'}, {'text': 'Sprinkle the top with the cheeses and then the chili powder.'}, {'text': 'Bake, uncovered, for 20 minutes.'}, {'text': 'Let the mac and cheese sit for 5 minutes before serving.'}, {'text': 'Melt the butter in a heavy-bottomed saucepan over medium heat and whisk in the flour.'}, {'text': 'Continue whisking and cooking for 2 minutes.'}, {'text': 'Slowly add the milk, whisking constantly.'}, {'text': 'Cook until the sauce thickens, about 10 minutes, stirring frequently.'}, {'text': 'Remove from the heat.'}, {'text': 'Add the cheeses, salt, chili powder, and garlic powder.'}, {'text': 'Stir until the cheese is melted and all ingredients are incorporated, about 3 minutes.'}, {'text': 'Use immediately, or refrigerate for up to 3 days.'}, {'text': 'This sauce reheats nicely on the stove in a saucepan over low heat.'}, {'text': 'Stir frequently so the sauce doesnt scorch.'}, {'text': 'This recipe can be assembled before baking and frozen for up to 3 monthsjust be sure to use a freezer-to-oven pan and increase the baking time to 50 minutes.'}, {'text': 'One-half teaspoon of chipotle chili powder makes a spicy mac, so make sure your family and friends can handle it!'}, {'text': 'The proportion of pasta to cheese sauce is crucial to the success of the dish.'}, {'text': 'It will look like a lot of sauce for the pasta, but some of the liquid will be absorbed.'}]\n"
     ]
    }
   ],
   "source": [
    "print(data[0]['instructions'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "instr = []\n",
    "for x in data[:100000]:            #change the number in here for the amount of recipes you want to use\n",
    "    for i in x['instructions']:\n",
    "        instr.append(i['text'].lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['stir in lemon juice and 1/4 cup chopped fennel fronds.', 'thinly slice pork and serve over fennel with sauce.', 'in a pitcher, combine all the ingredients except the soft drink and ice cubes.', 'refrigerate for 1 hour.', 'add the soft drink and ice just before serving.']\n"
     ]
    }
   ],
   "source": [
    "print(instr[100:105])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "methods = [\"grate\", \"pinch\", \"broil\", \"chop\", \"cut\", \"dip\", \"fry\", \"boil\", \"stir\", \"spread\", \"layer\", \"level\", \n",
    "           \"slice\", \"bake\", \"blend\", \"scramble\", \"melt\", \"pour\", \"simmer\", \"carve\", \"knead\", \"dice\", \"grill\", \n",
    "           \"sprinkle\", \"whip\", \"squeeze\", \"crush\", \"strain\", \"mix\", \"whisk\", \"saute\", \"roast\", \"microwave\", \"flip\", \n",
    "           \"baste\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findMethodCount(trigrams):\n",
    "    ingrMethods = {}\n",
    "    for ingr in trigrams:\n",
    "        #ingrMethods[ingr] = {}\n",
    "        methCnt = collections.Counter()\n",
    "        for meth in methods:\n",
    "            for i in instr:\n",
    "                if meth in i and ingr in i:\n",
    "                    methCnt[meth] += 1\n",
    "        ingrMethods[ingr] = methCnt\n",
    "        #print(methCnt)\n",
    "    return ingrMethods\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['beef', 'Worcestershire sauce', 'bay leaves', 'beef broth', 'black pepper', 'dry sherry', 'cooked ham', 'pumpkin puree', 'onions', 'chicken', 'cinnamon sticks', 'carrot']\n",
      "fry the beef. chop the Worcestershire sauce and add it to the pan. stir in the bay leaves and the beef broth. mix in the black pepper. stir in the dry sherry. chop the cooked ham and add it to the pan. mix in the pumpkin puree. saute the onions. mix in the chicken. boil the cinnamon sticks. stir in the carrot, taste and finally serve!\n"
     ]
    }
   ],
   "source": [
    "cooking_methods = [\"broil\", \"fry\", \"boil\", \"melt\", \"simmer\", \"grill\",  \"saute\", \"roast\", \"microwave\", \"baste\", \"stew\"]\n",
    "cooking_containers = {\"broil\":\"pot\", \"fry\":\"pan\", \"boil\":\"pot\", \"melt\":\"pan\", \"simmer\":\"pot\", \"grill\":\"tray\",  \"saute\":\"pan\", \"roast\":\"tray\", \"microwave\":\"bowl\", \"baste\":\"pot\"}\n",
    "adding_methods = {\"stir\":\"stir in\", \"whisk\":[\"whisk in\", \" with the other ingredients\"], \"sprinkle\":[\"sprinkle\", \" on top\"], \"pour\":\"pour\", \"mix\": \"mix in\" } \n",
    "ingredients = trigrams\n",
    "ingredient_methods = findMethodCount(ingredients)\n",
    "\n",
    "print(ingredients)\n",
    "first_method = \"yes\"\n",
    "last_method = \"\"\n",
    "print_sentence = \"\"\n",
    "for ingredient in ingredients:\n",
    "    try:\n",
    "        method = ingredient_methods[ingredient].most_common(1)[0][0]\n",
    "    except:\n",
    "        method = \"chop\"\n",
    "    if method == last_method:\n",
    "        print_sentence += \" and the \" + ingredient\n",
    "        continue\n",
    "    elif first_method != \"yes\":\n",
    "        print_sentence += \". \"\n",
    "    last_method = method\n",
    "    if method in adding_methods:\n",
    "        if isinstance(adding_methods[method], list):\n",
    "            print_sentence += adding_methods[method][0] +\" the \" + ingredient + adding_methods[method][1]\n",
    "            continue\n",
    "        elif first_method != \"yes\":\n",
    "            print_sentence += adding_methods[method] +\" the \" + ingredient\n",
    "            continue\n",
    "        else:\n",
    "            method = \"fry\"\n",
    "            print_sentence += method +\" the \" + ingredient\n",
    "            first_method = method\n",
    "    else:\n",
    "        print_sentence += method +\" the \" + ingredient\n",
    "    if method not in cooking_methods and first_method != \"yes\":\n",
    "        print_sentence += \" and add it to the \" + cooking_containers[first_method]\n",
    "        last_method = \"no\"\n",
    "    if method not in cooking_methods and first_method == \"yes\":\n",
    "        for method1 in ingredient_methods[ingredient].most_common(10):\n",
    "            done = False\n",
    "            if method1[0] in cooking_methods:\n",
    "                print(method1[0])\n",
    "                print_sentence += \" and then \" + method1[0] + \" it\"\n",
    "                done = True\n",
    "                first_method = method1[0]\n",
    "                break\n",
    "print(print_sentence + \", taste and finally serve!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cooking_methods = [\"broil\", \"fry\", \"boil\", \"melt\", \"simmer\", \"grill\",  \"saute\", \"roast\", \"microwave\", \"baste\", \"stew\"]\n",
    "cooking_containers = {\"broil\":\"pot\", \"fry\":\"pan\", \"boil\":\"pot\", \"melt\":\"pan\", \"simmer\":\"pot\", \"grill\":\"tray\",  \"saute\":\"pan\", \"roast\":\"tray\", \"microwave\":\"bowl\", \"baste\":\"pot\"}\n",
    "adding_methods = {\"stir\":\"stir in\", \"whisk\":\"whisk in\", \"sprinkle\":\"sprinkle\", \"pour\":\"pour\", \"mix\": \"mix in\" } "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_template(method, method_dict):\n",
    "    \"\"\"Generate a sentence based on the method and how many ingredients use that method in the recipe\"\"\"\n",
    "    recipe_str = \"\"\n",
    "    if method in adding_methods:\n",
    "        recipe_str += adding_methods[method].title() + \" the \"\n",
    "    else:\n",
    "        recipe_str += str(method).title() + \" the \"\n",
    "    for ingredient_i in range(0, len(method_dict[method])):\n",
    "        #Loops through the ingredients associated with the method to createproper \",\" and \"and\" grammar.\n",
    "        if len(method_dict[method]) == 1:\n",
    "            #if there is only one ingredient associated with the method\n",
    "            recipe_str += str(method_dict[method][ingredient_i])\n",
    "            break\n",
    "        if ingredient_i != len(method_dict[method]) - 1:\n",
    "            #if this ingredient isn't the last one associated with the method\n",
    "            if ingredient_i > 0:\n",
    "                recipe_str += \", \"\n",
    "            recipe_str += str(method_dict[method][ingredient_i])\n",
    "        else:\n",
    "            #if this ingredient is the last one associated with the method\n",
    "            recipe_str += \" and the \" + str(method_dict[method][ingredient_i]) + \". \"\n",
    "    return recipe_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['beef', 'bay leaves', 'Worcestershire sauce', 'Italian parsley', 'garlic cloves', 'olive oil', 'carrots', 'fresh lemon juice', 'pepper', 'garlic', 'long - grain rice', 'apple juice']\n",
      "[('mix', 'beef'), ('stir', 'bay leaves'), ('chop', 'Worcestershire sauce'), ('chop', 'Italian parsley'), ('chop', 'garlic cloves'), ('saute', 'olive oil'), ('stir', 'carrots'), ('squeeze', 'fresh lemon juice'), ('stir', 'pepper'), ('stir', 'garlic'), ('chop', 'long - grain rice'), ('mix', 'apple juice')]\n",
      "{'mix': ['beef', 'apple juice'], 'stir': ['bay leaves', 'carrots', 'pepper', 'garlic'], 'chop': ['Worcestershire sauce', 'Italian parsley', 'garlic cloves', 'long - grain rice'], 'saute': ['olive oil'], 'squeeze': ['fresh lemon juice']}\n",
      "0\n",
      "1\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "Mix In the beef and the apple juice. Stir In the bay leaves, carrots, pepper and the garlic. Chop the Worcestershire sauce, Italian parsley, garlic cloves and the long - grain rice. Saute the olive oilSqueeze the fresh lemon juice\n"
     ]
    }
   ],
   "source": [
    "#ingredients = trigrams\n",
    "ingredients = ['beef', 'bay leaves', 'Worcestershire sauce', 'Italian parsley', 'garlic cloves', 'olive oil', 'carrots', 'fresh lemon juice', 'pepper', 'garlic', 'long - grain rice', 'apple juice']\n",
    "ingredient_methods = findMethodCount(ingredients)\n",
    "\n",
    "print(ingredients)\n",
    "\n",
    "method_list = []\n",
    "for ingredient in ingredients:\n",
    "    try:\n",
    "        method = ingredient_methods[ingredient].most_common(1)[0][0]\n",
    "    except:\n",
    "        method = \"chop\"\n",
    "    \n",
    "    method_list.append((method, ingredient))\n",
    "\n",
    "print(method_list)\n",
    "\n",
    "method_dict = {}\n",
    "for method, ingredient in method_list:\n",
    "    if method in method_dict:\n",
    "        method_dict[method].append(ingredient)\n",
    "    else:\n",
    "        method_dict.update({method:[ingredient]})\n",
    "\n",
    "print(method_dict)\n",
    "recipe_str = \"\"\n",
    "i = 0\n",
    "last_method = \"\"\n",
    "for method in method_dict:\n",
    "    if i == 1 and last_method not in cooking_methods:        \n",
    "        for method1 in ingredient_methods[method_dict[last_method][0]ingredient].most_common(10):\n",
    "            done = False\n",
    "            if method1[0] in cooking_methods:\n",
    "                print(method1[0])\n",
    "                print_sentence += \" and then \" + method1[0] + \" it\"\n",
    "                done = True\n",
    "                first_method = method1[0]\n",
    "        recipe_str += generate_template(method, method_dict)\n",
    "    recipe_str += generate_template(method, method_dict)\n",
    "    i += 1\n",
    "    last_method = method\n",
    "print(recipe_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}