add lot of recipes

.pre-commit-config.yaml

@@ -0,0 +1,54 @@
+repos:
+  # General
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.2.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-added-large-files
+  # Python
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v2.32.1
+    hooks:
+      - id: pyupgrade
+        args: ["--py310-plus"]
+  - repo: https://github.com/pycqa/isort
+    rev: 5.10.1
+    hooks:
+      - id: isort
+        name: isort (python)
+        args:
+          - --profile=black
+          - --line-length=120
+        # isort can't find local imports if the path of the local packages are not relative from the root of the repo.
+        # In this case, packages need to be added here
+        # - --known-local-folder=
+  - repo: https://github.com/psf/black
+    rev: 22.3.0
+    hooks:
+      - id: black-jupyter
+        args:
+          - --line-length=120
+          - --target-version=py310
+  - repo: https://github.com/PyCQA/flake8
+    rev: 4.0.1
+    hooks:
+      - id: flake8
+        additional_dependencies:
+          - flake8-bugbear
+          - flake8-implicit-str-concat
+          - flake8-annotations
+        args: ["--max-line-length=120", "--ignore=ANN204,ANN101,ANN102,ANN002,ANN003,E203,W503"]
+        # we ignore errors
+        # -ANN204: "Missing return type annotation for special method"
+        # -ANN101: "Missing type annotation for self in method"
+        # -ANN102 "Missing type annotation for cls in classmethod"
+        # -ANN002 "Missing type annotation for *args"
+        # -ANN003 "Missing type annotation for *kwargs"
+        # -W503 "Line break occurred before a binary operator" See https://www.flake8rules.com/rules/W503.html
+        # -E203:  whitespace before ':' because pep8 is wrong here. See https://github.com/psf/black/issues/315
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v2.6.2
+    hooks:
+      - id: prettier
+        args: ["--print-width=120"]

Readme.md

@@ -1,17 +1,16 @@
 # Remy
 
-
-
     “This is me. I think it's apparent that I need to rethink my life a little bit. What's my problem? First of all, I'm a rat. Which means life is hard. And second, I have a highly developed sense of taste and smell.”
     ―Remy
 
 This repo contains a list of French cooking recipes.
 
 # Presentation
