health.qrisk-inputs-validate Unreviewed

def validate_qrisk_inputs(inputs: QriskInputs) -> QriskInputsValidation

@dataclass(frozen=True)
class QriskInputs:
    """The QRISK3 input set, as raw recorded values to be checked."""

    #: years; required, 25 to 84
    age: Optional[int]
    #: female or male; required
    sex: Optional[str]
    #: white-or-not-stated, indian, pakistani, bangladeshi, chinese, other-asian, black-caribbean, black-african or other; required
    ethnicity: Optional[str]
    #: UK postcode; optional
    postcode: Optional[str]
    #: non-smoker, ex-smoker, light (under 10 a day), moderate (10 to 19) or heavy (20 or more); required
    smoking: Optional[str]
    #: none, type-1 or type-2; required
    diabetes: Optional[str]
    #: angina or heart attack in a 1st degree relative
    family_history_cvd: bool
    #: CKD stage 3, 4 or 5
    chronic_kidney_disease: bool
    atrial_fibrillation: bool
    #: on treatment for high blood pressure
    blood_pressure_treatment: bool
    migraine: bool
    rheumatoid_arthritis: bool
    #: systemic lupus erythematosus (SLE)
    systemic_lupus: bool
    #: schizophrenia, bipolar disorder or moderate/severe depression
    severe_mental_illness: bool
    #: on atypical antipsychotic medication
    atypical_antipsychotic: bool
    #: on regular steroid tablets
    corticosteroids: bool
    #: a diagnosis of or treatment for erectile dysfunction
    erectile_dysfunction: bool
    #: total cholesterol / HDL; optional, 1.0 to 11.0
    cholesterol_hdl_ratio: Optional[float]
    #: mmHg; optional, 70 to 210
    systolic_bp: Optional[int]
    #: standard deviation of at least two recent systolic readings; optional, 0.0 to 40.0
    systolic_bp_sd: Optional[float]
    #: whole centimetres; optional with weight, 140 to 210
    height_cm: Optional[int]
    #: whole kilograms; optional with height, 40 to 180
    weight_kg: Optional[int]
    #: already diagnosed with coronary heart disease, stroke or TIA
    existing_cvd: bool
    #: already taking a statin
    on_statins: bool

@dataclass(frozen=True)
class QriskInputError:
    """One problem with one field."""

    #: the QriskInputs field name
    field: str
    #: required, out-of-range, unknown-value, incomplete-pair, bad-postcode or not-applicable
    reason: str
    #: plain English, in the calculator's own wording where it has one
    message: str

@dataclass(frozen=True)
class QriskInputsValidation:
    """Whether the set can be given to QRISK3, and if not, why."""

    valid: bool
    #: empty when valid
    errors: List[QriskInputError]

from fune.health.qrisk_inputs_validate import validate_qrisk_inputs  # health.qrisk-inputs-validate@^1

import math
from typing import List, Optional, Sequence

from .health_qrisk_inputs_validate_types import QriskInputError, QriskInputs, QriskInputsValidation
from .validation_uk_postcode import validate_uk_postcode  ← from validation.uk-postcode ^2.0.0 · built alongside by fune

_SEXES = ("female", "male")
_ETHNICITIES = (
    "white-or-not-stated",
    "indian",
    "pakistani",
    "bangladeshi",
    "chinese",
    "other-asian",
    "black-caribbean",
    "black-african",
    "other",
)
_SMOKING = ("non-smoker", "ex-smoker", "light", "moderate", "heavy")
_DIABETES = ("none", "type-1", "type-2")


# A value of the wrong type is a programming error, not a clinical one: it
# raises rather than being reported.
def _whole_or_none(name: str, value: object) -> Optional[int]:
    if value is None:
        return None
    if isinstance(value, bool) or not (
        isinstance(value, int) or (isinstance(value, float) and math.isfinite(value) and value.is_integer())
    ):
        raise TypeError("%s must be a whole number or null, received %r" % (name, value))
    return int(value)


def _number_or_none(name: str, value: object) -> Optional[float]:
    if value is None:
        return None
    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
        raise TypeError("%s must be a number or null, received %r" % (name, value))
    return float(value)


def _text_or_none(name: str, value: object) -> Optional[str]:
    if value is None:
        return None
    if not isinstance(value, str):
        raise TypeError("%s must be text or null, received %r" % (name, value))
    return value


