Canonical url intergration batch 3

recipe_scrapers/maangchi.py

@@ -25,11 +25,10 @@ def image(self):
         return self.schema.image()
 
     def ingredients(self):
-        before = self.soup.find("h4", string="Directions").find_all_previous("li")
-        after = self.soup.find("h4", string="Ingredients:").find_all_next("li")
+        before = self.soup.find("h2", string="Ingredients").find_all_next("li")
+        after = self.soup.find("h2", string="Directions").find_all_previous("li")
         list_before = [normalize_string(b.get_text()) for b in before]
         list_after = [normalize_string(a.get_text()) for a in after]
-        list_before.reverse()
         return [x for x in list_before if x in list_after]
 
     def instructions(self):
@@ -43,7 +42,12 @@ def instructions(self):
         )
 
     def ratings(self):
-        return self.schema.ratings()
+        rating_element = self.soup.find("p", {"class": "rmp-rating-widget__results"})
+        if rating_element:
+            rating_text = rating_element.find(
+                "span", {"class": "rmp-rating-widget__results__rating"}
+            ).text.strip()
+        return int(rating_text)
 
     def cuisine(self):
         return self.schema.cuisine()

recipe_scrapers/marthastewart.py

@@ -12,19 +12,16 @@ def title(self):
         return self.schema.title()
 
     def total_time(self):
-        s = (
-            self.soup.findAll("div", {"class": "two-subcol-content-wrapper"})[0]
-            .find("div", {"class": "recipe-meta-item-body"})
-            .text.strip()
-        )
-        return get_minutes(s)
+        time_label = self.soup.find("div", string="Total Time:")
+        if time_label:
+            servings_value = time_label.find_next(
+                "div", {"class": "mntl-recipe-details__value"}
+            )
+            if servings_value:
+                return get_minutes(servings_value.text.strip())
 
     def yields(self):
-        return (
-            self.soup.findAll("div", {"class": "two-subcol-content-wrapper"})[1]
-            .find("div", {"class": "recipe-meta-item-body"})
-            .text.strip()
-        )
+        return self.schema.yields()
 
     def ingredients(self):
         return self.schema.ingredients()

recipe_scrapers/momswithcrockpots.py

@@ -34,13 +34,3 @@ def instructions(self):
         return "\n".join(
             [normalize_string(instruction.get_text()) for instruction in instructions]
         )
-
-    def ratings(self):
-        return round(
-            float(
-                self.soup.find(
-                    "span", {"class": "wprm-recipe-rating-average"}
-                ).get_text()
-            ),
-            2,
-        )

recipe_scrapers/onehundredonecookbooks.py

@@ -1,7 +1,6 @@
 # mypy: disallow_untyped_defs=False
-import re
-
 from ._abstract import AbstractScraper
+from ._utils import get_yields
 
 
 class OneHundredOneCookBooks(AbstractScraper):
@@ -17,27 +16,56 @@ def author(self):
         return self.schema.author()
 
     def title(self):
-        return self.soup.find("h1").get_text()
+        return self.soup.find("h2").get_text()
 
     def total_time(self):
         return self.schema.total_time()
 
     def yields(self):
-        data = self.soup.find_all("p", limit=3, recursive=False)[-1].get_text()
-        extraction = re.search("([0-9]+) servings", data)
-        return extraction.group(1) if extraction else None
+        header = self.soup.find("div", class_="cb101-recipe-time-header")
+        if header and "Serves" in header.text:
+            data = self.soup.find("div", class_="cb101-recipe-time").text.strip()
+            total_yields = data.split()[0]
+            return get_yields(total_yields)
 
     def image(self):
         return self.schema.image()
 
     def ingredients(self):
-        ingredients = self.soup.find("blockquote").p.stripped_strings
-        return list(ingredients)
+        ingredients = []
 