+
 The goal is to have a single repo containing all recipes, in a format allowing any kind of scripting, automation, and human editing. To achieve this goal, recipes are coded in [cooklang](https://cooklang.org/)
 
-
 # TODO
-* miss pain burger
-* continue at "ile flottantes"
-* add star system
+
+- miss pain burger
+- continue at "ile flottantes"
+- add star system

add_recipe.py

@@ -1,26 +1,143 @@
-from pathlib import Path
 import argparse
+import re
+import time
+from pathlib import Path
 
-RECIPE_CATEGORIES = {
-    1: "entrées",
-    2: "plats",
-    3: "desserts"
-}
+from selenium import webdriver
 
-def main():
+RECIPE_CATEGORIES = {1: "entrées", 2: "plats", 3: "desserts"}
+
+CHROME_OPTIONS = ("--no-sandbox", "--headless", "--hide-scrollbars", "--disable-extensions", "--disable-infobars")
+
+GET_INGREDIENT_LIST_JS = """
+var xpath = "//div[text()='Ingrédients']";
+var e = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+var ingList = e.parentElement.parentElement.parentElement.children[2].children[0].children[0].children[0].children[1]
+return Array.from(ingList.children).map(c => c.innerText)
+"""
+
+GET_STEP_LIST_JS = """
+var xpath = "//h3[text()='Étape 1']";
+var e = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+var stepList = e.parentElement.parentElement.parentElement
+return Array.from(stepList.children).map(c => c.innerText)
+"""
+
+
+SPLIT_WORDS = [" de ", " d'"]
+
+UNSPLITABLE_WORDS = ["huile d'olive", "herbes de provence"]
+
+UNITS = [
+    "g",
+    "cl",
+]
+
+
+def process_marmiton(url: str) -> tuple[list[str], list[str]]:
+    options = webdriver.ChromeOptions()
+    for option in CHROME_OPTIONS:
+        options.add_argument(option)
+    driver = webdriver.Chrome(executable_path="chromedriver", chrome_options=options)
+    driver.get(url)
+    time.sleep(10)
+    ingredients = driver.execute_script(GET_INGREDIENT_LIST_JS)
+    steps = driver.execute_script(GET_STEP_LIST_JS)
+    ingredients = [re.sub(r"\xa0|\n", r" ", ingredient) for ingredient in ingredients]
+    steps = [re.sub(r"ÉTAPE \d+\n*", r"", step) for step in steps]
+    return ingredients, steps
+
+
+def process_ingredients(ingredients: list[str]) -> dict[str, str]:
+    """take a list of ingredient, human formatted, and transform them to cooklang format
+
+    Returns:
+        a dict with keys the name of the ingredient and value the cooklang definition
+    """
+    out = {}
+    for ingredient in ingredients:
+        # first clean the string
+        ingredient = ingredient.removeprefix("* ").strip().lower()
+        # sometime we got empty string. In this case do nothing
+        if not ingredient:
+            continue
+        # if the ingredient is a single word, then this is its cooklang def
+        if " " not in ingredient:
+            out[ingredient] = ingredient
+            continue
+        # if the first word start an number, then this is the quantity
+        ingredient_split = ingredient.split(" ")
+        if m := re.match(r"\d+", ingredient_split[0]):
+            # if the first word is the concat of a number and a word, then this word is the unit
+            if m.end() != len(ingredient_split[0]):
+                quantity_unit = f"{{{ingredient_split[0][:m.end()]}%{ingredient_split[0][m.end():]}}}"
+                ingredient_name = " ".join(ingredient_split[1:])
+            # if the second word is an unit, then we got to cooklang def
+            elif ingredient_split[1] in UNITS:
+                quantity_unit = f"{{{ingredient_split[0]}%{ingredient_split[1]}}}"
+                ingredient_name = " ".join(ingredient_split[2:])
+            else:
+                quantity_unit = f"{{{ingredient_split[0]}}}"
+                ingredient_name = " ".join(ingredient_split[1:])
+            # now check if ingredient name starts by "de" or d'...
+            # check if third word is "de" or "d'..."
+            ingredient_name = ingredient_name.removeprefix("de ")
+            ingredient_name = ingredient_name.removeprefix("d'")
+            out[ingredient_name] = f"@{ingredient_name}{quantity_unit}"
+            continue
+
+        # if the ingredient contains unsplitable words, then this words are the ingredient name
+        valid_unsplitable_word = [
+            unsplitable_word for unsplitable_word in UNSPLITABLE_WORDS if unsplitable_word in ingredient
+        ]
+        if valid_unsplitable_word:
+            unsplitable_word = valid_unsplitable_word[0]
+            ingredient_name = unsplitable_word
+            ingredient_quantity_and_units = " ".join(ingredient.split(unsplitable_word)).strip()
+            out[ingredient_name] = f"@{ingredient_name}{{{ingredient_quantity_and_units}}}"
+            continue
+
+        # If the ingredient contains a split word, then text before are quantity and units, and
+        # text after is ingredient name
+        valid_split_word = [split_word for split_word in SPLIT_WORDS if split_word in ingredient]
+        if valid_split_word:
+            split_word = valid_split_word[0]
+            splitted_ingredient = ingredient.split(split_word)
+            ingredient_quantity_and_units = splitted_ingredient[0]
+            ingredient_name = split_word.join(splitted_ingredient[1:])
+            out[ingredient_name] = f"@{ingredient_name}{{{ingredient_quantity_and_units}}}"
+            continue
+        out[ingredient] = f"@{ingredient}"
+    return out
+
+
+def process_steps(steps: list[str], ingredient_mapping: dict) -> str:
+    processed_ingredients = []
+    add_to_file = "\n"
+    for step in steps:
+        step = step.strip().removeprefix("* ").strip()
+        if not step:
+            continue
+        for ingredient in ingredient_mapping.keys():
+            if ingredient in step and ingredient not in processed_ingredients:
+                step = step.replace(ingredient, ingredient_mapping[ingredient])
+                processed_ingredients.append(ingredient)
+
+        add_to_file += step + "\n"
+
+    add_to_file += "\n".join(v for k, v in ingredient_mapping.items() if k not in processed_ingredients)
+    return add_to_file
+
+
+def main() -> None:
     parser = argparse.ArgumentParser("create a new recipe")
     parser.add_argument("--name", type=str, help="name of the recipe")
-    parser.add_argument("--kind", type=int , help="1: entrées, 2: plats, 3: desserts", required=True)
-    parser.add_argument("--source", type=str , help="source of the recipe (website, book...)")
+    parser.add_argument("--kind", type=int, help="1: entrées, 2: plats, 3: desserts", required=True)
+    parser.add_argument("--source", type=str, help="source of the recipe (website, book...)")
     parser.add_argument("--time", type=str, help="estimated time to prepare the meal")
     args = parser.parse_args()
 
-    metadata = {
-        "title": args.name,
-        "time": args.time,
-        "servings": 6,
-        "source": args.source
-    }
+    metadata = {"title": args.name, "time": args.time, "servings": 6, "source": args.source}
 
     for k, v in metadata.items():
         if v is None:
@@ -33,6 +150,13 @@ def main():
         for k, v in metadata.items():
             f.write(f">> {k}: {v}\n")
 
+    if metadata["source"].startswith("https://www.marmiton.org/"):
+        ingredients, steps = process_marmiton(metadata["source"])
+        map_ingredient_to_cooklang = process_ingredients(ingredients)
+        add_to_file = process_steps(steps, map_ingredient_to_cooklang)
+        with cooklang_file_path.open("a") as f:
+            f.write(add_to_file)
+
 
 if __name__ == "__main__":
-    main()
+    main()

process_recipe.ipynb

@@ -2,199 +2,64 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import re \n",
-    "\n",
-    "split_words = [\n",
-    "    \" de \",\n",
-    "    \" d'\"\n",
-    "]\n",
-    "\n",
-    "unsplitable_words = [\n",
-    "    \"huile d'olive\",\n",
-    "    \"herbes de provence\"\n",
-    "]\n",
-    "\n",
-    "prefix = \"* \"\n",
-    "\n",
-    "units = [\n",
-    "    \"g\",\n",
-    "    'cl',\n",
-    "]\n",
-    "\n",
-    "def p_u_word(ingredient: str):\n",
-    "    ingredient = ingredient.lower()\n",
-    "    for unsplitable_word in unsplitable_words:\n",
-    "        if unsplitable_word in ingredient.lower():\n",
-    "            si = \" \".join(ingredient.split(unsplitable_word)).strip()\n",
-    "            if not si:\n",
-    "                return f\"@{unsplitable_word}{{}}\"\n",
-    "    return \"\"\n",
-    "\n",
-    "def p_single_word(ingredient: str) -> str:\n",
-    "    if not \" \" in ingredient:\n",
-    "        return f\"@{ingredient}\"\n",
-    "    return \"\"\n",
-    "\n",
-    "def p_s_word(ingredient: str):\n",
-    "    for word in split_words:\n",
-    "        if word in ingredient:\n",
-    "            split_ingredients = ingredient.split(word)\n",
-    "            ingredient_name = word.join(split_ingredients[1:]).strip()\n",
-    "            ingredient_q_u = split_ingredients[0].strip()\n",
-    "            formated_q_u = p_q_u(ingredient_q_u)\n",
-    "            return f\"@{ingredient_name}{formated_q_u}\"\n",
-    "    return \"\"\n",
-    "\n",
-    "def p_q_u(q_u: str):\n",
-    "    \"\"\"process quantity and unit\n",
-    "    \"\"\"\n",
-    "    q_u_split = q_u.split(\" \")\n",
-    "    if len(q_u_split) == 1:\n",
-    "        return f\"{{{q_u}}}\"\n",
-    "    q = q_u_split[0]\n",
-    "    u = \" \".join(q_u_split[1:])\n",
-    "    return f\"{{{q}%{u}}}\"\n",
-    "\n",
-    "def p_start_int(ingredient: str) -> str:\n",
-    "    i_split = ingredient.split(\" \")\n",
-    "    if re.match(r\"\\d+\", i_split[0]):\n",
-    "        if i_split[1] in units:\n",
-    "            ingred = \" \".join(i_split[2:])\n",
-    "            return f\"@{ingred}{{{i_split[0]}%{i_split[1]}}}\"\n",
-    "        ingred = \" \".join(i_split[1:])\n",
-    "        return f\"@{ingred}{{{i_split[0]}}}\"\n",
-    "    return \"\"\n",
-    "\n",
-    "def process_ingredients(ingredients: str) -> str:\n",
-    "    out = \"\"\n",
-    "    for ingredient in ingredients.split(\"\\n\"):\n",
-    "        ingredient = ingredient.removeprefix(prefix).strip().lower()\n",
-    "        if not ingredient:\n",
-    "            continue\n",
-    "        if t := p_single_word(ingredient):\n",
-    "            out += t + \"\\n\"\n",
-    "            continue\n",
-    "        if t := p_u_word(ingredient):\n",
-    "            out += t + \"\\n\"\n",
-    "            continue\n",
-    "        if t := p_s_word(ingredient):\n",
-    "            out += t + \"\\n\"\n",
-    "            continue\n",
-    "        if t := p_start_int(ingredient):\n",
-    "            out += t + \"\\n\"\n",
-    "            continue\n",
-    "        out += f\"@{ingredient}{{}}\\n\"\n",
-    "    return out"
+    "from add_recipe import process_ingredients, process_steps"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
-    "ingredients=\"\"\"\n",
-    "* 1 yaourt et son pot vide\n",
-    "* 1.5 pot  de sucre en poudre\n",
-    "* 3 pots de farine\n",
-    "* 1/2 pot d'huile d'arachide\n",
-    "* 3 œufs entiers\n",
-    "* 1/2 sachet de levure\n",
-    "* 1 pincée de sel\n",
-    "* Un peu de beurre pour le moule ou du papier sulfurisé\n",
-    "\"\"\"\n",
+    "ingredients = \"\"\"\n",
+    "* 1 pâte sablée avec 200g de farine, 100g de beurre, 60g de sucre en poudre, une pincée de sel, eau.\n",
+    "* 800g de pommes\n",
+    "* 2 œufs\n",
+    "* 100g de crème fraîche ou de fromage blanc\n",
+    "* 50g de sucre en poudre\n",
+    "\n",
+    "\"\"\"\n",
+    "i = process_ingredients(ingredients.split(\"\\n\"))\n",
+    "\n",
+    "preparation = \"\"\"\n",
+    "* Préchauffer le four à 210°C (Th 6, 7)\n",
+    "* Etaler la pâte au fond d'un plat à tarte préalablement beurré. Piquer le fond avec une fourchette. Badigeonner le tour avec un peu de lait ou d'œuf battu pour qu'il dore un peu et faire cuire à blanc 10mn environ à four chaud (Th -, 180°C).\n",
+    "* Peler et épépiner les pommes. Les couper en lamelles assez épaisses et les ranger sur la pâte en les faisant légèrement se chevaucher.\n",
+    "* Dans un plat creux, battre les œufs en omelette. Ajouter le sucre, le fromage blanc ou la crème fraîche. Verser sur les pommes et parsemer d'amandes effilées.\n",
+    "* Mettre à cuire à four chaud pendant 25 minutes.\n",
     "\n",
-    "protocol = \"\"\"\n",
-    "* Préchauffer le four à 180° (th 6).\n",
-    "* Vider le yaourt dans un plat creux. Laver le pot et l'essuyer. Verser le sucre, l'huile et le sel dans le plat. Ajouter la farine et la levure puis les œufs entiers. Bien mélanger.\n",
-    "* Beurrer le moule (rond ou à cake) ou le papier de cuisson disposé dans le moule. Y verser la pâte et faire cuire au four pendant 45mn.\n",
     "\"\"\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'yaourt et son pot vide': '@yaourt et son pot vide{1}',\n",
-       " 'sucre en poudre': '@sucre en poudre{1.5%pot}',\n",
-       " 'farine': '@farine{3%pots}',\n",
-       " \"huile d'arachide\": \"@huile d'arachide{1/2%pot}\",\n",
-       " 'œufs entiers': '@œufs entiers{3}',\n",
-       " 'levure': '@levure{1/2%sachet}',\n",
-       " 'sel': '@sel{1%pincée}',\n",
-       " 'beurre pour le moule ou du papier sulfurisé': '@beurre pour le moule ou du papier sulfurisé{un%peu}'}"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "out = process_ingredients(ingredients)\n",
-    "map_ingredient_to_cooklang = {\n",
-    "    l[1:].split(\"{\")[0]: l for l in out.splitlines()\n",
-    "}\n",
-    "map_ingredient_to_cooklang"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Préchauffer le four à 180° (th 6).\n",
-      "Vider le yaourt dans un plat creux. Laver le pot et l'essuyer. Verser le sucre, l'huile et le @sel{1%pincée} dans le plat. Ajouter la @farine{3%pots} et la @levure{1/2%sachet} puis les @œufs entiers{3}. Bien mélanger.\n",
-      "Beurrer le moule (rond ou à cake) ou le papier de cuisson disposé dans le moule. Y verser la pâte et faire cuire au four pendant 45mn.\n",
-      "@yaourt et son pot vide{1}\n",
-      "@sucre en poudre{1.5%pot}\n",
-      "@huile d'arachide{1/2%pot}\n",
-      "@beurre pour le moule ou du papier sulfurisé{un%peu}\n"
+      "\n",
+      "Préchauffer le four à 210°C (Th 6, 7)\n",
+      "Etaler la pâte au fond d'un plat à tarte préalablement beurré. Piquer le fond avec une fourchette. Badigeonner le tour avec un peu de lait ou d'œuf battu pour qu'il dore un peu et faire cuire à blanc 10mn environ à four chaud (Th -, 180°C).\n",
+      "Peler et épépiner les @pommes{800%g}. Les couper en lamelles assez épaisses et les ranger sur la pâte en les faisant légèrement se chevaucher.\n",
+      "Dans un plat creux, battre les @œufs{2} en omelette. Ajouter le sucre, le fromage blanc ou la crème fraîche. Verser sur les pommes et parsemer d'amandes effilées.\n",
+      "Mettre à cuire à four chaud pendant 25 minutes.\n",
+      "@pâte sablée avec 200g de farine, 100g de beurre, 60g de sucre en poudre, une pincée de sel, eau.{1}\n",
+      "@crème fraîche ou de fromage blanc{100%g}\n",
+      "@sucre en poudre{50%g}\n"
      ]
     }
    ],
    "source": [
-    "processed_ingredients = []\n",
-    "for step in protocol.split(\"\\n\"):\n",
-    "    step = step.strip().removeprefix(\"* \")\n",
-    "    if not step:\n",
-    "        continue\n",
-    "    for ingredient in map_ingredient_to_cooklang.keys():\n",
-    "        if ingredient.lower() in step and ingredient not in processed_ingredients:\n",
-    "            step = step.replace(ingredient, map_ingredient_to_cooklang[ingredient])\n",
-    "            processed_ingredients.append(ingredient)\n",
-    "\n",
-    "    print(step)\n",
-    "\n",
-    "print(\"\\n\".join(v for k,v in map_ingredient_to_cooklang.items() if k not in processed_ingredients))\n"
+    "print(process_steps(preparation.split(\"\\n\"), i))"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": null,

recipes/desserts/Crumble_pommes.cook

@@ -0,0 +1,15 @@
+>> title: Crumble pommes
+>> time: 30m
+>> servings: 6
+>> source:
+
+Préchauffer le four à 180° C (th6).
+Eplucher les @belles pommes{6-7}, les couper en morceaux et les répartir dans un plat légèrement beurré. (On peut ici les soupoudrer de @cannelle{1%c} et de @sucre vanillé{1%sachet})
+Préparer la pâte en mélangeant du bout des doigts la @farine{150%g}, le @sucre{75%g} et le @beurre{75%g}, jusqu'à obtention d'une sableuse.
+Saupoudrer la pâte sur les pommes. Tasser légèrement avec les doigts.
+Mettre au four et laisser cuire 40 mn environ jusqu'à ce que le dessus soit bien caramélisé.
+
+>> steps: Remarques
+on peut réaliser une variante avec des @poires, des @framboises (5 pommes et 100 à 200g de framboises surgelées ou non), des @kiwis (6 pommes - 6 kiwi).
+Servir avec un peu de @fromage blanc{} ou une boule de @glace à la vanille{}.
+On peut ajouter à la pâte des @noix ou des @noisettes concassées ou encore des petits morceaux de @chocolats ou des pépites (à ajouter juste avant de répartir la pâte sur les fruits).

recipes/desserts/Gateau_yaourt.cook

@@ -1,7 +1,7 @@
 >> title: Gateau yaourt
 >> time: 45m
 >> servings: 6
->> source: 
+>> source:
 
 
 Préchauffer le four à 180° (th 6).
@@ -15,4 +15,3 @@ Ajouter à la pâte des @pommes{2} coupées en petits morceaux ou encore des @p
 On peut réaliser un gâteau zébré en versant dans le moule la moitié de la pâte, puis la seconde moitié après y avoir rajouté un peu de @chocolat en  poudre{3%c à soupe environ}.
 On peut réaliser ce gâteau avec un yaourt aux fruits et en y ajoutant des petits morceaux de fruits (ananas par exemple ou cerises dénoyautées).
 Remplacer un pot de farine de blé par de la farine de blé noir ou sarrasin.
-

recipes/desserts/Moelleux_au_chocolat.cook

@@ -0,0 +1,10 @@
+>> title: Moelleux au chocolat
+>> time: 20m
+>> servings: 6
+>> source:
+
+Préchauffer le four thermostat 6 (180°).
+Casser les @œufs{4} en séparant les blancs des jaunes. Faire fondre le @beurre{80%g} avec le @chocolat noir à pâtissier{200%g} dans une casserole ou au micro-onde. Ajouter le @sucre en poudre{120%g} puis la @farine{4%cuillères à soupe (~50g)} et les jaunes d'œuf. Bien mélanger.
+Battre les blancs en neige avec une @pincée de sel{1}. Les ajouter délicatement au mélange en soulevant la pâte.
+Verser la pâte dans un moule préalablement beurré. Enfourner au bain marie pour 30 à 40mn. Vérifier la cuisson sur les 10 dernières minutes en piquant la pointe d'un couteau dans le moelleux. Celle-ci doit ressortir encore humide.
+Sortir le moelleux et le démouler. Le laisser tiédir avant de servir.

recipes/desserts/Moelleux_chocolat_coeur_framboises.cook

@@ -0,0 +1,15 @@
+>> title: Moelleux chocolat coeur framboises
+>> time: 30m
+>> servings: 6
+>> source: https://cuisine.journaldesfemmes.fr/recette/307942-moelleux-au-chocolat-coeur-coulant-aux-framboises
+
+>> steps: Coulis
+Dans une casserole, mettre les @framboises{5%cuillères à soupe} et le @sucre en poudre{40%g ou 2 cuillères à soupe}. Faire chauffer jusqu'à ébullition, il faut que ça devienne une purée épaisse. Laisser refroidir puis passer à travers un chinois pour ôter les petits pépins en appuyant bien avec le dos d'une cuillère. Reserver le coulis au frais.
+
+>> steps: Fondant
+Mettre le four à préchauffer à 180°C (thermostat 6). Séparer les blancs des jaunes d'@oeuf{3}. Mélanger les jaunes avec le @sucre{40%g} jusqu'à ce que le mélange blanchisse. Ajouter ensuite la @farine{25%g}, bien remuer, la pâte doit être lisse et sans grumeaux.
+Dans un petit saladier, casser le @chocolat noir à pâtisser{120%g} et y ajouter le @beurre{80%g} puis faire fondre le tout soit au micro-onde, soit au bain-marie puis ajouter à la pâte. Bien mélanger de nouveau.
+Monter les 3 blancs en neige bien ferme avec une @pincée de sel{1}. Incorporer doucement à la pâte au chocolat. A ce stade, on obtient une mousse au chocolat classique.
+Beurrer 6 petits ramequins et les remplir à moitié de la préparation, poser 4 framboises au centre et recouvrir de mousse au chocolat jusqu'aux 2/3 du ramequin. Mettre au four 8 minutes environ.
+Sortir du four, attendre 1 minute puis démouler sur une assiette de présentation, faire un cordon de coulis tout autour puis poser une ou deux framboises avec une feuille de menthe. Pour décorer, on peut saupoudrer de sucre glace à travers une petite passoire en la tapotant.
+s

recipes/desserts/Mousse_au_chocolat.cook

@@ -0,0 +1,10 @@
+>> title: Mousse au chocolat
+>> time: 30m
+>> servings: 6
+>> source:
+
+faire fondre le @chocolat noir{100%g}
+separer le blanc des jaunes d'@oeuf{3}
+incorporer jaunes et @sucre vanillé{1%sachet} au chocolat fondu
+batter les blancs en neige et ajouter délicatement au mélange
+laisser au frais au moins 2 h

recipes/desserts/Panacota.cook

@@ -0,0 +1,19 @@
+>> title: Panacota
+>> time:
+>> servings: 6
+>> source: https://www.atelierdeschefs.fr/fr/recette/8442-panna-cotta-au-chocolat-blanc-coulis-de-framboise-crumble-pistache.php?utm_campaign=NL_AUTO_POST_COURS_LB_RECETTES_SANS_TEMPLATE&utm_source=NL_AUTO_CLIENT_ATELIER&utm_medium=EMAIL_ADC
+
+
+>> steps: Panacota
+Mettre les @feuilles de gélatine{2} à ramollir dans de l'eau froide.
+Porter la @crème liquide entière{50%cl} à ébullition avec le @sucre en poudre{70%g}, puis la retirer du feu, ajouter le @chocolat blanc{150%g} et bien mélanger pour le faire fondre. Ajouter la gélatine après l'avoir bien égouttée, la dissoudre tout en mélangeant à l'aide d'une spatule. Passer ensuite l'appareil ainsi obtenu à travers un chinois fin. Dresser la panna cotta dans des verrines et laisser refroidir 2 h au frigo.
+
+>> steps: Crumble
+Préchauffer le four à 200 °C (th. 7-8)
+
+Réunir dans un bol la @poudre amande{50%g}, le @sucre en poudre{100%g}, la @poudre de pistache{50%g}, la @farine{100%g} et le @beurre doux{100%g} et les mélanger du bout des doigts pour obtenir un sable grossier. Étaler ensuite la préparation sur une feuille de papier cuisson et l'enfourner pendant 10 min.
+Laisser ensuite refroidir sur la plaque.
+
+>> steps: Coulis de framboise
+Mixer les @framboises{125%g} avec l'@eau{5%cl}, puis réserver au frais.
+Verser le coulis framboise sur les panna cotta et terminer avec le crumble.

recipes/desserts/Roses_des_sables_au_chocoloat.cook

@@ -0,0 +1,11 @@
+>> title: Roses des sables au chocoloat
+>> time: 30m
+>> servings: 6
+>> source:
+
+Faire fondre le @chocolat noir à pâtisserie{120%g} avec le @beurre{80%g} très doucement, en remuant bien.
+Hors du feu, ajouter le @sucre glace{50%g} et bien remuer.
+Verser les @corn flakes{150%g} dans la casserole et mélanger délicatement sans les écraser.
+Garnir la tôle du four de papier sulfurisé et y faire des petits tas à l'aide de 2 c à soupe (ou d'une cuillère à glace).
+Laisser refroidir à température ambiante 1h avant de déguster les roses des sables.
+Ne pas mettre au réfrigérateur, le chocolat perdrait son brillant.

