Refactor: Use % style string formatting for logging.

Author: strangetom

ingredient_parser/en/_structure_features.py

@@ -195,7 +195,7 @@ def detect_mip_phrases(self, tokenized_sentence: list[Token]) -> list[list[int]]
 
         text_pos = [(token.text, token.pos_tag) for token in self.tokenized_sentence]
         parsed = self.mip_parser.parse(text_pos)
-        logger.debug(f"MIP parser: \n{parsed}")
+        logger.debug("MIP parser: \n%s", parsed)
         for indices in self._get_subtree_indices(parsed, ["EMIP", "MIP"]):  # type: ignore
             # If the conjunction is not "or", skip
             if self._cc_is_not_or(text_pos, indices):
@@ -249,7 +249,7 @@ def detect_sentences_splits(self, tokenized_sentence: list[Token]) -> list[int]:
             text_pos.append((t.feat_text, pos))
 
         parsed = self.compound_parser.parse(text_pos)
-        logger.debug(f"Sentence split parser: \n{parsed}")
+        logger.debug("Sentence split parser: \n%s", parsed)
         for indices in self._get_subtree_indices(parsed, ["CS_WU", "CS_NU", "CS_HALF"]):  # type: ignore
             # If the conjunction is not "or", skip
             if self._cc_is_not_or(text_pos, indices):
@@ -281,7 +281,7 @@ def detect_examples(self, tokenized_sentence: list[Token]) -> list[list[int]]:
 
         text_pos = [(token.text, token.pos_tag) for token in self.tokenized_sentence]
         parsed = self.example_parser.parse(text_pos)
