def saveRecipe(tokens, recipe):
    """
    Saves the recipe if it is fully filled in, otherwise gives an error message
    :param tokens: processed line of input
    :param recipe: recipe being saved
    :return:
    """
    ready = True
    if len(recipe.ingredients.keys()) == 0:
        print("Cannot save recipe with zero ingredients")
        ready = False
    if len(recipe.steps) == 0:
        print("Cannot save recipe with no steps")
        ready = False
    if( recipe.servings is None):
        print("Must set servings size of recipe before saving")
        ready = False
    if(recipe.time is None):
        print("Must set prep time of recipe before saving")
        ready = False

    if not ready:
        return
    #displayRecipe(recipe)
    if recipe.rid is not None:
        recipe.delete()

    Recipe.register_recipe(MANAGER, name=recipe.name, prep_time=recipe.time,
                           servings=recipe.servings, equipment=recipe.equipment,
                           owner=USER, steps=recipe.steps,
                           ingredients=recipe.ingredients)

    print(recipe.name + " saved successfully!")
    back(tokens)
Beispiel #2
0
    def post(self):
        login.logging_user(self)

        title_last = self.request.get("rtitle")
        ingr_last = self.request.get("ringredientes")
        prep_last = self.request.get("rpreparacion")

        if title_last != "" and ingr_last != "" and prep_last != "":
            currentUser = users.get_current_user().nickname()
            aux = Recipe(parent=ndb.Key("Recipe", title_last or "*notitle*"),
                         title=title_last,
                         ingredients=ingr_last,
                         directions=prep_last,
                         author=currentUser)

            aux.put()
            time.sleep(0.5)

        recetas = Recipe.query()

        template_values = {'recetas': recetas}

        jinja = jinja2.get_jinja2(app=self.app)
        self.response.write(
            jinja.render_template("index.html", **template_values))
Beispiel #3
0
def importBSMXRecipe(data):
    logger.debug("Start parsing BSMX recipe")

    # BSMX format use not valid entities
    def correct_bsmx_entities(text):
        text = re.sub("(ld|rd|rs)quo;", "quot;", text)
        text = text.replace("°", "°")
        return text

    try:
        tree = ElementTree.fromstring(correct_bsmx_entities(open(data, "r").read()))
    except TypeError:
        tree = data
    except FileNotFoundError:
        tree = ElementTree.fromstring(correct_bsmx_entities(data))
    except:
        raise

    recipe = Recipe()

    recipe_root = tree.find(".//Recipe")

    recipe.name = recipe_root.find("F_R_NAME").text
    recipe.brewer = recipe_root.find("F_R_BREWER").text
    equipment = recipe_root.find("F_R_EQUIPMENT")
    recipe.volume = bsmx_volume_conversion(float(equipment.find("F_E_BATCH_VOL").text))
    recipe.efficiency = float(equipment.find("F_E_EFFICIENCY").text)
    recipe.boil = float(equipment.find("F_E_BOIL_TIME").text)
    bsmx_type = {
        "0": model.constants.RECIPE_TYPE_EXTRACT,
        "1": model.constants.RECIPE_TYPE_PARTIAL_MASH,
        "2": model.constants.RECIPE_TYPE_ALL_GRAIN,
    }
    recipe.type = bsmx_type[recipe_root.find("F_R_TYPE").text]
    style = recipe_root.find("F_R_STYLE")
    recipe.style = "%s%s. %s" % (
        style.find("F_S_NUMBER").text,
        chr(64 + int(style.find("F_S_LETTER").text) % 26),
        style.find("F_S_NAME").text,
    )
    recipe.recipeNotes = recipe_root.find("F_R_NOTES").text
    recipe.mash = importBSMXMash(recipe_root.find("F_R_MASH"))

    elements = recipe_root.find("Ingredients").find("Data")
    for element in elements.findall("Grain"):
        recipe.listeFermentables.append(importBSMXFermentable(element))
    for element in elements.findall("Hops"):
        recipe.listeHops.append(importBSMXHop(element))
    for element in elements.findall("Yeast"):
        recipe.listeYeasts.append(importBSMXYeast(element))
    for element in elements.findall("Misc"):
        recipe.listeMiscs.append(importBSMXMisc(element))

    logger.debug("End parsing BSMX recipe")
    return recipe
