Merge pull request #100 from longieirl/fix/90-g004-logging-fstrings

fix(#90): replace logging f-strings with % formatting (G004, 214 sites)

Author: longieirl

.github/workflows/ci.yml

@@ -194,7 +194,7 @@ jobs:
 
     - name: Install security tools + packages
       run: |
-        pip install --upgrade pip bandit[toml] pip-audit
+        pip install --upgrade pip bandit[toml] pip-audit xenon
         pip install -e packages/parser-core
         pip install -e packages/parser-free
 

packages/parser-core/pyproject.toml

@@ -167,7 +167,6 @@ select = [
 ignore = [
     "E501",    # line too long — handled by black
     "PLR2004", # magic value comparison — acceptable in tests and config
-    "G004",    # logging f-string — 214 violations, deferred, see GitHub issue #90
 ]
 
 [tool.ruff.lint.per-file-ignores]

packages/parser-core/src/bankstatements_core/analysis/column_analyzer.py

@@ -44,7 +44,7 @@ def analyze_columns(
         Returns:
             Dictionary mapping column names to (x_min, x_max) tuples
         """
-        logger.debug(f"Analyzing columns in table {table_bbox}")
+        logger.debug("Analyzing columns in table %s", table_bbox)
 
         # Extract words within table bbox
         words = page.extract_words(
@@ -65,14 +65,14 @@ def analyze_columns(
             logger.warning("No words found in table region")
             return {}
 
-        logger.debug(f"Found {len(table_words)} words in table region")
+        logger.debug("Found %s words in table region", len(table_words))
 
         # Find header row first
         header_words = self._find_header_words(table_words, table_bbox)
 
         if header_words:
             # Strategy: Use header words to define columns
-            logger.debug(f"Using {len(header_words)} header words to define columns")
+            logger.debug("Using %s header words to define columns", len(header_words))
             boundaries, column_names = self._create_columns_from_headers(
                 header_words, table_bbox
             )
@@ -83,16 +83,16 @@ def analyze_columns(
             boundaries = self._detect_boundaries_from_clusters(clusters)
             column_names = [f"Column{i+1}" for i in range(len(boundaries))]
 
-        logger.debug(f"Detected {len(boundaries)} column boundaries")
+        logger.debug("Detected %s column boundaries", len(boundaries))
 
         # Build result dictionary
         columns = {}
         for i, (x_min, x_max) in enumerate(boundaries):
             column_name = column_names[i] if i < len(column_names) else f"Column{i+1}"
             columns[column_name] = (x_min, x_max)
-            logger.debug(f"  {column_name}: ({x_min:.1f}, {x_max:.1f})")
+            logger.debug("  %s: (%.1f, %.1f)", column_name, x_min, x_max)
 
-        logger.info(f"Detected {len(columns)} columns")
+        logger.info("Detected %s columns", len(columns))
         return columns
 
     def _cluster_x_coordinates(self, words: list[dict]) -> list[float]:
@@ -130,7 +130,7 @@ def _cluster_x_coordinates(self, words: list[dict]) -> list[float]:
             clusters.append(cluster_center)
 
         logger.debug(
-            f"Clustered {len(x_coords)} X-coords into {len(clusters)} clusters"
+            "Clustered %s X-coords into %s clusters", len(x_coords), len(clusters)
         )
         return sorted(clusters)
 
@@ -201,8 +201,10 @@ def _find_header_words(
         header_words = [word for word in table_words if word["top"] <= header_threshold]
 
         logger.debug(
-            f"Found {len(header_words)} words in header row "
-            f"(Y={min_y:.1f}, threshold={header_threshold:.1f})"
+            "Found %s words in header row (Y=%.1f, threshold=%.1f)",
+            len(header_words),
+            min_y,
+            header_threshold,
         )
         return header_words
 
@@ -272,8 +274,11 @@ def _assign_column_names(
                 column_names[best_col_idx] = name
 
                 logger.debug(
-                    f"Column {best_col_idx} [{boundaries[best_col_idx][0]:.1f}, "
-                    f"{boundaries[best_col_idx][1]:.1f}]: '{name}'"
+                    "Column %s [%.1f, %.1f]: '%s'",
+                    best_col_idx,
+                    boundaries[best_col_idx][0],
+                    boundaries[best_col_idx][1],
+                    name,
                 )
 
         # Fill in any unassigned columns with generic names
@@ -284,8 +289,11 @@ def _assign_column_names(
                 name = f"Column{i+1}"
                 result_names.append(name)
                 logger.debug(
-                    f"Column {i} [{boundaries[i][0]:.1f}, {boundaries[i][1]:.1f}]: "
-                    f"'{name}' (no match)"
+                    "Column %s [%.1f, %.1f]: '%s' (no match)",
+                    i,
+                    boundaries[i][0],
+                    boundaries[i][1],
+                    name,
                 )
             else:
                 result_names.append(name_val)
@@ -323,11 +331,16 @@ def _resolve_overlapping_boundaries(
                     # Leave 1px gap to avoid extraction ambiguity
                     new_x_max = next_x_min - 1
                     logger.debug(
-                        f"Overlap detected: Column {i} [{x_min:.1f}, {x_max:.1f}] "
-                        f"overlaps Column {i+1} [{next_x_min:.1f}, {next_x_max:.1f}]"
+                        "Overlap detected: Column %s [%.1f, %.1f] overlaps Column %s [%.1f, %.1f]",
+                        i,
+                        x_min,
+                        x_max,
+                        i + 1,
+                        next_x_min,
+                        next_x_max,
                     )
                     logger.debug(
-                        f"  Adjusting Column {i} x_max: {x_max:.1f} -> {new_x_max:.1f}"
+                        "  Adjusting Column %s x_max: %.1f -> %.1f", i, x_max, new_x_max
                     )
                     x_max = new_x_max
 
@@ -364,7 +377,9 @@ def _create_columns_from_headers(
         word_groups.append(current_group)
 
         logger.debug(
-            f"Grouped {len(header_words)} header words into {len(word_groups)} columns"
+            "Grouped %s header words into %s columns",
+            len(header_words),
+            len(word_groups),
         )
 
         # Create boundaries and names from word groups
@@ -390,7 +405,7 @@ def _create_columns_from_headers(
             name = " ".join(w["text"] for w in group)
             column_names.append(name)
 
-            logger.debug(f"  Column: '{name}' at [{x_min:.1f}, {x_max:.1f}]")
+            logger.debug("  Column: '%s' at [%.1f, %.1f]", name, x_min, x_max)
 
         # Resolve overlaps by adjusting boundaries
         boundaries = self._resolve_overlapping_boundaries(boundaries)
@@ -399,7 +414,7 @@ def _create_columns_from_headers(
         for i, (x_min, x_max) in enumerate(boundaries):
             if i < len(column_names):
                 logger.debug(
-                    f"  Adjusted '{column_names[i]}': [{x_min:.1f}, {x_max:.1f}]"
+                    "  Adjusted '%s': [%.1f, %.1f]", column_names[i], x_min, x_max
                 )
 
         return boundaries, column_names

packages/parser-core/src/bankstatements_core/analysis/iban_spatial_filter.py

@@ -64,11 +64,11 @@ def extract_iban_candidates(self, page: Any) -> list[IBANCandidate]:  # noqa: C9
         page_num = page.page_number
         if page_num != 1:
             logger.warning(
-                f"⚠️  IBAN extraction called on page {page_num} - "
-                "should only process first page!"
+                "⚠️  IBAN extraction called on page %s - should only process first page!",
+                page_num,
             )
 
-        logger.debug(f"Extracting IBAN candidates from page {page_num}")
+        logger.debug("Extracting IBAN candidates from page %s", page_num)
 
         # Extract all words with coordinates
         words = page.extract_words(x_tolerance=3, y_tolerance=3, keep_blank_chars=False)
@@ -77,7 +77,7 @@ def extract_iban_candidates(self, page: Any) -> list[IBANCandidate]:  # noqa: C9
             logger.debug("No words found on page")
             return []
 
-        logger.debug(f"Extracted {len(words)} words from page")
+        logger.debug("Extracted %s words from page", len(words))
 
         # Group nearby words into potential IBAN sequences
         candidates = []
@@ -129,7 +129,7 @@ def extract_iban_candidates(self, page: Any) -> list[IBANCandidate]:  # noqa: C9
                 )
 
                 candidates.append(candidate)
-                logger.debug(f"Found IBAN candidate: {masked} at {word_bbox}")
+                logger.debug("Found IBAN candidate: %s at %s", masked, word_bbox)
 
         # Fallback: If no candidates found with word-based approach,
         # try text-based extraction with approximate coordinates
@@ -143,7 +143,7 @@ def extract_iban_candidates(self, page: Any) -> list[IBANCandidate]:  # noqa: C9
                 iban = self.iban_extractor.extract_iban(page_text)
                 if iban:
                     masked = self.iban_extractor._mask_iban(iban)
-                    logger.info(f"✓ Found IBAN using text-based fallback: {masked}")
+                    logger.info("✓ Found IBAN using text-based fallback: %s", masked)
 
                     # Create approximate bounding box (page header area)
                     # Most IBANs are in the top 1/3 of the page
@@ -161,10 +161,11 @@ def extract_iban_candidates(self, page: Any) -> list[IBANCandidate]:  # noqa: C9
                     )
                     candidates.append(candidate)
                     logger.debug(
-                        f"Using approximate bounding box for fallback IBAN: {approx_bbox}"
+                        "Using approximate bounding box for fallback IBAN: %s",
+                        approx_bbox,
                     )
 
-        logger.info(f"Found {len(candidates)} IBAN candidates on page {page_num}")
+        logger.info("Found %s IBAN candidates on page %s", len(candidates), page_num)
         return candidates
 
     def filter_by_table_overlap(
@@ -198,19 +199,20 @@ def filter_by_table_overlap(
                     overlaps_table = True
                     candidate.rejection_reason = f"Overlaps with table {table_bbox}"
                     logger.debug(
-                        f"REJECTED: {candidate.masked} overlaps table {table_bbox}"
+                        "REJECTED: %s overlaps table %s", candidate.masked, table_bbox
                     )
                     break
 
             if overlaps_table:
                 rejected.append(candidate)
             else:
                 filtered.append(candidate)
-                logger.debug(f"ACCEPTED: {candidate.masked} does not overlap tables")
+                logger.debug("ACCEPTED: %s does not overlap tables", candidate.masked)
 
         logger.info(
-            f"Filtered IBANs: {len(filtered)} accepted, {len(rejected)} rejected "
-            f"(table overlap)"
+            "Filtered IBANs: %s accepted, %s rejected (table overlap)",
+            len(filtered),
+            len(rejected),
         )
 
         return filtered
@@ -240,23 +242,26 @@ def score_candidates(
             # Score 1: Header area preference (+50 points)
             if candidate.bbox.y0 <= header_boundary:
                 score += 50.0
-                logger.debug(f"{candidate.masked}: +50 (header area)")
+                logger.debug("%s: +50 (header area)", candidate.masked)
 
             # Score 2: Y-position preference (+0 to +30 points, higher = better)
             # Normalize Y position (0 = top, 1 = bottom)
             y_ratio = candidate.bbox.y0 / page_height
             position_score = 30.0 * (1.0 - y_ratio)  # Invert so top gets high score
             score += position_score
             logger.debug(
-                f"{candidate.masked}: +{position_score:.1f} "
-                f"(Y-position {candidate.bbox.y0:.1f}/{page_height:.1f})"
+                "%s: +%.1f (Y-position %.1f/%.1f)",
+                candidate.masked,
+                position_score,
+                candidate.bbox.y0,
+                page_height,
             )
 
             # Score 3: Near "IBAN" label (future enhancement)
             # TODO: Look for "IBAN" text nearby
 
             candidate.confidence_score = score
-            logger.debug(f"{candidate.masked}: Total score = {score:.1f}")
+            logger.debug("%s: Total score = %.1f", candidate.masked, score)
 
         # Sort by score (highest first)
         candidates_sorted = sorted(
@@ -280,8 +285,10 @@ def select_best_iban(self, candidates: list[IBANCandidate]) -> IBANCandidate | N
 
         best = candidates[0]
         logger.info(
-            f"Selected IBAN: {best.masked} (score: {best.confidence_score:.1f}, "
-            f"location: {best.bbox})"
+            "Selected IBAN: %s (score: %.1f, location: %s)",
+            best.masked,
+            best.confidence_score,
+            best.bbox,
         )
 
         return best