mathcraft-ocr 0.2.0__tar.gz → 0.2.2__tar.gz

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2}/MANIFEST.in

@@ -1,14 +1,14 @@
-include LICENSE
+include LICENSE
 include README_MATHCRAFT_OCR.md
-include pyproject.toml
-graft mathcraft_ocr
-prune build
-prune dist
-prune docs
-prune release_assets
-prune scripts
-prune src
-prune test
-prune test_pdf
-global-exclude __pycache__
-global-exclude *.py[cod]
+include pyproject.toml
+graft mathcraft_ocr
+prune build
+prune dist
+prune docs
+prune release_assets
+prune scripts
+prune src
+prune test
+prune test_pdf
+global-exclude __pycache__
+global-exclude *.py[cod]

{mathcraft_ocr-0.2.0/mathcraft_ocr.egg-info → mathcraft_ocr-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathcraft-ocr
-Version: 0.2.0
+Version: 0.2.2
 Summary: ONNX-only OCR runtime for mathematical documents
 Author: SakuraMathcraft
 License-Expression: MIT

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2}/mathcraft_ocr/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = [
     "DoctorReport",

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2}/mathcraft_ocr/formula_lines.py

@@ -7,6 +7,8 @@ import re
 
 import numpy as np
 
+from .latex_alignment import align_latex_relation_lines
+
 
 @dataclass(frozen=True)
 class FormulaLineCrop:
@@ -50,7 +52,7 @@ def compose_aligned_formula(lines: list[str] | tuple[str, ...]) -> str:
     cleaned = [line for line in cleaned if line]
     if len(cleaned) <= 1:
         return cleaned[0] if cleaned else ""
-    body = " \\\\\n".join(cleaned)
+    body = " \\\\\n".join(align_latex_relation_lines(cleaned))
     return "\\begin{aligned}\n" + body + "\n\\end{aligned}"
 
 
@@ -81,6 +83,8 @@ def _split_formula_rows(rgb: np.ndarray) -> tuple[FormulaLineCrop, ...]:
         if _band_looks_like_formula_row(mask, top, bottom, image_width=width)
     ]
     bands = _filter_annotation_bands(mask, bands, image_width=width)
+    if _looks_like_compact_fraction_split(mask, bands, image_width=width, image_height=height):
+        return ()
     if len(bands) < 2:
         return ()
 
