File size: 5,270 Bytes
dab7db2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
"""Load the test catalog and resolve names and units against it."""
from __future__ import annotations

import re
import unicodedata
from dataclasses import dataclass, field
from functools import lru_cache
from pathlib import Path

import yaml
from rapidfuzz import fuzz, process

CATALOG_PATH = Path(__file__).parent / "data" / "catalog.yaml"


def normalize_text(s: str) -> str:
    """Lowercase, strip accents (Latin only), collapse whitespace."""
    s = s.strip().lower()
    # Strip Latin diacritics but keep Arabic letters intact.
    decomposed = unicodedata.normalize("NFKD", s)
    s = "".join(c for c in decomposed if not (unicodedata.combining(c) and ord(c) < 0x0600))
    s = s.replace("μ", "µ")
    return re.sub(r"\s+", " ", s)


def normalize_unit(u: str) -> str:
    u = normalize_text(u or "").replace(" ", "")
    u = u.replace("μ", "µ").replace("×", "").replace("x10", "10")
    u = u.replace("10e", "10^").replace("10*", "10^")
    u = re.sub(r"10\^?(\d)", r"10^\1", u)
    return u


@dataclass
class TestDef:
    key: str
    display: dict[str, str]
    category: str
    canonical_unit: str
    units: dict[str, float]
    typical_range: tuple[float, float]
    critical: dict[str, float]
    plausible: tuple[float, float]
    aliases: dict[str, list[str]]
    kb: dict[str, str]
    all_aliases: list[str] = field(default_factory=list)

    def to_canonical(self, value: float, unit: str | None) -> float | None:
        """Convert a value to the canonical unit. Returns None if the unit is unknown."""
        if not unit:
            return value  # assume canonical when no unit printed
        nu = normalize_unit(unit)
        for spelled, factor in self.units.items():
            if normalize_unit(spelled) == nu:
                return value * factor
        if nu == normalize_unit(self.canonical_unit):
            return value
        return None


@lru_cache(maxsize=1)
def load_catalog(path: str | None = None) -> dict[str, TestDef]:
    raw = yaml.safe_load(Path(path or CATALOG_PATH).read_text(encoding="utf-8"))
    out: dict[str, TestDef] = {}
    for key, t in raw["tests"].items():
        td = TestDef(
            key=key,
            display=t["display"],
            category=t["category"],
            canonical_unit=t["canonical_unit"],
            units=t["units"],
            typical_range=tuple(t["typical_range"]),
            critical=t.get("critical") or {},
            plausible=tuple(t["plausible"]),
            aliases=t["aliases"],
            kb=t["kb"],
        )
        td.all_aliases = sorted(
            {normalize_text(a) for lang in td.aliases.values() for a in lang}, key=len, reverse=True
        )
        out[key] = td
    return out


@lru_cache(maxsize=1)
def _alias_index() -> dict[str, str]:
    idx: dict[str, str] = {}
    for key, td in load_catalog().items():
        for a in td.all_aliases:
            idx.setdefault(a, key)
    return idx


# Characters Tesseract commonly confuses, folded to one representative before fuzzy
# matching: "Hemiogiouine" and "hemoglobine" end up much closer.
_OCR_FOLD = str.maketrans({"l": "i", "1": "i", "|": "i", "!": "i", "j": "i", "t": "i",
                           "0": "o", "a": "o", "e": "o", "c": "o", "u": "o", "b": "o", "g": "o"})


def _fold(s: str) -> str:
    s = s.replace("rn", "m").replace("-", " ").replace("_", " ")
    return re.sub(r"\s+", " ", s.translate(_OCR_FOLD)).strip()


@lru_cache(maxsize=1)
def _folded_index() -> dict[str, set[str]]:
    out: dict[str, set[str]] = {}
    for a, k in _alias_index().items():
        if len(a) >= 4:
            out.setdefault(_fold(a), set()).add(k)
    return out


def match_test_name(name: str, min_score: int = 80, margin: float = 6.0) -> tuple[str | None, float]:
    """Map a printed test name to a catalog key.

    Exact alias first. Otherwise fuzzy matching on OCR-folded strings, accepted only when
    the best test beats the runner-up *test* by a margin. HDL vs LDL differ by one letter
    and have opposite meanings, so an ambiguous match is rejected rather than guessed.
    """
    n = normalize_text(name)
    n = re.sub(r"[:.\-–_]+$", "", n).strip()
    idx = _alias_index()
    if n in idx:
        return idx[n], 100.0
    if len(n) < 4:
        # Short aliases (hb, k, na, a1c) only match exactly after OCR folding, and only
        # when the folded form is unambiguous ("Alc" -> a1c).
        if len(n) < 3:
            return None, 0.0  # never guess 1-2 letter tokens ("No", "N°" sample numbers)
        keys = {k for a, k in idx.items() if len(a) < 4 and _fold(a) == _fold(n)}
        return (keys.pop(), 90.0) if len(keys) == 1 else (None, 0.0)
    folded = _folded_index()
    hits = process.extract(_fold(n), list(folded), scorer=fuzz.ratio, limit=12)
    best_per_key: dict[str, float] = {}
    for alias, score, _ in hits:
        for k in folded[alias]:
            best_per_key[k] = max(best_per_key.get(k, 0.0), score)
    ranked = sorted(best_per_key.items(), key=lambda kv: kv[1], reverse=True)
    if not ranked or ranked[0][1] < min_score:
        return None, ranked[0][1] if ranked else 0.0
    if len(ranked) > 1 and ranked[0][1] - ranked[1][1] < margin:
        return None, ranked[0][1]
    return ranked[0][0], float(ranked[0][1])