def optimise(recipe_data, meal_spec):
    '''
    description:
        Function responsible for optimising a recipe to
        meet a meal specification.
    args:
        1. recipe_data -- A recipe dictionary object from the
            list in the recipe.py database.
        2. meal_spec -- A meal specification object from
            the daily_meals list in the user_configs.py
            file.
    kwargs:
        kwargname -- ...
    raises:
        exceptname -- ...
    returns:
        An optimised recipe object.
    '''
    # Create a new population instance.
    p = Population()
    # Fill it with random vaiable variations of the recipe.
    # While the population is not full.
    while p.size < configs['max_population_size']:
        # Create a new recipe.
        r = Recipe(recipe_data['name'], recipe_data['ingredients'])
        # Mutate it.
        r = mutate_recipe(r)
        # Score the child.
        score = score_recipe(r, meal_spec)
        r.score = score
        # Add it to the population.
        p.add_recipe(r)
    # Run the GA to create an version of the recipe with
    # optimal macronutrient ratios.
    print("Optimising Recipe: " + recipe_data['name'] + "\n")
    while p.best_recipe.score < configs['goal_threshold'] \
        and p.generation_count < configs['generation_limit']:
        draw_progress_bar(p.generation_count, configs['generation_limit'] - 1)
        # Cull the population to the minium level.
        cull_population(p, meal_spec)
        # Grow the population to the maximum level.
        grow_population(p, meal_spec)
        # Log the best recipe data
        log_best_recipe(p, meal_spec['name'])
        # Increment the generation count.
        p.generation_count = p.generation_count + 1
    # Scale the optimised recipe to meet the caloric requirement
    # given in the meal spec.
    optimised_recipe = scale_recipe_to_calories(p.best_recipe, \
        (meal_spec['perc_daily_calories']/100) \
        *user_configs['target_daily_calories'])
    # Return the optimised recipe.
    return optimised_recipe
Beispiel #5
0
def importBSMXRecipe(data):
    logger.debug("Start parsing BSMX recipe")
    
    #BSMX format use not valid entities
    def correct_bsmx_entities(text):
        text = re.sub('(ld|rd|rs)quo;', 'quot;', text)
        text = text.replace('&deg;', '°')
        return text
    try:
        tree = ElementTree.fromstring(correct_bsmx_entities(open(data, 'r').read()))
    except TypeError:
        tree = data
    except FileNotFoundError:
        tree = ElementTree.fromstring(correct_bsmx_entities(data))
    except:
        raise

    recipe = Recipe()

    recipe_root = tree.find('.//Recipe')

    recipe.name = recipe_root.find('F_R_NAME').text
    recipe.brewer = recipe_root.find('F_R_BREWER').text
    equipment = recipe_root.find('F_R_EQUIPMENT')
    recipe.volume = bsmx_volume_conversion(float(equipment.find('F_E_BATCH_VOL').text))
    recipe.efficiency = float(equipment.find('F_E_EFFICIENCY').text)
    recipe.boil = float(equipment.find('F_E_BOIL_TIME').text)
    bsmx_type = {
        '0': model.constants.RECIPE_TYPE_EXTRACT,
        '1': model.constants.RECIPE_TYPE_PARTIAL_MASH,
        '2': model.constants.RECIPE_TYPE_ALL_GRAIN
    }
    recipe.type = bsmx_type[recipe_root.find('F_R_TYPE').text]
    style = recipe_root.find('F_R_STYLE')
    recipe.style = '%s%s. %s' % (style.find('F_S_NUMBER').text, chr(64+int(style.find('F_S_LETTER').text) % 26),
                                 style.find('F_S_NAME').text)
    recipe.recipeNotes = recipe_root.find('F_R_NOTES').text
    recipe.mash = importBSMXMash(recipe_root.find('F_R_MASH'))

    elements = recipe_root.find('Ingredients').find('Data')
    for element in elements.findall('Grain'):
        recipe.listeFermentables.append(importBSMXFermentable(element))
    for element in elements.findall('Hops'):
        recipe.listeHops.append(importBSMXHop(element))
    for element in elements.findall('Yeast'):
        recipe.listeYeasts.append(importBSMXYeast(element))
    for element in elements.findall('Misc'):
        recipe.listeMiscs.append(importBSMXMisc(element))

    logger.debug("End parsing BSMX recipe")
    return recipe
Beispiel #6
0
    def recent_recipes(self, user=None, limit=5):
        cur = self.get_cursor()
        cur.execute(
            """
            SELECT
                recipes.*,
                owner.*,
                MAX(datemade) as last_date
            FROM recipes
            JOIN dates_made ON recipes.rid = dates_made.rid
            JOIN users
                AS owner
                ON owner.uid = recipes.owner_id
            %%%
            GROUP BY recipes.rid, owner.uid
            ORDER BY last_date DESC
            LIMIT %s;
        """.replace('%%%',
                    ('WHERE dates_made.uid = %s' if user != None else '')),
            ((limit, ) if user == None else (user.uid, limit)))

        results = (Recipe.new_from_combined_record(self, record)
                   for record in cur.fetchall())
        cur.close()
        return results