recipes/desserts/Tarte_aux_citrons.cook

@@ -0,0 +1,20 @@
+>> title: Tarte aux citrons
+>> time: 60m
+>> servings: 6
+>> source:
+
+>> steps: Pâte sablée
+Préchauffer le four à 180
+mélanger les jaunes d'œuf{2} et le @sucre{70%g} au fouet pour détendez le mélange avec l'@eau{5%cl}
+Dans un saladier mélanger la @farine{250%g}, une pincée de sel et le @beurre{125%g} coupé en petit morceaux avec les mains de manière à obtenir une consistance sableuse
+Verser le mélange œuf-sucre au milieu de ce sable, former une boule homogène
+étaler la pâte et faire cuire à blanc 20 à 25 minutes. puis baiser la température du four a 120-150
+
+>> steps: Crème
+Prélever jus et zeste de @citron{3 ou 4}, mettre le tout dans une casserole. Verser le @sucre{150%g} et la @Maïzena{1%cuillère à soupe}, remuer et laisser chauffer a feu doux.
+Dans un bol, battez les @œufs{3} puis ajoutez les dans la casserole sans cesser de remuer. Augmenter la puissance du feu : le mélange vas s'épaissir
+Ôter la casserole et verser la préparation sur le fond de tarte cuit et refroidi
+
+>> steps: Meringue
+montez les @blancs d'oeuf{2} en neige avec une pincée de sel. Ajouter le @sucre{100%g} et la @levure{1/2%cuillère à soupe}. Fouettez jusqu'à ce que la neige soit bien ferme
+10 minutes au four