def validate_qrisk_inputs(inputs: QriskInputs) -> QriskInputsValidation:
    """Check a QRISK3 input set against the calculator's published input
    definitions (qrisk.org form and its validation). It reports every problem,
    in field order, and never computes a risk."""
    errors: List[QriskInputError] = []

    def add(field: str, reason: str, message: str) -> None:
        errors.append(QriskInputError(field=field, reason=reason, message=message))

    age = _whole_or_none("age", inputs.age)
    sex = _text_or_none("sex", inputs.sex)
    ethnicity = _text_or_none("ethnicity", inputs.ethnicity)
    postcode = _text_or_none("postcode", inputs.postcode)
    smoking = _text_or_none("smoking", inputs.smoking)
    diabetes = _text_or_none("diabetes", inputs.diabetes)
    ratio = _number_or_none("cholesterolHdlRatio", inputs.cholesterol_hdl_ratio)
    sbp = _whole_or_none("systolicBp", inputs.systolic_bp)
    sbp_sd = _number_or_none("systolicBpSd", inputs.systolic_bp_sd)
    height = _whole_or_none("heightCm", inputs.height_cm)
    weight = _whole_or_none("weightKg", inputs.weight_kg)

    age_message = "Age: enter an integer between 25 and 84"
    if age is None:
        add("age", "required", age_message)
    elif age < 25 or age > 84:
        add("age", "out-of-range", age_message)

    def choice(field: str, value: Optional[str], allowed: Sequence[str], label: str) -> None:
        message = "%s: enter one of %s" % (label, ", ".join(allowed))
        if value is None:
            add(field, "required", message)
        elif value not in allowed:
            add(field, "unknown-value", message)

    choice("sex", sex, _SEXES, "Sex")
    choice("ethnicity", ethnicity, _ETHNICITIES, "Ethnicity")
    # Blank means unknown, as on the calculator ("leave blank if unknown").
    if postcode is not None and postcode.strip() != "" and not validate_uk_postcode(postcode).valid:
        add("postcode", "bad-postcode", "Postcode: the postcode is not recognised. Please re-enter or leave blank.")
    choice("smoking", smoking, _SMOKING, "Smoking status")
    choice("diabetes", diabetes, _DIABETES, "Diabetes status")

    if ratio is not None and (ratio < 1.0 or ratio > 11.0):
        add(
            "cholesterolHdlRatio",
            "out-of-range",
            "Cholesterol/HDL ratio: either leave blank or enter a number between 1.0 and 11.0.",
        )
    if sbp is not None and (sbp < 70 or sbp > 210):
        add("systolicBp", "out-of-range", "Systolic blood pressure: either leave blank or enter an integer between 70 and 210")
    if sbp_sd is not None and (sbp_sd < 0.0 or sbp_sd > 40.0):
        add(
            "systolicBpSd",
            "out-of-range",
            "Standard deviation of SBP: either leave blank or enter a value between 0.0 and 40.0",
        )
    pair = "You have only entered one of height and weight: please enter both or leave both blank."
    if height is None and weight is not None:
        add("heightCm", "incomplete-pair", pair)
    if height is not None and (height < 140 or height > 210):
        add("heightCm", "out-of-range", "Height: enter an integer between 140 and 210")
    if weight is None and height is not None:
        add("weightKg", "incomplete-pair", pair)
    if weight is not None and (weight < 40 or weight > 180):
        add("weightKg", "out-of-range", "Weight: enter an integer between 40 and 180")

    if inputs.existing_cvd is True:
        add(
            "existingCvd",
            "not-applicable",
            "QRISK3 is only valid for people without a diagnosis of coronary heart disease "
            "(including angina or heart attack) or stroke/transient ischaemic attack.",
        )
    if inputs.on_statins is True:
        add("onStatins", "not-applicable", "QRISK3 is only valid for people who are not on statins.")
    return QriskInputsValidation(valid=len(errors) == 0, errors=errors)

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and its 1 dependency, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add health.qrisk-inputs-validate

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./health.qrisk-inputs-validate-1.0.1-python.fune, or fetch it from a terminal with fune pull health.qrisk-inputs-validate@1.0.1:python.

The whole function, every language, is one file too: health.qrisk-inputs-validate-1.0.1.fune, 63,589 bytes, sha256 60ced6a1a2baa49117e7b29dcfa24a8b99cc406022f04baaf04502da74e7e2f7. It installs into a project of any language.

# fune: before health.qrisk-inputs-validate

# fune: after health.qrisk-inputs-validate

# fune: replace validation.uk-postcode in health.qrisk-inputs-validate

# fune: step health.qrisk-inputs-validate after <n|label>

More from the author