Beispiel #7
0
    def compatible_recipes(self, limit=10):
        cur = self.manager.get_cursor()

        cur.execute(
            """
            SELECT
                recipes.*,
                owner.*,
                SUM(LEAST(1.0, qtyowned / ownd_comp.amount)) / (
                    SELECT COUNT(iname)
                    FROM requires_ingredient
                    WHERE requires_ingredient.rid = recipes.rid
                ) AS percent_owned
            FROM ingredient_ownership
            JOIN requires_ingredient
                AS ownd_comp
                ON ownd_comp.iname = ingredient_ownership.iname
            JOIN recipes
                ON ownd_comp.rid = recipes.rid
            JOIN users
                AS owner
                ON owner.uid = recipes.owner_id
            WHERE ingredient_ownership.uid = %s
            GROUP BY recipes.rid, owner.uid
            ORDER BY percent_owned DESC
            LIMIT %s;
        """, (self.uid, limit))

        results = ((Recipe.new_from_combined_record(self.manager,
                                                    record), record[8])
                   for record in cur.fetchall())

        cur.close()
        return results
def popular(tokens, optional=None):
    """
    Displays the 10 most made recipes for the week to the user
    :param tokens: processed line of input
    :param optional: N/A
    :return:
    """

    return RecipeListLoop(list(item[0] for item in Recipe.get_popular_recipes(MANAGER, 10)))
Beispiel #9
0
    def importBeerXML(self):
        fichierBeerXML = self.s
        try:
            self.recipe = Recipe.parse(fichierBeerXML)
            self.currentRecipeMash = self.recipe.mash

        except:
            errors = Errors()
            errors.warningXml()
Beispiel #10
0
    def get(self):
        login.logging_user(self)

        recetas = Recipe.query()

        template_values = {'recetas': recetas}

        jinja = jinja2.get_jinja2(app=self.app)
        self.response.write(
            jinja.render_template("index.html", **template_values))
def createRecipe(tokens, optional=None):
    """
    Enter recipe create loop with a new empty recipe
    :param tokens: processed line of input
    :param optional: N/A
    :return:
    """
    return RecipeCreateLoop(
        Recipe(manager=MANAGER, rid=None, servings=None, time=None, name=tokens[1],
               owner_id=USER.uid, equip=[], owner=USER, ingr={}, steps=[])
    )
Beispiel #12
0
def breed_recipes(recipe_1, recipe_2):
    '''
    description:
        Takes two recipes and randomly combines their
        IngredientAmount(s) to form a new child recipe.
        Performs rescaling to ensure the child recipe
        is valid (i.e its IngredientAmount(s) sum to
        100%).
    args:
        1. recipe_1 -- The first parent Recipe instance.
        2. recipe_2 -- The second parent Recipe instance.
    argv:
        [...]
    kwargs:
        kwargname -- ...
    raises:
        exceptname -- ...
    returns:
        A child Recipe instance.
    '''
    # Start the child's ingredients_data list.
    child_ingredients_data = []
    # Grab a list of the ingredient names.
    ingredient_names = recipe_1.ingredient_names
    # For each ingredient name on the list;
    for ingredient_name in ingredient_names:
        # Choose this IngredientAmount from parent at random.
        parent_1_ia = recipe_1.get_ingredient_amount(ingredient_name)
        parent_2_ia = recipe_2.get_ingredient_amount(ingredient_name)
        child_ia = random.choice([parent_1_ia, parent_2_ia])
        # Create the ingredient dict.
        # It is valid to use the ingredient perc as the
        # gms quantity in the ingredient dict, becuase this
        # is equivalent to the number of gms in a meal totalling
        # 100g. Since it will be normalised to a percentage
        # this is OK.
        ingredient_dict = {
            "name": ingredient_name,
            "gms": child_ia.perc_of_meal
        }
        # Add the ingredient dict to the child's ingredient list.
        child_ingredients_data.append(ingredient_dict)
    # Once the ingredient dict has been created by randomly
    # choosing from the two parents, instantiate the child
    # recipe.
    child_recipe = Recipe(recipe_1.name, child_ingredients_data)
    # If the child recipe should mutate;
    if should_mutate():
        child_recipe = mutate_recipe(child_recipe)
    # Rescale the recipe.
    child_recipe = _rescale_recipe(child_recipe)
    # Return the child recipe.
    return child_recipe
