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])
|