Every problem is reported, not just the first, in the order of the `QriskInputs` fields and then `existingCvd` and `onStatins`, each with the field name, a reason code and a message in the calculator's own wording where it has one. The result is `valid` only when there are none.

## The published input definitions

From the QRISK3 calculator form at https://qrisk.org and its client-side validation script https://qrisk.org/form.v003.js:

| Field | Required | Accepted | |---|---|---| | age | yes | whole years, 25 to 84 | | sex | yes | `female`, `male` | | ethnicity | yes | `white-or-not-stated`, `indian`, `pakistani`, `bangladeshi`, `chinese`, `other-asian`, `black-caribbean`, `black-african`, `other` | | postcode | no ("leave blank if unknown") | a valid UK postcode (checked with validation.uk-postcode) | | smoking | yes | `non-smoker`, `ex-smoker`, `light` (under 10 a day), `moderate` (10 to 19), `heavy` (20 or more) | | diabetes | yes | `none`, `type-1`, `type-2` | | cholesterolHdlRatio | no | 1.0 to 11.0 | | systolicBp | no | whole mmHg, 70 to 210 | | systolicBpSd | no | 0.0 to 40.0 (SD of at least two recent systolic readings) | | heightCm, weightKg | no, but both or neither | whole cm 140 to 210; whole kg 40 to 180 |

The eleven yes/no conditions (family history, CKD 3-5, AF, treated hypertension, migraine, rheumatoid arthritis, SLE, severe mental illness, atypical antipsychotics, regular steroid tablets, erectile dysfunction) are booleans and cannot be invalid.

The calculator states that it "is only valid if you do not already have a diagnosis of coronary heart disease (including angina or heart attack) or stroke/transient ischaemic attack, and not on statins", so `existingCvd` or `onStatins` being true is reported as `not-applicable`.

The codes for the categorical fields are this capability's own lower-case spellings of the calculator's options; the fields are plain strings, not enums, because the point is to check raw recorded values.

## Edge cases and decisions

- **Height and weight are whole numbers** in the published form ("enter an integer"). Round a recorded 172.5 cm before calling; a fractional height is refused with an error (it is a type error, thrown in every language, not a reported clinical problem), as is a fractional age or systolic pressure. A whole number sent as 170.0 is accepted. - **A lone height or weight** is reported against the missing one, with the calculator's "only entered one of height and weight" message. - **A blank postcode** (empty or spaces) is treated as unknown, as on the form. - **Units are not converted.** A height of 2 (metres) is out of range, not 200 cm. A total cholesterol typed into the ratio field cannot be told apart from a ratio if it is between 1 and 11: that is for the caller. - **Erectile dysfunction** is, as far as we know, a term of the male QRISK3 equation only (BMJ 2017; the paper's tables were not re-read for this package); the calculator's form does not reject it for women and neither does this. - The ranges are the calculator's input limits, not clinical normal ranges.

## Sources

- QRISK3 risk calculator, https://qrisk.org, and its form validation https://qrisk.org/form.v003.js (both read September 2026). - Hippisley-Cox J, Coupland C, Brindle P. Development and validation of QRISK3 risk prediction algorithms to estimate future risk of cardiovascular disease: prospective cohort study. BMJ 2017;357:j2099.

## Before you rely on this

**Not professional advice.** This capability calculates health figures from published rules. It is a software component for developers, not medical advice. Rules change and every rate here has an effective date. Check that the dates cover your case. Verify results against the official sources listed above, and have a primary-care clinician review how you use it, before anyone relies on the output. Provided "as is" under its licence, without warranty.

**Not a medical device.** It is not intended to diagnose, treat or support clinical decisions about any individual. Anyone building it into clinical software is responsible for that software's regulatory status, and must validate it under their own clinical governance.

**Not for clinical use; regulatory review pending.** Whether publishing this capability makes it a medical device is under regulatory review. Until that is settled it is a developer library only.

**Unreviewed.** This capability's implementations agree in every language and pass its published test vectors, which were worked out from the official sources cited. But no qualified primary-care clinician has yet checked those vectors, or confirmed that the capability covers the cases it claims. Treat it as a draft. Do not use it for real people, money or decisions without your own expert review. Once a qualified reviewer signs off, this notice is replaced with their name, qualification and the date. Each new version needs fresh sign-off.

## Notices

QRISK® is a registered trademark of ClinRisk Ltd; this capability is not affiliated with or endorsed by ClinRisk.

1.0.1 marks it unreviewed (not for clinical use; regulatory review pending) and adds its attribution notices (NOTICE). The code and the tests are unchanged.

Files