Beispiel #13
0
def generate():
    adjectives = file_to_string_list(ADJECTIVES)
    food_genres = file_to_string_list(FOOD_GENRES)
    persons = file_to_string_list(PERSONS)
    pt_verbs = file_to_string_list(PT_VERBS)
    ingredients = list(map(lambda x: ingredient_from_st(x), file_to_string_list(INGREDIENTS)))

    addition_methods = file_to_string_list(ADDITION_METHODS)
    final_steps = file_to_string_list(FINAL_STEPS)

    for i in range(VOLUME):
        recipe_ingredients = random.sample(ingredients, k=random.randint(1, min(len(ingredients)-1, MAX_INGREDIENTS_PER_RECIPE)))

        title_ingredient = random.choice(recipe_ingredients)
        name = assemble_name(persons, adjectives, pt_verbs, title_ingredient, food_genres)

        equip_dictionary = readEquipment(EQUIPMENT)

        selected_equips = random.sample(list(equip_dictionary.keys()), k=random.randint(0, len(list(equip_dictionary.keys()))))

        selected_equips_dict = {}
        for eq in selected_equips:
            selected_equips_dict[eq] = equip_dictionary[eq]

        recipe_steps = gen_steps_lst(addition_methods, recipe_ingredients, selected_equips_dict, final_steps)

        ingredients_dict = gen_ingredient_dictionary(recipe_ingredients)

        rec = Recipe(MANAGER, 0, random.randint(1, 4), random.randint(5, 360), name, list(selected_equips_dict.keys()), None, ingredients_dict, recipe_steps)

        print("====================")
        displayRecipe(rec)

        Recipe.register_recipe(manager=MANAGER, name=name,
                               servings=random.randrange(1, 4),
                               time=random.randint(5, 360),
                               equip=list(selected_equips_dict.keys()),
                               owner=USER, ingr=ingredients_dict,
                               steps=recipe_steps, owner_id=USER.uid)
def top_10_recipes_graph(manager):
    pairs = Recipe.get_popular_recipes(manager, 5)

    X = []
    Y = []

    for rec, count in pairs:
        X.append("\n".join(wrap(rec.name, 15)))
        Y.append(count)

    fig1, ax1 = plt.subplots()
    ax1.set_title("Most Made Recipes this Week")
    ax1.bar(height=Y, x=X, width=0.4)
    plt.show()
Beispiel #15
0
    def searchRecipes(self, name):
        cur = self.get_cursor()
        partialName = ['%' + x.strip() + '%' for x in name.split(' ')]
        sqlQuery = """
            SELECT recipes.*, owner.*
            FROM recipes
            JOIN users
                AS owner
                ON owner.uid = recipes.owner_id
            WHERE """ + " OR ".join(["rName LIKE %s"] * len(partialName)) + ";"
        cur.execute(sqlQuery, partialName)
        records = cur.fetchall()
        cur.close()

        return (Recipe.new_from_combined_record(self, record)
                for record in records)
Beispiel #16
0
    def search_by_ingredient(self, ingr, limit=10):
        cur = self.get_cursor()
        cur.execute(
            """
            SELECT recipes.*, owner.*
            FROM requires_ingredient
            JOIN recipes ON requires_ingredient.rid = recipes.rid
            JOIN users
                AS owner
                ON owner.uid = recipes.owner_id
            WHERE iname = %s
            LIMIT %s;
        """, (ingr.iname, limit))

        results = (Recipe.new_from_combined_record(self, record)
                   for record in cur.fetchall())
        cur.close()
        return results
Beispiel #17
0
    def get(self):
        login.logging_user(self)
        recetas = Recipe.query()

        recipe_id = self.request.get("id")

        receta_actual = None
        for receta in recetas:
            if str(receta.key.id()) == recipe_id:
                receta_actual = receta

        comentarios = Comment.query(Comment.recipe_id == str(recipe_id))

        template_values = {
            'receta_actual': receta_actual,
            'comentarios': comentarios
        }

        jinja = jinja2.get_jinja2(app=self.app)
        self.response.write(
            jinja.render_template("recipeView.html", **template_values))
    def recipe_get(self, idx, conn):
        selrecipes = select([self.recipes]).where(self.recipes.c.id == idx)
        recipesresult = conn.execute(selrecipes)

        recipex = ""

        for recipesrow in recipesresult:
            selusers = select([self.users]).where(
                self.users.c.id == recipesrow.user_id)
            usersresult = conn.execute(selusers)
            author = usersresult.fetchone().name
            selingrslst = select([self.ingredients_list]).where(
                self.ingredients_list.c.recipe_id == idx)
            ingredslstres = conn.execute(selingrslst)

            ings = []
            for ingredslstrow in ingredslstres:
                selingrds = select([self.ingredients]).where(
                    self.ingredients.c.id == ingredslstrow.ingredient_id)
                ingrdsresult = conn.execute(selingrds)
                for ingredsrow in ingrdsresult:
                    ing = Ingredient(
                        ingredsrow.name, ingredsrow.allergen,
                        ingredslstrow.quantity)
                    ings.append(ing)

            seldirs = select([self.directions_list]).where(
                self.directions_list.c.recipe_id == idx)
            dirsresult = conn.execute(seldirs)
            dirs = []
            for dirsrow in dirsresult:
                dir = Direction(dirsrow.number, dirsrow.text)
                dirs.append(dir)

            recipex = Recipe(idx, recipesrow.name, recipesrow.country,
                             recipesrow.course, recipesrow.views, author,
                             ings, recipesrow.image, dirs)

        return recipex