@@ -191,6 +195,51 @@ def _filter_annotation_bands(
     return [(top, bottom) for active, top, bottom in stats if active >= min_active]
 
 
+def _looks_like_compact_fraction_split(
+    mask: np.ndarray,
+    bands: list[tuple[int, int]],
+    *,
+    image_width: int,
+    image_height: int,
+) -> bool:
+    if len(bands) != 2:
+        return False
+    if image_height < 70 or image_width / max(1, image_height) > 2.65:
+        return False
+
+    first = _band_bounds(mask, *bands[0])
+    second = _band_bounds(mask, *bands[1])
+    if first is None or second is None:
+        return False
+
+    first_left, _first_top, first_right, first_bottom = first
+    second_left, second_top, second_right, _second_bottom = second
+    vertical_gap = second_top - first_bottom - 1
+    if vertical_gap < 0 or vertical_gap > max(12, int(round(image_height * 0.09))):
+        return False
+
+    first_width = first_right - first_left + 1
+    second_width = second_right - second_left + 1
+    first_inset = min(first_left, image_width - first_right - 1)
+    second_inset = min(second_left, image_width - second_right - 1)
+    first_is_centered_fragment = (
+        first_width <= image_width * 0.86 and first_inset >= image_width * 0.06
+    )
+    second_is_wider = second_width >= first_width * 1.15 and second_inset <= image_width * 0.08
+    return first_is_centered_fragment and second_is_wider
+
+
+def _band_bounds(mask: np.ndarray, top: int, bottom: int) -> tuple[int, int, int, int] | None:
+    points = np.argwhere(mask[top : bottom + 1, :])
+    if points.size == 0:
+        return None
+    y1 = int(points[:, 0].min()) + top
+    y2 = int(points[:, 0].max()) + top
+    x1 = int(points[:, 1].min())
+    x2 = int(points[:, 1].max())
+    return x1, y1, x2, y2
+
+
 def _band_active_columns(mask: np.ndarray, top: int, bottom: int) -> int:
     return int(np.count_nonzero(mask[top : bottom + 1, :].any(axis=0)))
 
@@ -229,6 +278,9 @@ def _split_wide_line_segments(line: FormulaLineCrop) -> tuple[FormulaLineCrop, .
         return (line,)
 
     mask = _ink_mask(line.image)
+    if _has_large_vertical_delimiter(mask):
+        return (line,)
+
     column_counts = mask.sum(axis=0)
     column_threshold = max(2, int(round(height * 0.035)))
     column_has_ink = column_counts >= column_threshold
@@ -264,6 +316,26 @@ def _split_wide_line_segments(line: FormulaLineCrop) -> tuple[FormulaLineCrop, .
     return tuple(segments) if len(segments) > 1 else (line,)
 
 
+def _has_large_vertical_delimiter(mask: np.ndarray) -> bool:
+    height, width = mask.shape
+    if height < 48 or width < 80:
+        return False
+    content = np.argwhere(mask)
+    if content.size == 0:
+        return False
+    content_height = int(content[:, 0].max() - content[:, 0].min() + 1)
+    if content_height < height * 0.42:
+        return False
+    window = max(6, int(round(width * 0.035)))
+    column_counts = mask.sum(axis=0)
+    tall_threshold = max(12, int(round(content_height * 0.42)))
+    left_has_tall = bool(np.any(column_counts[:window] >= tall_threshold))
+    right_has_tall = bool(np.any(column_counts[-window:] >= tall_threshold))
+    interior = column_counts[window:-window] if width > window * 2 else column_counts
+    interior_tall_count = int(np.count_nonzero(interior >= tall_threshold))
+    return left_has_tall or right_has_tall or interior_tall_count >= 2
+
+
 def _crop_segment(
     segment_rgb: np.ndarray,
     offset_x: int,

mathcraft_ocr-0.2.2/mathcraft_ocr/latex_alignment.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+from __future__ import annotations
+
+
+RELATION_COMMANDS = (
+    r"\leqslant",
+    r"\geqslant",
+    r"\leq",
+    r"\geq",
+    r"\approx",
+    r"\equiv",
+    r"\sim",
+)
+RELATION_SYMBOLS = ("=", "<", ">")
+
+
+def align_latex_relation_lines(lines: list[str] | tuple[str, ...]) -> tuple[str, ...]:
+    cleaned = [line.strip() for line in lines if line and line.strip()]
+    if len(cleaned) <= 1:
+        return tuple(cleaned)
+
+    aligned: list[str] = []
+    saw_relation = False
+    for index, line in enumerate(cleaned):
+        relation = find_alignment_relation(line)
+        if relation is None:
+            if index > 0 and saw_relation:
+                aligned.append(r"&\quad " + line)
+            else:
+                aligned.append(line)
+            continue
+
+        left, operator, right = relation
+        saw_relation = True
+        if left:
+            aligned.append(f"{left} &{operator} {right}".rstrip())
+        else:
+            aligned.append(f"&{operator} {right}".rstrip())
+    return tuple(aligned)
+
+
+def find_alignment_relation(text: str) -> tuple[str, str, str] | None:
+    depth = 0
+    index = 0
+    while index < len(text):
+        char = text[index]
+        if char == "\\":
+            command = _read_command(text, index)
+            if depth == 0 and command in RELATION_COMMANDS:
+                return _split_relation(text, index, command)
+            index += len(command) if command else 1
+            continue
+        if char == "{" and not _is_escaped(text, index):
+            depth += 1
+            index += 1
+            continue
+        if char == "}" and not _is_escaped(text, index):
+            depth = max(0, depth - 1)
+            index += 1
+            continue
+        if depth == 0 and char in RELATION_SYMBOLS and not _is_escaped(text, index):
+            if _is_duplicate_relation_neighbor(text, index, char):
+                index += 1
+                continue
+            return _split_relation(text, index, char)
+        index += 1
+    return None
+
+
+def _split_relation(text: str, index: int, operator: str) -> tuple[str, str, str]:
+    left = text[:index].strip()
+    right = text[index + len(operator) :].strip()
+    return left, operator, right
+
+
+def _read_command(text: str, index: int) -> str:
+    if index >= len(text) or text[index] != "\\":
+        return ""
+    end = index + 1
+    while end < len(text) and text[end].isalpha():
+        end += 1
+    return text[index:end]
+
+
+def _is_duplicate_relation_neighbor(text: str, index: int, char: str) -> bool:
+    if char != "=":
+        return False
+    left = text[:index].rstrip()
+    right = text[index + 1 :].lstrip()
+    return left.endswith("=") or right.startswith("=")
+
+
+def _is_escaped(text: str, index: int) -> bool:
+    backslashes = 0
+    pos = index - 1
+    while pos >= 0 and text[pos] == "\\":
+        backslashes += 1
+        pos -= 1
+    return backslashes % 2 == 1

mathcraft_ocr-0.2.2/mathcraft_ocr/latex_quality.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+from __future__ import annotations
+
+from collections import Counter
+import re
+
+
+_TOKEN_RE = re.compile(r"\\[A-Za-z]+|[A-Za-z]+|\d+|[^\s]")
+_BEGIN_RE = re.compile(r"\\begin\s*\{\s*([^{}]+)\s*\}")
+_END_RE = re.compile(r"\\end\s*\{\s*([^{}]+)\s*\}")
+_LEFT_RE = re.compile(r"\\left(?![A-Za-z])")
+_RIGHT_RE = re.compile(r"\\right(?![A-Za-z])")
+_DUPLICATE_EQUALS_RE = re.compile(r"(?<!\\)=\s*=")
+_NOISY_REPEAT_TOKENS = {r"\quad", r"\qquad", r"\cdots", r"\ldots"}
+
+SEVERE_LATEX_QUALITY_FLAGS = {
+    "duplicate_relation",
+    "repeated_token_run",
+    "excessive_repeated_token",
+    "unbalanced_group",
+    "mismatched_environment",
+}
+
+
+def latex_quality_flags(text: str) -> tuple[str, ...]:
+    value = str(text or "")
+    flags: set[str] = set()
+    if _DUPLICATE_EQUALS_RE.search(value):
+        flags.add("duplicate_relation")
+    if _has_repeated_token_run(value):
+        flags.add("repeated_token_run")
+    if _has_excessive_repeated_token(value):
+        flags.add("excessive_repeated_token")
+    if _group_balance(value) != 0:
+        flags.add("unbalanced_group")
+    if not _environments_balanced(value):
+        flags.add("mismatched_environment")
+    if len(_LEFT_RE.findall(value)) != len(_RIGHT_RE.findall(value)):
+        flags.add("unbalanced_left_right")
+    return tuple(sorted(flags))
+
+
+def has_severe_latex_quality_issue(text: str) -> bool:
+    return bool(set(latex_quality_flags(text)) & SEVERE_LATEX_QUALITY_FLAGS)
+
+
+def _has_repeated_token_run(text: str) -> bool:
+    previous = ""
+    run = 0
+    for token in _TOKEN_RE.findall(text):
+        if token == previous:
+            run += 1
+        else:
+            previous = token
+            run = 1
+        if run >= 8:
+            return True
+    return False
+
+
+def _has_excessive_repeated_token(text: str) -> bool:
+    counts = Counter(token for token in _TOKEN_RE.findall(text) if token in _NOISY_REPEAT_TOKENS)
+    return any(count >= 18 for count in counts.values())
+
+
+def _group_balance(text: str) -> int:
+    depth = 0
+    for index, char in enumerate(text):
+        if char == "{" and not _is_escaped(text, index):
+            depth += 1
+        elif char == "}" and not _is_escaped(text, index):
+            depth -= 1
+    return depth
+
+
+def _environments_balanced(text: str) -> bool:
+    stack: list[str] = []
+    for match in re.finditer(r"\\(?:begin|end)\s*\{\s*([^{}]+)\s*\}", text):
+        command = match.group(0)
+        env = match.group(1).strip()
+        if command.startswith(r"\begin"):
+            stack.append(env)
+            continue
+        if not stack or stack.pop() != env:
+            return False
+    return not stack
+
+
+def _is_escaped(text: str, index: int) -> bool:
+    backslashes = 0
+    pos = index - 1
+    while pos >= 0 and text[pos] == "\\":
+        backslashes += 1
+        pos -= 1
+    return backslashes % 2 == 1

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2}/mathcraft_ocr/manifests/models.v1.json

@@ -1,60 +1,60 @@
-{
-  "version": 1,
-  "models": {
-    "mathcraft-formula-det": {
-      "version": "1",
-      "runtime": "onnx",
-      "files": [
-        {
-          "path": "mathcraft-mfd.onnx",
-          "sha256": "40d4fc852d99bcbf25a9478897d2f49fbbb8f7fdd6569c088cd1c31386293bd7"
-        }
-      ],
-      "sources": [
-        "https://github.com/SakuraMathcraft/MathCraft-Models/releases/download/v1.0.0/mathcraft-formula-det.zip"
-      ]
-    },
-    "mathcraft-formula-rec": {
-      "version": "1",
-      "runtime": "onnx",
-      "files": [
-        {
-          "path": "config.json",
-          "sha256": "9f3812441d397c871b9b2a74e8d956b939aec5f4f45745bba9214e968d56449d"
-        },
-        {
-          "path": "encoder_model.onnx",
-          "sha256": "bd8d5c322792e9ec45793af5569e9748f82a3d728a9e00213dbfc56c1486f37d"
-        },
-        {
-          "path": "decoder_model.onnx",
-          "sha256": "fd0f92d7a012f3dae41e1ac79421aea0ea888b5a66cb3f9a004e424f82f3daed"
-        },
-        {
-          "path": "generation_config.json",
-          "sha256": "cbea88288d5576a9655ad04e2456768544be22273a1c5ca160e0d16384639b4f"
-        },
-        {
-          "path": "preprocessor_config.json",
-          "sha256": "36a945a7cc645688b9ef64dabae16979cf5f7c1c448569cc306694edc0598b9b"
-        },
-        {
-          "path": "special_tokens_map.json",
-          "sha256": "8c785abebea9ae3257b61681b4e6fd8365ceafde980c21970d001e834cf10835"
-        },
-        {
-          "path": "tokenizer.json",
-          "sha256": "3e2ab757277d22639bec28c9d7972e352d3d1dba223051fa674002dc5ab64df3"
-        },
-        {
-          "path": "tokenizer_config.json",
-          "sha256": "7ffff31747c73b1a462b766abfc128e03f669e5b8452fe6e175b1430a078ac8d"
-        }
-      ],
-      "sources": [
-        "https://github.com/SakuraMathcraft/MathCraft-Models/releases/download/v1.0.0/mathcraft-formula-rec.zip"
-      ]
-    },
+{
+  "version": 1,
+  "models": {
+    "mathcraft-formula-det": {
+      "version": "1",
+      "runtime": "onnx",
+      "files": [
+        {
+          "path": "mathcraft-mfd.onnx",
+          "sha256": "40d4fc852d99bcbf25a9478897d2f49fbbb8f7fdd6569c088cd1c31386293bd7"
+        }
+      ],
+      "sources": [
+        "https://github.com/SakuraMathcraft/MathCraft-Models/releases/download/v1.0.0/mathcraft-formula-det.zip"
+      ]
+    },
+    "mathcraft-formula-rec": {
+      "version": "1",
+      "runtime": "onnx",
+      "files": [
+        {
+          "path": "config.json",
+          "sha256": "9f3812441d397c871b9b2a74e8d956b939aec5f4f45745bba9214e968d56449d"
+        },
+        {
+          "path": "encoder_model.onnx",
+          "sha256": "bd8d5c322792e9ec45793af5569e9748f82a3d728a9e00213dbfc56c1486f37d"
+        },
+        {
+          "path": "decoder_model.onnx",
+          "sha256": "fd0f92d7a012f3dae41e1ac79421aea0ea888b5a66cb3f9a004e424f82f3daed"
+        },
+        {
+          "path": "generation_config.json",
+          "sha256": "cbea88288d5576a9655ad04e2456768544be22273a1c5ca160e0d16384639b4f"
+        },
+        {
+          "path": "preprocessor_config.json",
+          "sha256": "36a945a7cc645688b9ef64dabae16979cf5f7c1c448569cc306694edc0598b9b"
+        },
+        {
+          "path": "special_tokens_map.json",
+          "sha256": "8c785abebea9ae3257b61681b4e6fd8365ceafde980c21970d001e834cf10835"
+        },
+        {
+          "path": "tokenizer.json",
+          "sha256": "3e2ab757277d22639bec28c9d7972e352d3d1dba223051fa674002dc5ab64df3"
+        },
+        {
+          "path": "tokenizer_config.json",
+          "sha256": "7ffff31747c73b1a462b766abfc128e03f669e5b8452fe6e175b1430a078ac8d"
+        }
+      ],
+      "sources": [
+        "https://github.com/SakuraMathcraft/MathCraft-Models/releases/download/v1.0.0/mathcraft-formula-rec.zip"
+      ]
+    },
     "mathcraft-text-det": {
       "version": "1",
       "runtime": "onnx",

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2}/mathcraft_ocr/runtime.py

@@ -27,6 +27,11 @@ from .errors import ModelCacheError
 from .formula_lines import compose_aligned_formula, compose_formula_line, split_formula_line_groups
 from .hardware import choose_rec_batch_num, detect_hardware_info
 from .image import load_image_rgb, rgb_to_bgr
+from .latex_quality import (
+    SEVERE_LATEX_QUALITY_FLAGS,
+    has_severe_latex_quality_issue,
+    latex_quality_flags,
+)
 from .layout import (
     annotate_blocks,
     box_to_points,
@@ -422,6 +427,7 @@ class MathCraftRuntime:
                     text=formula_text,
                     score=min(formula_box.score, formula_score),
                     source="formula_rec",
+                    confidence_flags=latex_quality_flags(formula_text),
                 )
             )
         if not blocks:
@@ -433,6 +439,7 @@ class MathCraftRuntime:
                     text=formula.text,
                     score=formula.score,
                     source="formula_fallback",
+                    confidence_flags=latex_quality_flags(formula.text),
                 )
             )
         blocks = list(resolve_formula_text_conflicts(blocks, image_size=(int(width), int(height))))
@@ -475,7 +482,30 @@ class MathCraftRuntime:
                 count = len(line_group.crops)
                 grouped_results.append(flat_results[offset : offset + count])
                 offset += count
-            return _merge_formula_group_results(grouped_results)
+            grouped_results = _repair_severe_segmented_lines(
+                rgb,
+                line_groups,
+                grouped_results,
+                model_dir,
+                provider_info,
+                max_new_tokens=max_new_tokens,
+            )
+            merged_text, merged_score = _merge_formula_group_results(grouped_results)
+            if has_severe_latex_quality_issue(merged_text):
+                fallback_text, fallback_score = recognize_formula_image(
+                    rgb,
+                    model_dir,
+                    provider_info,
+                    max_new_tokens=max_new_tokens,
+                )
+                if _prefer_formula_fallback(
+                    merged_text,
+                    merged_score,
+                    fallback_text,
+                    fallback_score,
+                ):
+                    return fallback_text, fallback_score
+            return merged_text, merged_score
         return recognize_formula_image(
             rgb,
             model_dir,
@@ -591,5 +621,64 @@ def _merge_formula_group_results(results: list[list[tuple[str, float]]]) -> tupl
     return text, score
 
 
+def _repair_severe_segmented_lines(
+    rgb,
+    line_groups,
+    grouped_results: list[list[tuple[str, float]]],
+    model_dir: Path,
+    provider_info: ProviderInfo,
+    *,
+    max_new_tokens: int,
+) -> list[list[tuple[str, float]]]:
+    repaired = [list(line_results) for line_results in grouped_results]
+    for index, (line_group, line_results) in enumerate(zip(line_groups, grouped_results)):
+        if len(line_group.crops) <= 1:
+            continue
+        line_text = compose_formula_line([text for text, _score in line_results])
+        if not has_severe_latex_quality_issue(line_text):
+            continue
+        fallback_text, fallback_score = recognize_formula_image(
+            _crop_formula_line_group(rgb, line_group),
+            model_dir,
+            provider_info,
+            max_new_tokens=max_new_tokens,
+        )
+        line_score = _mean_score(line_results)
+        if _prefer_formula_fallback(line_text, line_score, fallback_text, fallback_score):
+            repaired[index] = [(fallback_text, fallback_score)]
+    return repaired
+
+
+def _crop_formula_line_group(rgb, line_group) -> object:
+    left = min(crop.box[0] for crop in line_group.crops)
+    top = min(crop.box[1] for crop in line_group.crops)
+    right = max(crop.box[2] for crop in line_group.crops)
+    bottom = max(crop.box[3] for crop in line_group.crops)
+    return rgb[top:bottom, left:right].copy()
+
+
+def _mean_score(results: list[tuple[str, float]]) -> float:
+    if not results:
+        return 0.0
+    return float(sum(score for _text, score in results) / len(results))
+
+
+def _prefer_formula_fallback(
+    candidate_text: str,
+    candidate_score: float,
+    fallback_text: str,
+    fallback_score: float,
+) -> bool:
+    candidate_flags = set(latex_quality_flags(candidate_text))
+    fallback_flags = set(latex_quality_flags(fallback_text))
+    candidate_severe = candidate_flags & SEVERE_LATEX_QUALITY_FLAGS
+    fallback_severe = fallback_flags & SEVERE_LATEX_QUALITY_FLAGS
+    if len(fallback_severe) < len(candidate_severe):
+        return fallback_score >= candidate_score * 0.78
+    if fallback_severe == candidate_severe:
+        return fallback_score > candidate_score + 0.04
+    return False
+
+
 def _formula_mask_margin(width: int, height: int) -> int:
     return max(2, int(round(max(width, height) / 640.0)))

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2/mathcraft_ocr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathcraft-ocr
-Version: 0.2.0
+Version: 0.2.2
 Summary: ONNX-only OCR runtime for mathematical documents
 Author: SakuraMathcraft
 License-Expression: MIT

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2}/mathcraft_ocr.egg-info/SOURCES.txt

@@ -1,8 +1,8 @@
 LICENSE
 MANIFEST.in
-README.md
 README_MATHCRAFT_OCR.md
 pyproject.toml
+readme.md
 mathcraft_ocr/__init__.py
 mathcraft_ocr/__main__.py
 mathcraft_ocr/api.py
@@ -16,6 +16,8 @@ mathcraft_ocr/errors.py
 mathcraft_ocr/formula_lines.py
 mathcraft_ocr/hardware.py
 mathcraft_ocr/image.py
+mathcraft_ocr/latex_alignment.py
+mathcraft_ocr/latex_quality.py
 mathcraft_ocr/layout.py
 mathcraft_ocr/manifest.py
 mathcraft_ocr/profiles.py

{mathcraft_ocr-0.2.0 → mathcraft_ocr-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mathcraft-ocr"
-version = "0.2.0"
+version = "0.2.2"
 description = "ONNX-only OCR runtime for mathematical documents"
 readme = "README_MATHCRAFT_OCR.md"
 requires-python = ">=3.10"
@@ -79,13 +79,17 @@ exclude = ["src*", "test*", "scripts*", "docs*", "release_assets*", "build*", "d
 [tool.setuptools.package-data]
 mathcraft_ocr = ["manifests/*.json"]
 
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["test"]
+addopts = ["--ignore=python311", "--ignore=tools/deps", "--ignore=.venv", "--ignore=build", "--ignore=dist"]
+
 [tool.vulture]
 paths = ["src"]
 exclude = [
   "build/",
   "python311/",
-  "src/deps/python311/",
-  "src/get-pip.py"
+  "tools/deps/python311/"
 ]
 min_confidence = 70
 sort_by_size = true