recipes/desserts/meringue.cook

@@ -0,0 +1,18 @@
+>> title: meringue
+>> time: 60m
+>> servings: 6
+>> source: https://www.marmiton.org/recettes/recette_meringue-pour-les-nuls_36610.aspx
+
+Quelques trucs pour bien réussir ces meringues : sortir les oeufs du réfrigérateur un quart d'heure avant de les utiliser.
+Ne surtout pas mélanger de jaunes aux @blancs d'oeuf{4}.
+Ajouter une pincée de sel avant de battre les blancs en neige.
+Utiliser un récipient plus haut que large et utiliser un batteur électrique (bien plus rapide et moins fatiguant)! On peut commencer :
+Battre les blancs d'oeuf en neige ferme.
+Ajouter le sucre par petites quantités tout en continuant de battre.
+Préchauffer le four à 120°C (thermostat 4).
+Déposer immédiatement de petits tas de meringue sur une plaque de four préalablement recouverte de papier sulfurisé.
+Cuire entre 30 minutes et 1 heure à 120°C.
+Au bout de 30 minutes, on obtient des meringues blanches et moelleuses.
+Au bout d'1 heure, on obtient des meringues rosées, craquantes et fondantes avec un coeur moelleux.
+Une fois cuites, décoller les meringues délicatement dès la sortie du four et laisser refroidir sur une grille.
+@sucre semoule{250%g}