Beispiel #19
0
    def post(self):
        login.logging_user(self)

        recetas = Recipe.query()

        recipe_id = self.request.get("id")

        comments_author = self.request.get("author")

        comments_content = self.request.get("content")

        comments_title = self.request.get("title-commment")

        if comments_author != "" and comments_content != "" and recipe_id != "" and comments_title != "":
            comentario = Comment(author=comments_author,
                                 comment=comments_content,
                                 recipe_id=recipe_id,
                                 title=comments_title)
            comentario.put()
            time.sleep(0.5)

        comentarios = Comment.query(Comment.recipe_id == str(recipe_id))

        receta_actual = None
        for receta in recetas:
            if str(receta.key.id()) == recipe_id:
                receta_actual = receta

        template_values = {
            'receta_actual': receta_actual,
            'comentarios': comentarios
        }

        jinja = jinja2.get_jinja2(app=self.app)
        self.response.write(
            jinja.render_template("recipeView.html", **template_values))
Beispiel #20
0
 def testIngredientsIsNone(self):
     with self.assertRaises(Exception):
         Recipe("Lasagna", ['pasta', 'italian'], 1.0, 2.0, None,
                ['combine ingredients', 'cook ingredients'], 2)
Beispiel #21
0
 def testCategoriesIsNone(self):
     with self.assertRaises(Exception):
         Recipe("Lasagna", None, 1.0, 2.0,
                ['meat', 'noodles', 'sauce', 'cheese'],
                ['combine ingredients', 'cook ingredients'], 2)
Beispiel #22
0
 def testNameIsNone(self):
     with self.assertRaises(Exception):
         Recipe(None, ['pasta', 'italian'], 1.0, 2.0,
                ['meat', 'noodles', 'sauce', 'cheese'],
                ['combine ingredients', 'cook ingredients'], 2)
Beispiel #23
0
def importBSMXRecipe(data):
    logger.debug("Start parsing BSMX recipe")

    #BSMX format use not valid entities
    def correct_bsmx_entities(text):
        text = re.sub('(ld|rd|rs)quo;', 'quot;', text)
        text = text.replace('&deg;', '°')
        return text

    try:
        tree = ElementTree.fromstring(
            correct_bsmx_entities(open(data, 'r').read()))
    except TypeError:
        tree = data
    except FileNotFoundError:
        tree = ElementTree.fromstring(correct_bsmx_entities(data))
    except:
        raise

    recipe = Recipe()

    recipe_root = tree.find('.//Recipe')

    recipe.name = recipe_root.find('F_R_NAME').text
    recipe.brewer = recipe_root.find('F_R_BREWER').text
    equipment = recipe_root.find('F_R_EQUIPMENT')
    recipe.volume = bsmx_volume_conversion(
        float(equipment.find('F_E_BATCH_VOL').text))
    recipe.efficiency = float(equipment.find('F_E_EFFICIENCY').text)
    recipe.boil = float(equipment.find('F_E_BOIL_TIME').text)
    bsmx_type = {
        '0': model.constants.RECIPE_TYPE_EXTRACT,
        '1': model.constants.RECIPE_TYPE_PARTIAL_MASH,
        '2': model.constants.RECIPE_TYPE_ALL_GRAIN
    }
    recipe.type = bsmx_type[recipe_root.find('F_R_TYPE').text]
    style = recipe_root.find('F_R_STYLE')
    recipe.style = '%s%s. %s' % (style.find('F_S_NUMBER').text,
                                 chr(64 + int(style.find('F_S_LETTER').text) %
                                     26), style.find('F_S_NAME').text)
    recipe.recipeNotes = recipe_root.find('F_R_NOTES').text
    recipe.mash = importBSMXMash(recipe_root.find('F_R_MASH'))

    elements = recipe_root.find('Ingredients').find('Data')
    for element in elements.findall('Grain'):
        recipe.listeFermentables.append(importBSMXFermentable(element))
    for element in elements.findall('Hops'):
        recipe.listeHops.append(importBSMXHop(element))
    for element in elements.findall('Yeast'):
        recipe.listeYeasts.append(importBSMXYeast(element))
    for element in elements.findall('Misc'):
        recipe.listeMiscs.append(importBSMXMisc(element))

    logger.debug("End parsing BSMX recipe")
    return recipe
