11160013722

Committed 03 Oct 2024 10:08AM UTC coverage: 95.698% (+0.002%) from 95.696%

Build # 11160013722

Build Type

push

github

Committed by

jayaddison

Commit Message

v14: Type-hinting: modernize: remove some legacy `typing` imports

Logically re-applies/continues commit 44087215f.

Run Details

1798 of 2107 branches covered (85.33%)

1 of 1 new or added line in 1 file covered. (100.0%)

34 existing lines in 5 files now uncovered.

6829 of 7136 relevant lines covered (95.7%)

0.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.37

/recipe_scrapers/_grouping_utils.py

from __future__ import annotations

from collections import defaultdict
from dataclasses import dataclass

from bs4 import BeautifulSoup

from ._utils import normalize_string


@dataclass
class IngredientGroup:
    ingredients: list[str]
    purpose: str | None = (
        None  # this group of ingredients is {purpose} (e.g. "For the dressing")
    )


def score_sentence_similarity(first: str, second: str) -> float:
    """Calculate Dice coefficient for two strings.

    The dice coefficient is a measure of similarity that accounts for
    the length of the strings, determined by the proportion of shared bigrams. This normalization
    ensures the score is less biased towards shorter strings.

    Parameters
    ----------
    first : str
        The first input string.
    second : str
        The second input string.

    Returns
    -------
    float
        The similarity score between 0 and 1, where 0 indicates no shared bigrams and
        1 indicates identical strings.
    """

    if first == second:
        return 1

    if len(first) < 2 or len(second) < 2:
        return 0

    first_bigrams = {first[i : i + 2] for i in range(len(first) - 1)}
    second_bigrams = {second[i : i + 2] for i in range(len(second) - 1)}

    intersection = len(first_bigrams & second_bigrams)

    return 2 * intersection / (len(first_bigrams) + len(second_bigrams))


def best_match(test_string: str, target_strings: list[str]) -> str:
    """Find the best match for a given test string within a list of target strings.

    This function utilizes the score_sentence_similarity function to compare the test string
    against each target string. The target string with the highest similarity score to the
    test string is returned as the best match.

    Parameters
    ----------
    test_string : str
        The string to find the best match for.
    target_strings : list[str]
        A list of strings to compare against the test string.

    Returns
    -------
    str
        The string from target_strings that has the highest similarity score with test_string.
    """
    scores = [
        score_sentence_similarity(test_string, target) for target in target_strings
    ]
    best_match_index = max(range(len(scores)), key=scores.__getitem__)

    return target_strings[best_match_index]


def group_ingredients(
    ingredients_list: list[str],
    soup: BeautifulSoup,
    group_heading: str,
    group_element: str,
) -> list[IngredientGroup]:
    """
    Group ingredients into sublists according to the heading in the recipe.

    This method groups ingredients by extracting headings and corresponding elements
    based on provided CSS selectors. If no groupings are present, it creates a single
    group with all ingredients. It ensures ingredient groupings match those in
    the .ingredients() method of a scraper by comparing the text against the ingredients list.

    Parameters
    ----------
    ingredients_list : list[str]
        Ingredients extracted by the scraper.
    soup : BeautifulSoup
        Parsed HTML of the recipe page.
    group_heading : str
        CSS selector for ingredient group headings.
    group_element : str
        CSS selector for ingredient list items.

    Returns
    -------
    list[IngredientGroup]
        groupings of ingredients categorized by their purpose or heading.

    Raises
    -------
    ValueError
        If the number of elements selected does not match the length of ingredients_list.
    """

    found_ingredients = soup.select(group_element)
    if len(found_ingredients) != len(ingredients_list):
        raise ValueError(
            f"Found {len(found_ingredients)} grouped ingredients but was expecting to find {len(ingredients_list)}."
        )

    groupings: dict[str | None, list[str]] = defaultdict(list)
    current_heading = None

    elements = soup.select(f"{group_heading}, {group_element}")
    for element in elements:
        if element in element.parent.select(group_heading):
            current_heading = normalize_string(element.text) or None
            if current_heading not in groupings:
                groupings[current_heading] = []
        else:
            ingredient_text = normalize_string(element.text)
            matched_ingredient = best_match(ingredient_text, ingredients_list)
            groupings[current_heading].append(matched_ingredient)

    return [
        IngredientGroup(purpose=heading, ingredients=items)
        for heading, items in groupings.items()
        if items != []
    ]