-    def instructions(self):
-        return self.soup.find_all("p", limit=2, recursive=False)[1].get_text(
-            "\n", strip=True
+        ingredient_items = self.soup.select(
+            ".cb101-recipe-ingredients li.cb101-recipe-ingredient"
         )
 
-    def ratings(self):
-        return None
+        for item in ingredient_items:
+            amount_element = item.select_one(".cb101-recipe-ingredient-amount")
+            unit_element = item.select_one(".cb101-recipe-ingredient-unit")
+            name_element = item.select_one(".cb101-recipe-ingredient-name")
+
+            amount = amount_element.get_text(strip=True) if amount_element else ""
+            unit = unit_element.get_text(strip=True) if unit_element else ""
+            name = name_element.get_text(strip=True)
+
+            if amount and unit:
+                ingredient = f"{amount} {unit} {name}".strip()
+            else:
+                ingredient = f"{amount}{unit} {name}".strip()
+
+            ingredients.append(ingredient)
+
+        return ingredients
+
+    def instructions(self):
+        instructions_div = self.soup.find(
+            "div", class_="cb101-recipe-header", string="Instructions"
+        )
+        instructions = []
+        if instructions_div:
+            instruction_group = instructions_div.find_next(
+                "div", class_="cb101-recipe-instruction-group"
+            )
+            if instruction_group:
+                for instruction in instruction_group.find_all("p"):
+                    instructions.append(instruction.get_text(strip=True))
+        return "\n".join(instructions)

recipe_scrapers/panelinha.py

@@ -2,7 +2,7 @@
 import re
 
 from ._abstract import AbstractScraper
-from ._utils import get_minutes, normalize_string
+from ._utils import get_yields, normalize_string
 
 INSTRUCTIONS_NUMBERING_REGEX = re.compile(r"^\d{1,2}\.\s*")  # noqa
 
@@ -13,23 +13,22 @@ def host(cls):
         return "panelinha.com.br"
 
     def title(self):
-        return normalize_string(self.soup.find("h1").get_text())
-
-    def total_time(self):
-        return get_minutes(
-            self.soup.find("span", string="Tempo de preparo").nextSibling
-        )
+        parent_div = self.soup.find("div", {"id": "recipe_header"})
+        return normalize_string(parent_div.find("h1").get_text())
 
     def ingredients(self):
-        ingredients = self.soup.find("h4", string="Ingredientes").nextSibling.findAll(
+        ingredients = self.soup.find("h5", string="Ingredientes").nextSibling.findAll(
             "li"
         )
 
-        return [normalize_string(ingredient.get_text()) for ingredient in ingredients]
+        return [
+            normalize_string(ingredient.get_text().replace("\u00C2", ""))
+            for ingredient in ingredients
+        ]
 
     def instructions(self):
         instructions = self.soup.find(
-            "h4", string="Modo de preparo"
+            "h5", string="Modo de preparo"
         ).nextSibling.findAll("li")
 
         instructions = [
@@ -53,4 +52,8 @@ def instructions(self):
         return "\n".join(instructions)
 
     def yields(self):
-        return self.schema.yields()
+        main_element = self.soup.find("main")
+        yield_text = main_element.get("data-item-p-yield")
+        yield_number = re.search(r"\d+", yield_text)
+        if yield_number:
+            return get_yields(yield_number.group())

recipe_scrapers/paninihappy.py

@@ -18,8 +18,11 @@ def yields(self):
         return get_yields(self.soup.find("span", {"class": "yield"}))
 
     def image(self):
-        image = self.soup.find("img", {"class": "post_image", "src": True})
-        return image["src"] if image else None
+        div_hrecipe = self.soup.find("div", {"class": "hrecipe"})
+        if div_hrecipe:
+            img_tag = div_hrecipe.find("img", {"loading": "lazy"})
+            if img_tag and "src" in img_tag.attrs:
+                return img_tag["src"]
 
     def ingredients(self):
         ingredients = self.soup.findAll("li", {"class": "ingredient"})

recipe_scrapers/primaledgehealth.py

@@ -1,5 +1,6 @@
 # mypy: disallow_untyped_defs=False
 from ._abstract import AbstractScraper
+from ._utils import normalize_string
 
 
 class PrimalEdgeHealth(AbstractScraper):
@@ -20,7 +21,22 @@ def image(self):
         return self.schema.image()
 
     def ingredients(self):
-        return self.schema.ingredients()
+        ingredients_li = self.soup.select(".wprm-recipe-ingredient")
+        ingredients_list = [
+            normalize_string(
+                li.find("span", {"class": "wprm-recipe-ingredient-amount"}).get_text()
+            ).replace("\u00C2", "")
+            + " "
+            + normalize_string(
+                li.find("span", {"class": "wprm-recipe-ingredient-unit"}).get_text()
+            ).replace("\u00C2", "")
+            + " "
+            + normalize_string(
+                li.find("span", {"class": "wprm-recipe-ingredient-name"}).get_text()
+            ).replace("\u00C2", "")
+            for li in ingredients_li
+        ]
+        return ingredients_list
 
     def instructions(self):
         return self.schema.instructions()

recipe_scrapers/rezeptwelt.py

@@ -31,15 +31,12 @@ def ingredients(self):
         return self.schema.ingredients()
 
     def instructions(self):
-        content = self.soup.find("ol", {"itemprop": "recipeInstructions"}).findAll(
-            "div", {"itemprop": "itemListElement"}
-        )
-        res = ""
-        for i in content:
-            steps = i.findAll("span", {"itemprop": "text"})
-            for step in steps:
-                res += normalize_string(step.text) + "\n"
-        return res
+        preparation_div = self.soup.find("div", id="preparationSteps")
+        instructions = preparation_div.find("span", itemprop="text").find_all("p")
+        instruction_texts = [instruction.get_text() for instruction in instructions]
+        normalized_texts = [normalize_string(text) for text in instruction_texts]
+        joined_instructions = "\n".join(filter(None, normalized_texts))
+        return joined_instructions
 
     def ratings(self):
         return self.schema.ratings()