Beispiel #24
0
def importDictRecipe(dic):
    logger.debug("Start parsing dict")

    recipe = Recipe()
    recipe.path = dic['path']
    recipe.name = dic['name']
    recipe.brewer = dic['brewer']
    recipe.style = dic['style']
    if dic['type'] == "All Grain":
        recipe.type = RECIPE_TYPE_ALL_GRAIN
    elif dic['type'] == "Extract":
        recipe.type = RECIPE_TYPE_EXTRACT
    elif recipe.type == "Partial Mash":
        recipe.type = RECIPE_TYPE_PARTIAL_MASH

    recipe.volume = dic['volume']
    recipe.boil = dic['boilTime']
    recipe.efficiency = dic['efficiency']

    for hop_dic in dic['hops']:
        hop = Hop()
        hop.name = hop_dic['name']

        if hop_dic['form'] == "Pellet":
            hop.form = HOP_FORM_PELLET
        elif hop_dic['form'] == "Leaf":
            hop.form = HOP_FORM_LEAF
        elif hop_dic['form'] == "Plug":
            hop.form = HOP_FORM_PLUG
        hop.alpha = hop_dic['alpha']
        hop.use = hop_dic['use']
        hop.time = hop_dic['time']
        hop.amount = hop_dic['amount']
        recipe.listeHops.append(hop)

    for f_dic in dic['fermentables']:
        f = Fermentable()
        f.name = f_dic['name']
        f.type = f_dic['type']
        f.fyield = f_dic['fyield']
        f.color = f_dic['color']
        f.amount = f_dic['amount']
        if f_dic['afterBoil'] == 'TRUE':
            f.useAfterBoil = True
        else:
            f.useAfterBoil = False
        f.recommendMash = f_dic['recoMash']
        recipe.listeFermentables.append(f)

    for y_dic in dic['yeasts']:
        y = Yeast()
        y.name = y_dic['name']
        y.productId = y_dic['product_id']
        y.labo = y_dic['labo']
        y.form = y_dic['form']
        y.attenuation = y_dic['attenuation']
        recipe.listeYeasts.append(y)

    for m_dic in dic['miscs']:
        m = Misc()
        m.name = m_dic['name']
        m.amount = m_dic['amount']
        m.type = m_dic['type']
        m.use = m_dic['use']
        m.time = m_dic['time']
        recipe.listeMiscs.append(m)

    mash_dic = dic['mashProfile']
    recipe.mash.name = mash_dic['name']
    recipe.mash.ph = mash_dic['ph']
    recipe.mash.spargeTemp = mash_dic['sparge']
    recipe.mash.tunTemp = mash_dic['tunTemp']

    for s_dic in mash_dic['steps']:
        s = MashStep()
        s.name = s_dic['name']
        s.time = s_dic['time']
        s.temp = s_dic['temp']
        s.type = s_dic['type']
        recipe.listeMashSteps.append(s)
    recipe.recipeNotes = dic['notes']

    return recipe
Beispiel #25
0
def importBeerXMLRecipe(data):
    logger.debug("Start parsing recipe")
    try:
        tree = ElementTree.parse(data)
    except TypeError:
        tree = data
    except IOError:
        tree = ElementTree.fromstring(data)
    except:
        raise

    recipe = Recipe()
    recipe.path = data

    presentation = tree.find('.//RECIPE')
    fermentables = tree.findall('.//FERMENTABLE')
    hops = tree.findall('.//HOP')
    levures = tree.findall('.//YEAST')
    misc = tree.findall('.//MISC')
    style = tree.find('.//STYLE')
    mash = tree.find('.//MASH')

    for element in presentation:
        if 'NAME' == element.tag:
            recipe.name = element.text
            logger.debug(" Recipe name: %s", recipe.name)
        if 'BREWER' == element.tag:
            recipe.brewer = element.text
            logger.debug(" Recipe brewer: %s", recipe.brewer)
        if 'TYPE' == element.tag:
            if "All Grain" == element.text:
                recipe.type = model.constants.RECIPE_TYPE_ALL_GRAIN
            elif "Partial Mash" == element.text:
                recipe.type = model.constants.RECIPE_TYPE_PARTIAL_MASH
            elif "Extract" == element.text:
                recipe.type = model.constants.RECIPE_TYPE_EXTRACT
            logger.debug(" Recipe type: %s", recipe.type)
        if "BATCH_SIZE" == element.tag:
            recipe.volume = float(element.text)
            logger.debug(" Recipe volume: %s", recipe.volume)
        if "EFFICIENCY" == element.tag:
            recipe.efficiency = float(element.text)
            logger.debug(" Recipe efficiency: %s", recipe.efficiency)
        if "BOIL_TIME" == element.tag:
            recipe.boil = float(element.text)
            logger.debug(" Recipe boil time: %s", recipe.boil)
        if "NOTES" == element.tag:
            recipe.recipeNotes = element.text
            logger.debug(" Recipe notes: %s", recipe.recipeNotes)
    try:
        for element in style:
            if "NAME" == element.tag:
                recipe.style = element.text
    except TypeError:
        recipe.style = ""

    try:
        recipe.mash = importBeerXMLMash(mash)
    except:
        pass

    for element in fermentables:
        recipe.listeFermentables.append(importBeerXMLFermentable(element))
    for element in hops:
        recipe.listeHops.append(importBeerXMLHop(element))
    for element in levures:
        recipe.listeYeasts.append(importBeerXMLYeast(element))
    for element in misc:
        recipe.listeMiscs.append(importBeerXMLMisc(element))

    logger.debug("End parsing recipe")
    return recipe