1	from __future__ import annotations	1✔
2
3	from collections import defaultdict	1✔
4	from dataclasses import dataclass	1✔
5
6	from bs4 import BeautifulSoup	1✔
7
8	from ._utils import normalize_string	1✔
9
10
11	@dataclass	1✔
12	class IngredientGroup:	1✔
13	ingredients: list[str]	1✔
14	purpose: str \| None = (	1✔
15	None # this group of ingredients is {purpose} (e.g. "For the dressing")
16	)
17
18
19	def score_sentence_similarity(first: str, second: str) -> float:	1✔
20	"""Calculate Dice coefficient for two strings.
21
22	The dice coefficient is a measure of similarity that accounts for
23	the length of the strings, determined by the proportion of shared bigrams. This normalization
24	ensures the score is less biased towards shorter strings.
25
26	Parameters
27	----------
28	first : str
29	The first input string.
30	second : str
31	The second input string.
32
33	Returns
34	-------
35	float
36	The similarity score between 0 and 1, where 0 indicates no shared bigrams and
37	1 indicates identical strings.
38	"""
39
40	if first == second:	1✔
41	return 1	1✔
42
43	if len(first) < 2 or len(second) < 2:	1✔
44	return 0	1✔
45
46	first_bigrams = {first[i : i + 2] for i in range(len(first) - 1)}	1✔
47	second_bigrams = {second[i : i + 2] for i in range(len(second) - 1)}	1✔
48
49	intersection = len(first_bigrams & second_bigrams)	1✔
50
51	return 2 * intersection / (len(first_bigrams) + len(second_bigrams))	1✔
52
53
54	def best_match(test_string: str, target_strings: list[str]) -> str:	1✔
55	"""Find the best match for a given test string within a list of target strings.
56
57	This function utilizes the score_sentence_similarity function to compare the test string
58	against each target string. The target string with the highest similarity score to the
59	test string is returned as the best match.
60
61	Parameters
62	----------
63	test_string : str
64	The string to find the best match for.
65	target_strings : list[str]
66	A list of strings to compare against the test string.
67
68	Returns
69	-------
70	str
71	The string from target_strings that has the highest similarity score with test_string.
72	"""
73	scores = [	1✔
74	score_sentence_similarity(test_string, target) for target in target_strings
75	]
76	best_match_index = max(range(len(scores)), key=scores.__getitem__)	1✔
77
78	return target_strings[best_match_index]	1✔
79
80
81	def group_ingredients(	1✔
82	ingredients_list: list[str],
83	soup: BeautifulSoup,
84	group_heading: str,
85	group_element: str,
86	) -> list[IngredientGroup]:
87	"""
88	Group ingredients into sublists according to the heading in the recipe.
89
90	This method groups ingredients by extracting headings and corresponding elements
91	based on provided CSS selectors. If no groupings are present, it creates a single
92	group with all ingredients. It ensures ingredient groupings match those in
93	the .ingredients() method of a scraper by comparing the text against the ingredients list.
94
95	Parameters
96	----------
97	ingredients_list : list[str]
98	Ingredients extracted by the scraper.
99	soup : BeautifulSoup
100	Parsed HTML of the recipe page.
101	group_heading : str
102	CSS selector for ingredient group headings.
103	group_element : str
104	CSS selector for ingredient list items.
105
106	Returns
107	-------
108	list[IngredientGroup]
109	groupings of ingredients categorized by their purpose or heading.
110
111	Raises
112	-------
113	ValueError
114	If the number of elements selected does not match the length of ingredients_list.
115	"""
116
117	found_ingredients = soup.select(group_element)	1✔
118	if len(found_ingredients) != len(ingredients_list):	1!
UNCOV 119	raise ValueError(	×
120	f"Found {len(found_ingredients)} grouped ingredients but was expecting to find {len(ingredients_list)}."
121	)
122
123	groupings: dict[str \| None, list[str]] = defaultdict(list)	1✔
124	current_heading = None	1✔
125
126	elements = soup.select(f"{group_heading}, {group_element}")	1✔
127	for element in elements:	1✔
128	if element in element.parent.select(group_heading):	1✔
129	current_heading = normalize_string(element.text) or None	1✔
130	if current_heading not in groupings:	1✔
131	groupings[current_heading] = []	1✔
132	else:
133	ingredient_text = normalize_string(element.text)	1✔
134	matched_ingredient = best_match(ingredient_text, ingredients_list)	1✔
135	groupings[current_heading].append(matched_ingredient)	1✔
136
137	return [	1✔
138	IngredientGroup(purpose=heading, ingredients=items)
139	for heading, items in groupings.items()
140	if items != []
141	]

hhursev / recipe-scraper / 11160013722

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous