sartoriuslib.registry¶

def unit_to_display_code(unit: Unit) -> int:
    """Turn a :class:`Unit` into its p07 display-unit code.

    Raises :class:`ValueError` for :attr:`Unit.UNKNOWN` and any
    :class:`Unit` member not in the display-unit table (should be
    unreachable today — every member is in the table — but stays
    defensive for future additions).
    """
    try:
        return _UNIT_TO_DISPLAY_CODE[unit]
    except KeyError as exc:
        raise ValueError(
            f"{unit!r} has no display-unit code in the p07 parameter table",
        ) from exc

def get_parameter_spec(index: int) -> ParameterSpec | None:
    """Look up the spec for a parameter index, or ``None`` if unmapped."""
    return PARAMETER_TABLE.get(index)

def decode_mode[E: IntEnum](enum_cls: type[E], raw: int) -> E:
    """Turn a wire u8 into a member of ``enum_cls``.

    Unrecognised codes collapse to the ``UNKNOWN`` member (value ``0``)
    so new firmware reveals stay non-crashing. Every enum in this
    module is guaranteed to carry an ``UNKNOWN = 0`` member.
    """
    try:
        return enum_cls(raw)
    except ValueError:
        return enum_cls(0)

def normalise(raw: str) -> str:
    """Canonicalise ``raw`` to ``lower_snake_case_ish``.

    ``"Very Stable"`` / ``"very-stable"`` / ``"very.stable"`` all
    collapse to ``"very_stable"``. Unicode is lowercased but not
    folded — ``"µg"`` stays ``"µg"``.
    """
    text = raw.strip().lower()
    text = _NORMALISE_SEPARATORS.sub("_", text)
    return _NORMALISE_STRIPS.sub("", text)

def resolve_auto_zero(raw: str | AutoZeroMode | int) -> AutoZeroMode:
    """Fuzzy-match to an :class:`AutoZeroMode`."""
    return _resolve_enum(AutoZeroMode, _AUTO_ZERO_ALIASES, raw)

def resolve_display_accuracy(raw: str | DisplayAccuracyMode | int) -> DisplayAccuracyMode:
    """Fuzzy-match to a :class:`DisplayAccuracyMode`."""
    return _resolve_enum(DisplayAccuracyMode, _DISPLAY_ACC_ALIASES, raw)

def resolve_filter_mode(raw: str | FilterMode | int) -> FilterMode:
    """Fuzzy-match to a :class:`FilterMode`. Raises on unknown input."""
    return _resolve_enum(FilterMode, _FILTER_ALIASES, raw)

def resolve_isocal_mode(raw: str | IsoCalMode | int) -> IsoCalMode:
    """Fuzzy-match to an :class:`IsoCalMode`."""
    return _resolve_enum(IsoCalMode, _ISOCAL_ALIASES, raw)

def resolve_menu_access(raw: str | MenuAccessMode | int) -> MenuAccessMode:
    """Fuzzy-match to a :class:`MenuAccessMode`."""
    return _resolve_enum(MenuAccessMode, _MENU_ACCESS_ALIASES, raw)

def resolve_output_mode(raw: str | OutputMode | int) -> OutputMode:
    """Fuzzy-match to an :class:`OutputMode`."""
    return _resolve_enum(OutputMode, _OUTPUT_ALIASES, raw)

def resolve_tare_behavior(raw: str | TareBehavior | int) -> TareBehavior:
    """Fuzzy-match to a :class:`TareBehavior`."""
    return _resolve_enum(TareBehavior, _TARE_ALIASES, raw)

def resolve_unit(raw: str | Unit) -> Unit:
    """Fuzzy-match ``raw`` to a :class:`Unit` member.

    Raises :class:`UnknownUnitError` if no alias matches.
    """
    if isinstance(raw, Unit):
        return raw
    key = normalise(raw)
    if key in _UNIT_ALIASES:
        return _UNIT_ALIASES[key]
    raise UnknownUnitError(
        f"unknown unit {raw!r}",
        context=ErrorContext(extra={"input": raw, "normalised": key}),
    )