Beispiel #26
0
 def testServingsIsNegative(self):
     with self.assertRaises(Exception):
         Recipe("Lasagna", ['pasta', 'italian'], 1.0, 2.0,
                ['meat', 'noodles', 'sauce', 'cheese'],
                ['combine ingredients', 'cook ingredients'], -1)
Beispiel #27
0
 def testInstructionsIsNone(self):
     with self.assertRaises(Exception):
         Recipe("Lasagna", ['pasta', 'italian'], 1.0, 2.0,
                ['meat', 'noodles', 'sauce', 'cheese'], None, 2)
Beispiel #28
0
 def testInstructionsContainsNone(self):
     with self.assertRaises(Exception):
         Recipe("Lasagna", ['pasta', 'italian'], 1.0, 2.0,
                ['meat', 'noodles', 'sauce', 'cheese'],
                [None, 'combine ingredients', 'cook ingredients'], 2)
Beispiel #29
0
    def recommended_recipes(self, limit=10):
        cur = self.manager.get_cursor()

        cur.execute(
            """
            WITH user_commonality AS (
                SELECT
                    others_made.uid as uid,
                    COUNT(others_made.rid)::float / (
                        SELECT COUNT(rid)
                        FROM dates_made
                        WHERE uid = others_made.uid
                            OR uid = %s
                    ) AS percent_shared
                FROM dates_made AS personally_made
                JOIN dates_made
                    AS others_made
                    ON others_made.rid = personally_made.rid
                WHERE personally_made.uid = %s
                    AND others_made.uid != %s
                GROUP BY others_made.uid
            ),
            users_by_recipe AS (
                SELECT
                    uid,
                    rid,
                    LOG(COUNT(id)) + 1 as degree
                FROM dates_made
                GROUP BY uid, rid
            ),
            recipe_ownership AS (
                SELECT
                    recipes.rid,
                    SUM(LEAST(1.0, qtyowned / ownd_comp.amount)) / (
                        SELECT COUNT(iname)
                        FROM requires_ingredient
                        WHERE requires_ingredient.rid = recipes.rid
                    ) AS percent_owned
                FROM ingredient_ownership
                JOIN requires_ingredient
                    AS ownd_comp
                    ON ownd_comp.iname = ingredient_ownership.iname
                JOIN recipes
                    ON ownd_comp.rid = recipes.rid
                WHERE ingredient_ownership.uid = %s
                GROUP BY recipes.rid
            ),
            scores AS (
                SELECT
                    users_by_recipe.rid,
                    SUM(user_commonality.percent_shared * users_by_recipe.degree) as score,
                    SUM(percent_owned) AS percent_owned
                FROM users_by_recipe
                JOIN user_commonality ON users_by_recipe.uid = user_commonality.uid
                JOIN recipe_ownership ON users_by_recipe.rid = recipe_ownership.rid
                GROUP BY users_by_recipe.rid
            )
            SELECT
                recipes.*,
                users.*,
                percent_owned,
                (percent_owned/2 + 0.5) * score AS recommendation_degree
            FROM scores
            JOIN recipes ON recipes.rid = scores.rid
            JOIN users ON recipes.owner_id = users.uid
            ORDER BY recommendation_degree DESC;
        """, [self.uid] * 4)

        results = ((Recipe.new_from_combined_record(self.manager, record),
                    record[8], record[9]) for record in cur.fetchall())

        cur.close()
        return results
Beispiel #30
0
    def testCreateValidRecipe(self):
        result = Recipe("Lasagna", ['pasta', 'italian'], 1.0, 2.0,
                        ['meat', 'noodles', 'sauce', 'cheese'],
                        ['combine ingredients', 'cook ingredients'], 3)

        self.assertEqual("Lasagna", result.getName(), "checking name")
        self.assertEqual(2, len(result.getCategories()),
                         "checking number of categories")
        self.assertEqual("pasta",
                         result.getCategories()[0], "checking first category")
        self.assertEqual("italian",
                         result.getCategories()[1], "checking second category")

        self.assertEqual(4, len(result.getIngredients()),
                         "checking number of ingredients")
        self.assertEqual("meat",
                         result.getIngredients()[0],
                         "checking first ingredient")
        self.assertEqual("noodles",
                         result.getIngredients()[1],
                         "checking second ingredient")
        self.assertEqual("sauce",
                         result.getIngredients()[2],
                         "checking third ingredient")
        self.assertEqual("cheese",
                         result.getIngredients()[3],
                         "checking fourth ingredient")

        self.assertEqual(2, len(result.getInstructions()),
                         "checking number of instructions")
        self.assertEqual("combine ingredients",
                         result.getInstructions()[0],
                         "checking first instruction")
        self.assertEqual("cook ingredients",
                         result.getInstructions()[1],
                         "checking second instruction")

        self.assertEqual(1.0, result.getTimeToCook(), "checking time to cook")

        self.assertEqual(2.0, result.getTimeToPrep(), "checking time to prep")

        self.assertEqual(3, result.getServings(),
                         "checking number of servings")