-        logger.debug(f"Example parser: \n{parsed}")
+        logger.debug("Example parser: \n%s", parsed)
         for indices in self._get_subtree_indices(parsed, ["EX"]):  #  type: ignore
             phrase_text_pos = [
                 (token.text.upper(), token.pos_tag)
@@ -347,7 +347,7 @@ def detect_dimensional_phrases(
             text_pos.append((t.feat_text, pos))
 
         parsed = self.dimensional_phrase_parser.parse(text_pos)
-        logger.debug(f"Dimensional phrase parser: \n{parsed}")
+        logger.debug("Dimensional phrase parser: \n%s", parsed)
         dimensional_phrases = self._get_subtree_indices(parsed, ["DP"])  # type: ignore
         return dimensional_phrases
 

ingredient_parser/en/foundationfoods/_ff_utils.py

@@ -163,7 +163,7 @@ def normalise_spelling(tokens: list[IngredientToken]) -> list[IngredientToken]:
 
     if normalised_tokens != tokens:
         norm_tokens = [t.token for t in normalised_tokens]
-        logger.debug(f"Normalised '{[t.token for t in tokens]}' to '{norm_tokens}'.")
+        logger.debug("Normalised '%s' to '%s'.", [t.token for t in tokens], norm_tokens)
 
     return normalised_tokens
 
@@ -230,7 +230,8 @@ def load_fdc_ingredients() -> list[FDCIngredient]:
                 tokenized_description = tokenize_fdc_description(row["description"])
                 if not tokenized_description.embedding_tokens:
                     logger.debug(
-                        f"'{row['description']}' has no tokens in embedding vocabulary."
+                        "'%s' has no tokens in embedding vocabulary.",
+                        row["description"],
                     )
                     continue
                 foundation_foods.append(
@@ -247,7 +248,7 @@ def load_fdc_ingredients() -> list[FDCIngredient]:
                     )
                 )
 
-    logger.debug(f"Loaded {len(foundation_foods)} FDC ingredients.")
+    logger.debug("Loaded %d FDC ingredients.", len(foundation_foods))
     return foundation_foods
 
 

ingredient_parser/en/foundationfoods/_foundationfoods.py

@@ -94,13 +94,13 @@ def match_foundation_foods(
     name_tokens = [IngredientToken(token, tag) for token, tag in zip(tokens, pos_tags)]
 
     name_tokens = strip_ambiguous_leading_adjectives(name_tokens)
-    logger.debug(f"Matching FDC ingredient for ingredient name tokens: {tokens}")
+    logger.debug("Matching FDC ingredient for ingredient name tokens: %s", tokens)
     prepared_tokens = prepare_tokens(tuple(name_tokens))
     if not prepared_tokens:
         logger.debug("Ingredient name has no tokens valid for matching.")
         return None
     else:
-        logger.debug(f"Prepared tokens: {prepared_tokens}.")
+        logger.debug("Prepared tokens: %s.", prepared_tokens)
 
     normalised_tokens = normalise_spelling(prepared_tokens)
 
@@ -158,7 +158,9 @@ def match_foundation_foods(
     # Check if both BM25 and uSIF agree on the top result. If they do, return that and
     # avoid any further processing.
     if fdc := consistent_top_result(bm25_matches, usif_matches):
-        logger.debug(f"BM25 and uSIF rankers agree on best match: {fdc.fdc_id=}")
+        logger.debug(
+            "BM25 and uSIF rankers agree on best match: fdc.fdc_id=%s", fdc.fdc_id
+        )
         return FoundationFood(
             text=fdc.description,
             confidence=1.0,
@@ -177,12 +179,14 @@ def match_foundation_foods(
             m.fdc.fdc_id for m in bm25_matches[:TOP_K]
         }
         logger.debug(
-            f"BM25 and uSIF ranker alignment is below threshold "
-            f"({bm25_usif_agreement=:.4f} < {BM25_USIF_AGREENMENT_THRESHOLD=})."
+            "BM25 and uSIF ranker alignment is below threshold "
+            "(bm25_usif_agreement=%.4f < BM25_USIF_AGREENMENT_THRESHOLD=%f).",
+            bm25_usif_agreement,
+            BM25_USIF_AGREENMENT_THRESHOLD,
         )
         logger.debug(
-            f"Using FuzzyMatcher on top {TOP_K} matches from "
-            "BM25 and uSIF to help arbitrate."
+            "Using FuzzyMatcher on top %d matches from BM25 and uSIF to arbitrate.",
+            TOP_K,
         )
 
         fuzzy = get_fuzzy_ranker()
@@ -213,16 +217,17 @@ def match_foundation_foods(
         )
         if matches_with_top_score > len(DATASET_PREFERENCE):
             logger.debug(
-                f"Top score shared by {matches_with_top_score} FDC entries "
-                "therefore cannot determine suitable match."
+                "Top score shared by %d FDC entries therefore cannot determine match.",
+                matches_with_top_score,
             )
             return None
 
     match_quality = determine_match_quality(best_match, usif_matches, fuzzy_matches)
     if match_quality.quality == "poor":
         logger.debug(
-            f"Rejected best match of '{best_match.fdc.description}' because "
-            f"{match_quality.reason}."
+            "Rejected best match of '%s' because %s.",
+            best_match.fdc.description,
+            match_quality.reason,
         )
         return None
 
@@ -552,10 +557,10 @@ def fuse_results(
     fuzzy_conf = fuzzy_conf / total_conf * 3
     usif_conf = usif_conf / total_conf * 3
     logger.debug(
-        f"Ranker confidences: "
-        f"BM25={bm25_conf:.4f}, "
-        f"uSIF={usif_conf:.4f}, "
-        f"Fuzzy={fuzzy_conf:.4f}."
+        "Ranker confidences: BM25=%.4f, uSIF=%.4f, Fuzzy=%.4f.",
+        bm25_conf,
+        usif_conf,
+        fuzzy_conf,
     )
 
     fused_matches = []

ingredient_parser/en/parser.py

@@ -67,7 +67,7 @@ def parse_ingredient_en(
     ParsedIngredient
         ParsedIngredient object of structured data parsed from input string.
     """
-    logger.debug(f'Parsing sentence "{sentence}" using "en" parser.')
+    logger.debug("Parsing sentence '%s' using 'en' parser.", sentence)
     TAGGER = load_parser_model()
 
     if custom_units is None:
@@ -84,7 +84,7 @@ def parse_ingredient_en(
     labels, scores = zip(*TAGGER.tag_from_features(features, expect_name_in_output))
     labels = list(labels)
     scores = list(scores)
-    logger.debug(f"Sentence token labels: {labels}.")
+    logger.debug("Sentence token labels: %s.", labels)
 
     labelled_tokens = [
         LabelledToken(
@@ -173,7 +173,7 @@ def inspect_parser_en(
         ParserDebugInfo object containing the PreProcessor object, PostProcessor
         object and Tagger.
     """
-    logger.debug(f'Parsing sentence "{sentence}" using "en" parser.')
+    logger.debug("Parsing sentence '%s' using 'en' parser.", sentence)
     TAGGER = load_parser_model()
 
     if custom_units is None:
@@ -190,7 +190,7 @@ def inspect_parser_en(
     labels, scores = zip(*TAGGER.tag_from_features(features, expect_name_in_output))
     labels = list(labels)
     scores = list(scores)
-    logger.debug(f"Sentence token labels: {labels}.")
+    logger.debug("Sentence token labels: %s.", labels)
 
     labelled_tokens = [
         LabelledToken(

ingredient_parser/en/postprocess.py

@@ -196,9 +196,10 @@ def parsed(self) -> ParsedIngredient:
             self.labels = name_replaced_labels
             logger.debug(
                 (
-                    f"Relabelled tokens to {name_replaced_labels} ",
+                    "Relabelled tokens to %s ",
                     "because seperate_name=False.",
-                )
+                ),
+                name_replaced_labels,
             )
 
             # Process NAME labels as any other label, but return as a list
@@ -1073,7 +1074,9 @@ def _sizeable_unit_pattern(
                         amounts.append(first)
                         _ = match.pop(-1)
 
-                        logger.debug(f"Implicit quantity of '1' applied to '1 {unit}'.")
+                        logger.debug(
+                            "Implicit quantity of '1' applied to '1 %s'.", unit
+                        )
                     else:
                         # The first amount is made up of the first and last items
                         # Note that this cannot be singular, but may be approximate
@@ -1581,7 +1584,7 @@ def _fallback_pattern(
 
             if amount.implicit_quantity:
                 logger.debug(
-                    f"Implicit quantity of '{amount.quantity}' applied to '{text}'."
+                    "Implicit quantity of '%s' applied to '%s'.", amount.quantity, text
                 )
 
         return processed_amounts

ingredient_parser/en/preprocess.py

@@ -127,7 +127,7 @@ def __init__(self, input_sentence: str, custom_units: dict[str, str] | None = No
         """
         self.input: str = input_sentence
         self.sentence: str = self._normalise(input_sentence)
-        logger.debug(f'Normalised sentence: "{self.sentence}".')
+        logger.debug("Normalised sentence: '%s'.", self.sentence)
 
         if custom_units is not None:
             self._units = UNITS | custom_units
@@ -196,7 +196,7 @@ def _normalise(self, sentence: str) -> str:
 
         for func in funcs:
             sentence = func(sentence)
-            logger.debug(f"{func.__name__}: {sentence}")
+            logger.debug("%s: %s", func.__name__, sentence)
 
         return sentence.strip()
 
@@ -625,8 +625,8 @@ def _calculate_tokens(self, sentence: str) -> list[Token]:
                 )
             )
 
-        logger.debug(f"Tokenized sentence: {[t.text for t in tokens]}.")
-        logger.debug(f"Singularised tokens at indices: {self.singularised_indices}.")
+        logger.debug("Tokenized sentence: %s.", [t.text for t in tokens])
+        logger.debug("Singularised tokens at indices: %s.", self.singularised_indices)
 
         return tokens
 

ingredient_parser/inference.py

@@ -128,7 +128,7 @@ def tag_from_features(
 
         if expect_name_in_output and all("NAME" not in label for label in labels):
             # No tokens were assigned the NAME label, so guess if there's a name
-            logger.debug(f"No tokens found where name is most probable label: {labels}")
+            logger.debug("No tokens labelled as NAME by model: %s", labels)
             labels, scores = self._guess_ingredient_name(labels, scores)
 
         self._detect_invalid_label_sequence(labels)
@@ -285,7 +285,7 @@ def _guess_ingredient_name(
             labels[token_index] = new_label
             scores[token_index] = new_score
 
-        logger.debug(f"Found alternative name at token indices: {indices}")
+        logger.debug("Found alternative name at token indices: %s", indices)
         return labels, scores
 
     def _detect_invalid_label_sequence(self, labels: list[str]) -> None:

pyproject.toml

@@ -74,7 +74,7 @@ exclude = [
 line-length = 88
 
 [tool.ruff.lint]
-select = ["E", "F", "I", "PERF", "PT", "RUF"]
+select = ["E", "F", "I", "PERF", "PT", "RUF", "G"]
 ignore = [
     "E402",   # To enable path to be modified in doc conf.py before import
     "RUF001", # Ambiguous unicode characters are handled explicitly in functions