recipes/desserts/pain_d'épice.cook

@@ -0,0 +1,12 @@
+>> title: pain d'épice
+>> time: 60m
+>> servings: 6
+>> source: 
+
+
+Préchauffer le four à 150 °C (Th 5).
+Mélanger la @farine{250%g} avec la @levure chimique{1/2%sachet}, le @sucre roux (cassonade) ou normal{50%g}, le @sucre vanillé{1%sachet} et les @épices{1 cuillère à café de cannelle, 1 cuillère à café de muscade, 1 cuillère à café de mélange 4 épices pour pain d'épices}.
+Faire tiédir le @miel{150%g} au micro-ondes ainsi que le @lait{100%ml} et les ajouter à la farine.
+Casser les @œufs{2} dans un bol et les battre légèrement avec une fourchette avant de les incorporer à la préparation.
+Verser la préparation dans un moule à cake préalablement beurré et fariné.
+Enfourner et laisser cuire pendant environ 45 mn. Démouler le pain d'épices lorsqu'il a totalement refroidi. Il est meilleur le lendemain.

recipes/desserts/pancake.cook

@@ -0,0 +1,9 @@
+>> title: pancake
+>> time: 20m
+>> servings: 6
+>> source:
+
+
+Mélanger les @yaourts{2}, la @farine{150%g}, les @œufs{2}, le @sucre vanillé{un sachet}, la @levure chimique{un demi sachet} et le @sel{une pincée}
+Mettre du beurre dans la poêle.
+Verser un peu de pâte pour former une petite galette. Dès que les bulles se forment à la surface retourner le pancake.

recipes/desserts/tarte_pomme_normande.cook

@@ -0,0 +1,10 @@
+>> title: tarte pomme normande
+>> time: 30m
+>> servings: 6
+>> source:
+
+Préchauffer le four à 210°C (Th 6, 7)
+Etaler la pâte sablée (@farine{200%g}, @beurre{100%g}, @sucre{100%g}, @sel{une pincée}, @eau{}) au fond d'un plat à tarte préalablement beurré. Piquer le fond avec une fourchette. Badigeonner le tour avec un peu de lait ou d'œuf battu pour qu'il dore un peu et faire cuire à blanc 10mn environ à four chaud (180°C).
+Peler et épépiner les @pommes{800%g}. Les couper en lamelles assez épaisses et les ranger sur la pâte en les faisant légèrement se chevaucher.
+Dans un plat creux, battre les @œufs{2} en omelette. Ajouter le @sucre en poudre{50%g}, la @crème fraîche ou le fromage blanc{100%g}. Verser sur les pommes et parsemer d'amandes effilées.
+Mettre à cuire à four chaud pendant 25 minutes.

recipes/desserts/Îles_flottantes.cook

@@ -0,0 +1,23 @@
+>> title: Îles flottantes
+>> time: 55m
+>> servings: 6
+>> source: https://www.marmiton.org/recettes/recette_iles-flottantes_22034.aspx
+
+>> steps: Crème
+faire bouillir le @lait{60%cl} avec la @gousse de vanille{1} fendue dans la longueur et en ayant préalablement gratté la gousse.
+laisser infuser la préparation 5 minutes, puis retirer la gousse.
+séparer les jaunes d'@oeufs{4} et les battre avec le @sucre en poudre{80%g}.
+ajouter le lait chaud puis remettre sur feu doux pour faire épaissir le mélange. agiter sans arrêt avec une cuillère en bois et sans faire bouillir la crème. la crème est prise lorsque la mousse blanche en surface disparaît.
+mettre au réfrigérateur une fois la préparation refroidie.
+
+>> steps: Îles
+dans une grande casserole, mettre 2 l d'eau à bouillir.
+monter les blancs en neige avec une @pincée de sel{1} et ajouter doucement @sucre en poudre{30%g}.
+former des boules de blancs d'oeuf avec deux cuillères à soupe et les faire cuire toutes les faces dans de l'eau bouillante.
+compter 1 min et égoutter sur papier absorbant.
+
+
+>> steps: déco
+dorer les @amandes effilées{30%g} à la poêle.
+faire un caramel blond avec le @sucre en morceaux{60%g}, un filet de @citron{1⁄2} et 2 cuillères à soupe d'eau.
+mettre la crème dans un plat creux. y déposer les blancs puis décorer avec des filets de caramel et un peu d'amandes.

recipes/plats/Brouillade_à_la_tomate.cook

@@ -0,0 +1,13 @@
+>> title: Brouillade à la tomate
+>> time: 30m
+>> servings: 6
+>> source:
+
+Laver les @tomates bien mures{4} et les mettre 2mn au micro-onde (ou dans une casserole d'eau bouillante) avant de les peler. Les couper en morceaux et les mixer au robot.
+Mettre un peu @huile d'olive{1%cuillère à soupe} au fond d'une poêle. Y déposer les tomates et ajouter un morceau de @sucre{1%cuillère à soupe}. Saler et porter à ébullition à feu vif. Couvrir et faire cuire 15mn.
+Battre les @œufs{6} entiers, les saler et les poivrer puis les ajouter aux tomates. Faire cuire à feu très doux en remuant constamment.
+Déguster sur des toasts.
+
+>> steps: Remarques
+Ajouter un petit @oignon (haché finement et précuit 3mn) ou encore une gousse d'@ail hachés (en cours de cuisson) ainsi qu'un peu de @persil haché (en fin de cuisson).
+Servir avec quelques @croûtons de pain grillés et frottés légèrement à l'ail{}.

recipes/plats/Curry_de_fenouil.cook

@@ -8,4 +8,4 @@ Préparer le jus d'un 1/2 @citron
 Dans une #sauteuse, faire chauffer un filet d'@huile d'olive{}. Mettre le fenouil, assaisonner avec le @sel et le @poivre. Ajouter le verre d'@eau{1%verre}. Couvrir et faire cuire à feu moyen durant ~{15%min}. Remuer de temps en temps.
 Dans un bol, mettre la cuillère de @pâte de curry{1%cuillère à café} et la @crème fraîche (ou un yaourt nature pour une version allégée){2%cuillères à soupe}. Bien mélanger.
 Quand les fenouils sont cuits, ajouter le jus de citron. Remuer.
-Ajouter la préparation curry/crème (ou yaourt)aux fenouils.
+Ajouter la préparation curry/crème (ou yaourt)aux fenouils.

recipes/plats/Lasagne_au_saumon_et_epinards.cook

@@ -8,4 +8,4 @@ Préchauffer le four (210°C).
 Faire décongeler les @épinards{500%g} suffisamment longtemps à l'avance. Préchauffer le four (210°C).
 Mettre un peu de @beurre dans un #plat rectangulaire ou carré allant au four{}, puis une couche de @lasagnes précuites{1%boite}, une couche de @saumon fumé{300%g}, une couche d'épinards et un peu de @parmesan. Recommencer l'opération jusqu'à la fin des ingrédients.
 Verser la @crème liquide{50%cl} préalablement salée et poivrée.
-Remettre un peu de parmesan puis cuire à four chaud pendant ~{25%min}.
+Remettre un peu de parmesan puis cuire à four chaud pendant ~{25%min}.

recipes/plats/Lasagne_vegetariennes.cook

@@ -11,4 +11,4 @@ Ajoutez le @coulis de tomate{100%g}, le @sucre en poudre{1%cuillère à café} e
 Laissez mijoter l'ensemble, ~{20%min} environ, à feu moyen.
 Une fois le mélange prêt, procédez à l'empilement dans un grand plat : 1 couche de @pates à lasagnes{}, 1 couche de préparation, 1 couche de @béchamel{25%cl}, 1 couche de @gruyère rapé{200%g}, et ainsi de suite (en rajoutant un peu de sel à chaque fois), en mettant beaucoup de gruyère sur la dernière couche.
 Faites cuire à four chaud (thermostat 7-200°C), ~{35%minutes}
-Servez, lorsque c'est bien gratiné.
+Servez, lorsque c'est bien gratiné.

recipes/plats/Quiche_à_la_tomate.cook

@@ -1,7 +1,7 @@
 >> title: Quiche à la tomate
 >> time: 45m
 >> servings: 6
->> source: 
+>> source:
 
 Préchauffer le four à 210°(th 6-7)
 Préparer la pâte brisée en melangeant la @farine{200%g} et le @beurre{100%g} avec un peu de @sel. Ajouter un peu d'eau

recipes/plats/Tarte_thon_tomate.cook

@@ -8,4 +8,3 @@ Etaler la @pâte brisée{1} et la piquer avec une fourchette.
 Emietter le @thon{150%g (1 petite boite)} sur la pâte.
 Mélanger dans un gros bol : la @crème épaisse{20%cl}, le @concentré de tomates{1%petite boîte}, l'@oeuf{1} et le @sel; verser la préparation sur le thon.
 Saupoudrer d'@herbes de provence{}, recouvrir de @fromage râpé{50%g}, puis faire cuire 25 min (selon puissance du four).
-

recipes/plats/cake_olives.cook

@@ -4,11 +4,11 @@
 
 
 Préchauffer le four à 180°C (Th 6)
-Dans un saladier, mélanger le @yaourt{1}, la @farine{150%g (environ 3 pots de yaourt)}, la @levure{1/2%sachet} et les @œufs{3}. 
-Ajouter l'@huile d'olive{1/2%pot (environ 50 ml)}. Bien mélanger. 
+Dans un saladier, mélanger le @yaourt{1}, la @farine{150%g (environ 3 pots de yaourt)}, la @levure{1/2%sachet} et les @œufs{3}.
+Ajouter l'@huile d'olive{1/2%pot (environ 50 ml)}. Bien mélanger.
 Ajouter le @gruyère râpé{100%g}, le @basilic et les @olives{Environ 20 dénoyautées de chaque couleur (noires, vertes)} coupées en petits morceaux.
 Verser dans un #moule à cake{} préalablement beurré et fariné. Cuire ~{40%minutes} au four à 180° C (thermostat 6).
 Retirer le cake du four quand il est doré. Le servir tiède ou froid.
 
->> steps: Facultatif 
+>> steps: Facultatif
 Incorporer éventuellement le @jambon{100%g} (coupé en dés), les @tomates séchées{40%g} et le @fromage de chèvre{100%g}.

recipes/plats/cheese_naan.cook

@@ -7,4 +7,4 @@ Mélanger la @farine{300%g} avec le @sel{1%pincée}, la @levure{1/2%sachet}, l'@
 Travailler la pâte et ajouter si besoin un peu d'eau tiède afin d'obtenir une pâte molle. Laisser reposer ~{10%minutes}.
 Séparer la pâte en 6 parts que l'on aplatit en forme de galette.
 Parsemer généreusement de @fromage râpé{} et redonner un ou deux tours à la pâte (c'est à dire la replier et la repasser au rouleau).
-Cuire dans une #poêle{} épaisse à revêtement anti-adhésif pendant ~{3%minutes} de chaque côté jusqu'à ce que la galette soit bien gonflée. 
+Cuire dans une #poêle{} épaisse à revêtement anti-adhésif pendant ~{3%minutes} de chaque côté jusqu'à ce que la galette soit bien gonflée.

recipes/plats/wraps_de_thon.cook

@@ -1,7 +1,7 @@
 >> title: wraps de thon
 >> time: 15m
 >> servings: 6
->> source: 
+>> source:
 
 Laver la @laitue{6%grandes feuilles}, et sélectionner les feuilles les plus vertes
 Égoutter le @thon{150%g} et le mélanger au @fromage blanc{6%cuillères à soupe} et au jus de @citron{1/2}, le @persil ou la @ciboulette. Saler et poivrer. Laver et couper la tomate en rondelles.