Beispiel #31
0
def importBeerXMLRecipe(data):
    logger.debug("Start parsing recipe")
    try:
        tree = ElementTree.parse(data)
    except TypeError:
        tree = data
    except FileNotFoundError:
        tree = ElementTree.fromstring(data)
    except:
        raise

    recipe = Recipe()
    recipe.path = data

    presentation = tree.find('.//RECIPE')
    fermentables = tree.findall('.//FERMENTABLE')
    hops = tree.findall('.//HOP')
    levures = tree.findall('.//YEAST')
    misc = tree.findall('.//MISC')
    style = tree.find('.//STYLE')
    mash = tree.find('.//MASH')

    for element in presentation:
        if 'NAME' == element.tag:
            recipe.name = element.text
            logger.debug(" Recipe name: %s", recipe.name)
        if 'BREWER' == element.tag:
            recipe.brewer = element.text
            logger.debug(" Recipe brewer: %s", recipe.brewer)
        if 'TYPE' == element.tag:
            if "All Grain" == element.text:
                recipe.type = model.constants.RECIPE_TYPE_ALL_GRAIN
            elif "Partial Mash" == element.text:
                recipe.type = model.constants.RECIPE_TYPE_PARTIAL_MASH
            elif "Extract" == element.text:
                recipe.type = model.constants.RECIPE_TYPE_EXTRACT
            logger.debug(" Recipe type: %s", recipe.type)
        if "BATCH_SIZE" == element.tag:
            recipe.volume = float(element.text)
            logger.debug(" Recipe volume: %s", recipe.volume)
        if "EFFICIENCY" == element.tag:
            recipe.efficiency = float(element.text)
            logger.debug(" Recipe efficiency: %s", recipe.efficiency)
        if "BOIL_TIME" == element.tag:
            recipe.boil = float(element.text)
            logger.debug(" Recipe boil time: %s", recipe.boil)
        if "NOTES" == element.tag:
            recipe.recipeNotes = element.text
            logger.debug(" Recipe notes: %s", recipe.recipeNotes)
    try:
        for element in style:
            if "NAME" == element.tag:
                recipe.style = element.text
    except TypeError:
        recipe.style = ""

    try:
        recipe.mash = importBeerXMLMash(mash)
    except:
        pass

    for element in fermentables:
        recipe.listeFermentables.append(importBeerXMLFermentable(element))
    for element in hops:
        recipe.listeHops.append(importBeerXMLHop(element))
    for element in levures:
        recipe.listeYeasts.append(importBeerXMLYeast(element))
    for element in misc:
        recipe.listeMiscs.append(importBeerXMLMisc(element))

    logger.debug("End parsing recipe")
    return recipe
Beispiel #32
0
 def jsonRecipeLib(self, recipe):
     self.s = recipe
     self.recipe = Recipe.parse(recipe)
     data = self.recipe.export("json")
     data = data[1:-1]
     return data
Beispiel #33
0
recipe1 = Recipe(
    recipeID='135',
    authorID='sarah',
    name='Sweet Potato Soup',
    duration='45 minutes',
    picture='picture',
    difficulty='easy',
    style='boiling',
    country='chinese',
    course='dessert',
    ingredient={
        "ingredient": [{
            "name": "sweet potato",
            "amount": "400g"
        }, {
            "name": "slab sugar",
            "amount": "1 block"
        }, {
            "name": "ginger",
            "amount": "2 slices"
        }]
    },
    procedure={
        "procedure": [{
            "procedure": 1,
            "description": "Washed and peel sweet the potato"
        }, {
            "procedure":
            2,
            "description":
            "When you slice the sweet potatoes, cut it halfway then split the piece off (It brings out a better flavor)"
        }, {
            "procedure":
            3,
            "description":
            "Add ginger and sweet potatoes into boiled water. Turn the water to med heat. "
        }, {
            "procedure":
            4,
            "description":
            "Cook for 25 minutes until the sweet potatoes are softened. "
        }, {
            "procedure": 5,
            "description": "Add slab sugar. "
        }]
    })