gea-program 0.14.0__tar.gz → 0.15.0__tar.gz

{gea_program-0.14.0 → gea_program-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.14.0
+Version: 0.15.0
 Summary: GEA-Program: downhole gauge monitoring - canonical measurement records, quality rules, drift evaluation with a re-fit change log, well-test validation, alarm management, model cards, store-and-forward, monthly SLA measurement, FAT/SAT protocols and a dashboard, generated from live objects in the client's reporting outline.
 Author: Daniel T. Murphy
 License: MPL-2.0
@@ -125,7 +125,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (330 checks)
+gea accept                     # the product gate (333 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -619,6 +619,27 @@ promoted; the group and the support are declarations; a matched frequency
 is not a fault size. CSV or miniSEED/SAC; `gea vibration` runs the labelled
 pump; `gea help vibration`.
 
+### Conformity, in the standards' words
+
+The drift report's "bias inside the instrument's class" is a statement of
+conformity, and ISO/IEC 17025:2017 7.8.6 says what one carries: the result it
+applies to, the specification, and the decision rule - which has to take
+the uncertainty into account. The report now states it that way: the tag's
+bias over the window with its sample count, the certificate's accuracy
+class as the tolerance limit, the bias's expanded uncertainty (k = 2) as the
+guard band, and the ILAC-G8:09/2019 non-binary rule - PASS, CONDITIONAL
+PASS, CONDITIONAL FAIL or FAIL, with the acceptance limit printed; without
+an uncertainty it falls back to simple acceptance and says so. The
+certificate register takes what 7.8.4 asks the paper to carry (the expanded
+uncertainty with k and probability, the traceability statement as worded,
+the conditions, the calibration date, the method, who authorised it) and
+`gea certificates --action conformance` prints each certificate against
+the fourteen items of 7.8.2.1 and 7.8.4.1 - CARRIED, NOT CARRIED, NOT
+RECORDED - with COMPLETE or INCOMPLETE and the missing clauses named. The
+well page's filing form takes the items and its table shows U (k) and the
+standing. `gea conformance --action decide` states one decision. `gea help
+conformance`.
+
 ### Audit / Update
 
 The Audit / Update tab holds three things. The whole audit log

{gea_program-0.14.0 → gea_program-0.15.0}/README.md

@@ -86,7 +86,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (330 checks)
+gea accept                     # the product gate (333 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -580,6 +580,27 @@ promoted; the group and the support are declarations; a matched frequency
 is not a fault size. CSV or miniSEED/SAC; `gea vibration` runs the labelled
 pump; `gea help vibration`.
 
+### Conformity, in the standards' words
+
+The drift report's "bias inside the instrument's class" is a statement of
+conformity, and ISO/IEC 17025:2017 7.8.6 says what one carries: the result it
+applies to, the specification, and the decision rule - which has to take
+the uncertainty into account. The report now states it that way: the tag's
+bias over the window with its sample count, the certificate's accuracy
+class as the tolerance limit, the bias's expanded uncertainty (k = 2) as the
+guard band, and the ILAC-G8:09/2019 non-binary rule - PASS, CONDITIONAL
+PASS, CONDITIONAL FAIL or FAIL, with the acceptance limit printed; without
+an uncertainty it falls back to simple acceptance and says so. The
+certificate register takes what 7.8.4 asks the paper to carry (the expanded
+uncertainty with k and probability, the traceability statement as worded,
+the conditions, the calibration date, the method, who authorised it) and
+`gea certificates --action conformance` prints each certificate against
+the fourteen items of 7.8.2.1 and 7.8.4.1 - CARRIED, NOT CARRIED, NOT
+RECORDED - with COMPLETE or INCOMPLETE and the missing clauses named. The
+well page's filing form takes the items and its table shows U (k) and the
+standing. `gea conformance --action decide` states one decision. `gea help
+conformance`.
+
 ### Audit / Update
 
 The Audit / Update tab holds three things. The whole audit log

{gea_program-0.14.0 → gea_program-0.15.0}/gea/__init__.py

@@ -122,7 +122,7 @@ from .profile_catalog import (
     read_pangaea_txt,
 )
 
-__version__ = "0.14.0"
+__version__ = "0.15.0"
 __all__ = [
     "aging_rate", "rate_psi_yr", "accuracy_psi",
     "Sensor", "SimulatorConfig", "DownholeEngine",

{gea_program-0.14.0 → gea_program-0.15.0}/gea/__main__.py

@@ -409,6 +409,14 @@ def main(argv=None) -> int:
 
     p_osdu = sub.add_parser("osdu", help="the OSDU-shaped export: the self-test on a labelled site")
     p_osdu.add_argument("--action", choices=["selftest"], default="selftest")
+    p_cf = sub.add_parser("conformance", help="ISO/IEC 17025 7.8 certificate items and the ILAC-G8 decision rules: the self-test, or one decision")
+    p_cf.add_argument("--action", choices=["selftest", "decide"], default="selftest")
+    p_cf.add_argument("--value", type=float, default=None, help="decide: the measured value (a deviation; the tolerance is symmetric)")
+    p_cf.add_argument("--tolerance", type=float, default=None, help="decide: the tolerance limit TL")
+    p_cf.add_argument("--uncertainty", type=float, default=None, help="decide: the expanded uncertainty U of the value (omit: simple acceptance)")
+    p_cf.add_argument("--k", type=float, default=2.0)
+    p_cf.add_argument("--rule", choices=["simple-acceptance", "binary-guard-band", "non-binary-guard-band"], default="non-binary-guard-band")
+    p_cf.add_argument("--unit", type=str, default="")
     p_vib = sub.add_parser("vibration", help="machine vibration: ISO 20816-3 zone and bearing envelope analysis on a record, or the self-test")
     p_vib.add_argument("--action", choices=["selftest", "assess"], default="selftest")
     p_vib.add_argument("--record", type=str, default=None, help="assess: the record (CSV with a time column, or miniSEED/SAC)")
@@ -522,7 +530,7 @@ def main(argv=None) -> int:
 
     p_ce = sub.add_parser("certificates", help="calibration certificates per instrument: list, file one, status against today")
     p_ce.add_argument("--register", type=str, required=True, help="the well's certificates.jsonl")
-    p_ce.add_argument("--action", choices=["list", "add", "status"], default="list")
+    p_ce.add_argument("--action", choices=["list", "add", "status", "conformance"], default="list")
     p_ce.add_argument("--tag", type=str, default=None)
     p_ce.add_argument("--tags", type=str, default=None, help="comma-separated tags for --action status")
     p_ce.add_argument("--serial", type=str, default="")
@@ -536,6 +544,17 @@ def main(argv=None) -> int:
     p_ce.add_argument("--doc", type=str, default=None, help="the certificate file (hashed, not copied)")
     p_ce.add_argument("--note", type=str, default="")
     p_ce.add_argument("--actor", type=str, default="cli")
+    p_ce.add_argument("--calibrated", type=str, default="", help="ISO/IEC 17025 7.8.2.1 i: the date the calibration was performed")
+    p_ce.add_argument("--method", type=str, default="", help="7.8.2.1 f: the method used")
+    p_ce.add_argument("--authorised-by", type=str, default="", help="7.8.2.1 o: who authorised the certificate")
+    p_ce.add_argument("--uncertainty", type=float, default=None, help="7.8.4.1 a: the expanded uncertainty U, in --uncertainty-unit (default the result's unit)")
+    p_ce.add_argument("--uncertainty-unit", type=str, default="")
+    p_ce.add_argument("--k", type=float, default=None, help="7.8.4.1 a: the coverage factor U is stated at")
+    p_ce.add_argument("--probability", type=float, default=None, help="7.8.4.1 a: the coverage probability as a fraction (0.95)")
+    p_ce.add_argument("--conditions", type=str, default="", help="7.8.4.1 b: the conditions the calibration was made under")
+    p_ce.add_argument("--traceability", type=str, default="", help="7.8.4.1 c: the statement of metrological traceability, as the certificate words it")
+    p_ce.add_argument("--adjustment", type=str, default="", help="7.8.4.1 d: results before and after adjustment, if the certificate carries them")
+    p_ce.add_argument("--decision-rule", type=str, default="", help="7.8.6: the decision rule the certificate's conformity statement names, if any")
 
     p_tr = sub.add_parser("transient", help="shut-in detection and build-up analysis (Horner + Bourdet derivative with a bootstrap band)")
     p_tr.add_argument("--file", type=str, required=True, help="historian file")
@@ -773,7 +792,10 @@ def main(argv=None) -> int:
         if a.action == "add":
             try:
                 print(_json.dumps(reg.add(a.tag or "", a.serial, a.certificate, a.issued or "", a.valid_until or "", a.actor, a.lab,
-                                          a.accuracy_pct_fs, a.full_scale, a.unit, a.doc, a.note), indent=1))
+                                          a.accuracy_pct_fs, a.full_scale, a.unit, a.doc, a.note,
+                                          calibrated_utc=a.calibrated, method=a.method, authorised_by=a.authorised_by, uncertainty=a.uncertainty,
+                                          uncertainty_unit=a.uncertainty_unit, uncertainty_k=a.k, uncertainty_probability=a.probability,
+                                          conditions=a.conditions, traceability=a.traceability, adjustment=a.adjustment, decision_rule=a.decision_rule), indent=1))
             except (ValueError, TypeError) as e:
                 raise SystemExit(f"certificates: {e}")
             return 0
@@ -784,6 +806,13 @@ def main(argv=None) -> int:
                 print(f"{r['tag_id']:24s} {r['status']:9s} {r.get('certificate_id') or '-':16s} until {r.get('valid_until_utc') or '-'}  {('' if r['days_left'] is None else str(r['days_left']) + ' d')}")
             print(_json.dumps(CertificateRegister.summary(rows)))
             return 0 if CertificateRegister.summary(rows)['all_valid'] else 1
+        if a.action == "conformance":
+            from .conformance import report_lines
+            c = reg.conformance()
+            for r in c["rows"]:
+                print("\n".join(report_lines(r)))
+            print(f"certificates: {c['n']} filed, {c['complete']} COMPLETE against ISO/IEC 17025:2017 7.8" + (f"; incomplete: {', '.join(c['incomplete'])}" if c['incomplete'] else ''))
+            return 0 if not c["incomplete"] else 1
         for e in reg.list():
             print(f"{e['tag_id']:24s} {e['serial']:12s} {e['certificate_id']:16s} {e['issued_utc'][:10]} to {e['valid_until_utc'][:10]}  ±{e.get('accuracy_pct_fs') or '-'} % FS  {e.get('lab', '')}")
         print(f"certificates: {len(reg.list())} filed")
@@ -1524,6 +1553,23 @@ def main(argv=None) -> int:
             return 0
         print(f"notifications: {'configured' if n.cfg else 'not configured'}" + (f" - {len(n.cfg['channels'])} channel(s), {len(n.cfg['rules'])} rule(s), quiet {n.cfg['quiet_s']} s" if n.cfg else " (gea notify --example)"))
         return 0
+    elif a.cmd == "conformance":
+        from . import conformance as _C
+        if a.action == "decide":
+            if a.value is None or a.tolerance is None:
+                raise SystemExit("conformance --action decide needs --value and --tolerance")
+            d = _C.decide(a.value, a.tolerance, a.uncertainty, rule=a.rule, k=a.k if a.uncertainty is not None else None,
+                          probability=(0.95 if abs(a.k - 2.0) < 1e-9 else None) if a.uncertainty is not None else None, unit=a.unit)
+            print(d["statement"]); print(f"  {d['rule_text']}")
+            return 0 if d["outcome"] in ("PASS", "CONDITIONAL PASS") else 1
+        r = _C.selftest()
+        print(f"conformance selftest [{r['label']}]: {r['status']}")
+        for k, v in r["checks"].items():
+            print(f"  {'ok ' if v else 'BAD'} {k}")
+        print("\n".join(_C.report_lines(r["full"])))
+        for d in r["decisions"]:
+            print("  " + d["statement"])
+        return 0 if r["status"] == "OK" else 1
     elif a.cmd == "vibration":
         from . import vibration as _V
         if a.action == "assess":

{gea_program-0.14.0 → gea_program-0.15.0}/gea/acceptance_tests.py

@@ -2420,7 +2420,7 @@ def section_ah_band2(tmp: str) -> None:
            and Path(wsp, "wells", w1["id"], "records", "certificates", "CERT-1_cert1.txt").exists()
            and st2["P_raw_psi_S2"] == 48 and st2["P_raw_psi_S1"] == 240 and gd["instruments"]["swap_notes"][0]["samples_excluded"] == 192
            and [c["status"] for c in inst["certificate_status"]] == ["VALID", "VALID"] and not [c for c in inst["candidates"] if c["tag_id"] == "P_raw_psi_S2"]
-           and "Instruments: sensor swaps" in drift_html and "CERT-77" in drift_html and "Bias vs accuracy" in drift_html
+           and "Instruments: sensor swaps" in drift_html and "CERT-77" in drift_html and "Conformity" in drift_html and "ISO/IEC 17025 7.8" in drift_html
            and ptr and ptr["analyses"][0]["status"] == "OK" and abs(ptr["analyses"][0]["derived"]["k_md"] - k) / k < 0.05
            and ov["wells"][0]["instruments"]["swaps"] == 1 and ov["wells"][0]["transient"]["analysed"] == 1 and ov["site"]["certificates"]["counts"]["VALID"] == 2
            and "swap.add" in audit and "certificate.add" in audit and "transient.params" in audit,
@@ -5319,6 +5319,140 @@ def section_bh_vibration(tmp: str) -> None:
        "a channel that is not there; `gea vibration --action assess` reads a miniSEED record in counts with a declared sensitivity and says "
        "NOT ASSESSED without one; the self-test runs from the command line; the help page carries the boundaries and names the fault size it will not claim")
 
+
+def section_bi_conformance(tmp: str) -> None:
+    """Section BI - conformity in the standards' words: each certificate against the items ISO/IEC 17025:2017
+    7.8.2.1 and 7.8.4.1 ask it to carry, and the drift report's bias-against-class line as a statement of
+    conformity with its ILAC-G8 decision rule named, the uncertainty as the guard band, nothing assumed."""
+    import csv
+    import datetime as D
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import numpy as _np
+    from . import conformance as C
+    from . import helplib as H
+    from .certificates import CertificateRegister
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bi"); d.mkdir()
+
+    # -- the self-test and the rules --------------------------------------------------------------------
+    r = C.selftest()
+    ok(r["status"] == "OK" and all(r["checks"].values())
+       and [x["outcome"] for x in r["decisions"]] == ["PASS", "CONDITIONAL PASS", "CONDITIONAL FAIL", "FAIL", "PASS"]
+       and r["decisions"][4]["rule"] == "simple-acceptance"
+       and C.decide(8.0, 10.0, 2.0)["outcome"] == "PASS" and C.decide(8.0001, 10.0, 2.0)["outcome"] == "CONDITIONAL PASS"
+       and C.decide(10.0, 10.0, 2.0)["outcome"] == "CONDITIONAL PASS" and C.decide(10.0001, 10.0, 2.0)["outcome"] == "CONDITIONAL FAIL"
+       and C.decide(12.0, 10.0, 2.0)["outcome"] == "CONDITIONAL FAIL" and C.decide(12.0001, 10.0, 2.0)["outcome"] == "FAIL"
+       and C.decide(10.0, 10.0, 2.0, rule="simple-acceptance")["outcome"] == "PASS" and C.decide(8.5, 10.0, 2.0, rule="binary-guard-band")["outcome"] == "FAIL"
+       and len(C.CERTIFICATE_CLAUSES) == 14 and {c[0].split(" ")[0] for c in C.CERTIFICATE_CLAUSES} == {"7.8.2.1", "7.8.4.1"}
+       and all(k in " ".join(x[1] for x in C.CERTIFICATE_CLAUSES) for k in ("uncertainty", "traceability", "conditions", "adjustment", "decision_rule", "authorised_by", "method", "calibrated_utc")),
+       "BI1 the ILAC-G8:09/2019 rules give the four outcomes at their boundaries (PASS to TL - U, CONDITIONAL PASS to TL, CONDITIONAL FAIL to TL + U, "
+       "FAIL above), simple acceptance ignores U and says so, the binary rule fails inside the guard band; the certificate items are the fourteen of "
+       "ISO/IEC 17025:2017 7.8.2.1 and 7.8.4.1 - identification, laboratory, item, dates, result, method, authorisation, uncertainty with its "
+       "coverage factor, conditions, traceability, adjustment, decision rule - and a full certificate is COMPLETE, a thin one INCOMPLETE with the "
+       "missing clauses named, an entry filed before the fields existed NOT RECORDED rather than NOT CARRIED")
+
+    # -- the register: the fields recorded from the paper, nothing invented ------------------------------
+    reg = CertificateRegister(str(d / "certs.jsonl"))
+    e1 = reg.add("P1", "S1", "C-1", "2026-01-10", "2027-01-10", "tester", "Acme Cal", 0.1, 10000.0, "psi",
+                 uncertainty=2.5, uncertainty_k=2.0, uncertainty_probability=0.95, traceability="NIST via DWT 1234", conditions="23 ± 1 °C",
+                 calibrated_utc="2026-01-09", method="comparison", authorised_by="J. Doe", adjustment="as found / as left", decision_rule="simple acceptance")
+    e2 = reg.add("P2", "S2", "C-2", "2026-01-10", "2027-01-10", "tester", "Acme Cal", 0.1, 10000.0, "psi")
+    bad = []
+    for kw in ({"uncertainty_k": 0}, {"uncertainty_probability": 1.5}, {"uncertainty": -1}, {"nonsense": "x"}):
+        try:
+            reg.add("P3", "S3", "C-3", "2026-01-10", "2027-01-10", "tester", **kw); bad.append(False)
+        except ValueError:
+            bad.append(True)
+    st = {x["tag_id"]: x for x in reg.status(["P1", "P2"], now=D.datetime(2026, 6, 1, tzinfo=D.timezone.utc))}
+    conf = reg.conformance()
+    r1 = _sp.run([sys.executable, "-m", "gea", "certificates", "--register", str(d / "certs.jsonl"), "--action", "conformance"], capture_output=True, text=True)
+    r2 = _sp.run([sys.executable, "-m", "gea", "certificates", "--register", str(d / "cli.jsonl"), "--action", "add", "--tag", "P9", "--serial", "S9", "--certificate", "C-9",
+                  "--issued", "2026-01-10", "--valid-until", "2027-01-10", "--lab", "Cal Lab GmbH", "--accuracy-pct-fs", "0.05", "--full-scale", "5000", "--unit", "psi", "--uncertainty", "1.2",
+                  "--k", "2", "--probability", "0.95", "--traceability", "PTB via transfer standard 7", "--conditions", "21 °C", "--calibrated", "2026-01-08",
+                  "--method", "comparison", "--authorised-by", "A. B."], capture_output=True, text=True)
+    r3 = _sp.run([sys.executable, "-m", "gea", "certificates", "--register", str(d / "cli.jsonl"), "--action", "conformance"], capture_output=True, text=True)
+    r4 = _sp.run([sys.executable, "-m", "gea", "conformance", "--action", "decide", "--value", "11", "--tolerance", "10", "--uncertainty", "2", "--unit", "psi"], capture_output=True, text=True)
+    r5 = _sp.run([sys.executable, "-m", "gea", "conformance"], capture_output=True, text=True)
+    ok(e1["uncertainty"] == 2.5 and e1["uncertainty_k"] == 2.0 and e1["traceability"] == "NIST via DWT 1234" and e2["uncertainty"] is None and e2["traceability"] == ""
+       and all(bad) and st["P1"]["iso17025"]["status"] == "COMPLETE" and st["P1"]["iso17025"]["carried"] == 14
+       and st["P2"]["iso17025"]["status"] == "INCOMPLETE" and any("7.8.4.1 c" in m for m in st["P2"]["iso17025"]["missing"]) and st["P2"]["uncertainty"] is None
+       and conf["n"] == 2 and conf["complete"] == 1 and conf["incomplete"] == ["C-2"]
+       and r1.returncode == 1 and "C-1 (serial S1, tag P1): COMPLETE - 14 of 14" in r1.stdout and "NOT CARRIED  a statement identifying how the measurements are metrologically traceable" in r1.stdout
+       and r2.returncode == 0 and r3.returncode == 0 and "1 COMPLETE" in r3.stdout
+       and r4.returncode == 1 and "CONDITIONAL FAIL" in r4.stdout and "acceptance limit 8 psi" in r4.stdout
+       and r5.returncode == 0 and "conformance selftest [SELF_TEST]: OK" in r5.stdout,
+       "BI2 the register takes what 7.8.4 asks the paper to carry - the expanded uncertainty with its coverage factor and probability, the "
+       "traceability statement as worded, the conditions, the calibration date, the method, who authorised it, the adjustment results, the "
+       "decision rule - rejects a k of zero, a probability above one, a negative uncertainty and a field it does not know, leaves empty what was "
+       "not filed, and every status row carries the certificate's 7.8 standing; `gea certificates --action conformance` prints it item by item "
+       "and exits 1 while any certificate is incomplete; `gea conformance --action decide` states one decision from the command line")
+
+    # -- the drift report: the statement of conformity with its rule named ----------------------------------
+    rng = _np.random.default_rng(5)
+    n = 240
+    t0 = D.datetime(2026, 3, 1, tzinfo=D.timezone.utc)
+    hist = d / "hist.csv"
+    base = 3000.0 + 0.2 * _np.sin(_np.arange(n) / 24.0)
+    with open(hist, "w", newline="") as f:
+        w = csv.writer(f); w.writerow(["timestamp_utc", "P_raw_psi_S1", "P_raw_psi_S2", "T_raw_F_S1"])
+        for i in range(n):
+            w.writerow([(t0 + D.timedelta(hours=i)).strftime("%Y-%m-%dT%H:%M:%SZ"), round(base[i] + rng.normal(0, 0.8), 2), round(base[i] + 1.5 + rng.normal(0, 0.8), 2), round(80 + 0.1 * rng.normal(), 2)])
+    wsp = str(d / "ws")
+    ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w1 = ws.add_well_file(str(hist), display="Well BI", actor="tester")
+    users = Users(str(Path(wsp, "users.json"))); users.add("op1", "operator-pass-1", "operator")
+    svc = Service(wsp, host="127.0.0.1", port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+    def call(method, path, body=None):
+        req = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        req.add_header("Content-Type", "application/json")
+        if method == "POST":
+            req.add_header("X-GEA-Action", "1")
+        try:
+            with opener.open(req, timeout=600) as rr:
+                return rr.status, json.loads(rr.read())
+        except urllib.error.HTTPError as ex:
+            return ex.code, json.loads(ex.read())
+    try:
+        call("POST", "/api/login", {"name": "op1", "password": "operator-pass-1"})
+        s_c1, _ = call("POST", f"/api/wells/{w1['id']}/certificates", {"tag_id": "P_raw_psi_S1", "serial": "SN-1", "certificate_id": "CERT-A", "issued_utc": "2026-01-01",
+                                                                       "valid_until_utc": "2027-01-01", "lab": "LabX", "accuracy_pct_fs": 0.02, "full_scale": 10000, "unit": "psi",
+                                                                       "uncertainty": "0.5", "uncertainty_k": "2", "uncertainty_probability": "0.95", "traceability": "NIST via DWT",
+                                                                       "conditions": "23 °C", "calibrated_utc": "2025-12-30", "method": "comparison", "authorised_by": "Q. A."})
+        s_c2, _ = call("POST", f"/api/wells/{w1['id']}/certificates", {"tag_id": "P_raw_psi_S2", "serial": "SN-2", "certificate_id": "CERT-B", "issued_utc": "2026-01-01",
+                                                                       "valid_until_utc": "2027-01-01", "lab": "LabX", "accuracy_pct_fs": 0.02, "full_scale": 10000, "unit": "psi"})
+        call("POST", "/api/refresh", {})
+        svc.app.runner.wait(svc.app.runner.list(1)[0]["id"], 600)
+        inst = call("GET", f"/api/wells/{w1['id']}/instruments")[1]
+        drift_md = Path(wsp, "reports", "wells", w1["id"], "gauge_drift_report.md").read_text(encoding="utf-8")
+        drift_html = Path(wsp, "reports", "wells", w1["id"], "gauge_drift_report.html").read_text(encoding="utf-8")
+        page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+        by = inst["iso17025"]["by_certificate"]
+        ok(s_c1 == 200 and s_c2 == 200 and inst["iso17025"]["n"] == 2 and inst["iso17025"]["complete"] == 1 and inst["iso17025"]["incomplete"] == ["CERT-B"]
+           and by["CERT-A"]["status"] == "COMPLETE" and by["CERT-B"]["status"] == "INCOMPLETE"
+           and "Conformity" in drift_md and "ISO/IEC 17025 7.8" in drift_md and "decision rule: non-binary-guard-band (ILAC-G8:09/2019)" in drift_md
+           and "bias of P_raw_psi_S1 over the evaluation window" in drift_md and "with expanded uncertainty U = " in drift_md and "(k = 2, 95%)" in drift_md
+           and "tolerance limit 2 psi" in drift_md and "acceptance limit" in drift_md and "COMPLETE (12/14)" in drift_md and "INCOMPLETE (5/14)" in drift_md and by["CERT-A"]["carried"] == 12
+           and ("CONDITIONAL" in drift_md or "PASS" in drift_md or "FAIL" in drift_md) and "ISO/IEC 17025:2017 7.8.6" in drift_html
+           and "ctUnc" in page_src and "ctTrace" in page_src and "uncertainty_k" in page_src and "ISO/IEC 17025 7.8" in page_src
+           and any(t["topic"] == "conformance" for t in H.topics()) and not H.check("conformance")
+           and "simple acceptance" in (pkg / "help" / "conformance.md").read_text(encoding="utf-8").split("will not call a measurement")[1],
+           "BI3 through the API: a certificate filed with its uncertainty, coverage factor and traceability is COMPLETE and one filed without them is "
+           "INCOMPLETE; the instruments answer carries every certificate's 7.8 standing; the drift report's bias line is a statement of conformity "
+           "in 7.8.6's words - the result it applies to with its sample count, the certificate's class as the tolerance limit, the bias's expanded "
+           "uncertainty at k = 2, the ILAC-G8 non-binary guard-band rule and the acceptance limit - beside the certificate's own 7.8 standing; the "
+           "page's filing form takes the 7.8.4 items and its table shows U (k) and the standing; the help page names simple acceptance as the "
+           "fallback it will not dress up")
+    finally:
+        svc.stop()
+
 def main() -> int:
     print("GEA-Program - ACCEPTANCE SUITE (the product gate)")
     # a handle a job subprocess still holds at the end must not turn a finished gate into a traceback on Windows:
@@ -5382,6 +5516,7 @@ def main() -> int:
         section_bf_quakeml(tmp)
         section_bg_ppdm(tmp)
         section_bh_vibration(tmp)
+        section_bi_conformance(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.14.0 → gea_program-0.15.0}/gea/certificates.py

@@ -64,9 +64,14 @@ class CertificateRegister:
                     continue
         return out
 
+    # what ISO/IEC 17025:2017 7.8 asks a calibration certificate to carry beyond the fields above (v0.15.0):
+    # recorded from the paper by the operator, empty when the paper does not carry it. None of it is invented.
+    CLAUSE_FIELDS = ('calibrated_utc', 'method', 'authorised_by', 'uncertainty', 'uncertainty_unit', 'uncertainty_k', 'uncertainty_probability',
+                     'conditions', 'traceability', 'adjustment', 'decision_rule')
+
     def add(self, tag_id: str, serial: str, certificate_id: str, issued_utc: str, valid_until_utc: str, actor: str,
             lab: str = '', accuracy_pct_fs: Optional[float] = None, full_scale: Optional[float] = None, unit: str = '',
-            file_path: Optional[str] = None, note: str = '') -> dict:
+            file_path: Optional[str] = None, note: str = '', **clauses) -> dict:
         if not (tag_id and serial and certificate_id):
             raise ValueError('a certificate needs the tag id, the instrument serial and the certificate id')
         issued, until = _parse(issued_utc), _parse(valid_until_utc)
@@ -79,6 +84,20 @@ class CertificateRegister:
              'full_scale': (float(full_scale) if full_scale is not None else None), 'unit': unit,
              'file': os.path.basename(file_path) if file_path else '', 'file_sha256': _sha(file_path) if file_path and os.path.isfile(file_path) else '',
              'filed_by': actor, 'filed_utc': _iso(datetime.now(timezone.utc)), 'note': note}
+        unknown = sorted(set(clauses) - set(self.CLAUSE_FIELDS))
+        if unknown:
+            raise ValueError(f'unknown certificate field(s): {", ".join(unknown)}')
+        for k in self.CLAUSE_FIELDS:
+            v = clauses.get(k)
+            if k in ('uncertainty', 'uncertainty_k', 'uncertainty_probability') and v not in (None, ''):
+                v = float(v)
+                if k == 'uncertainty_k' and not (0 < v <= 10):
+                    raise ValueError('the coverage factor k is between 0 and 10')
+                if k == 'uncertainty_probability' and not (0 < v < 1):
+                    raise ValueError('the coverage probability is a fraction between 0 and 1')
+                if k == 'uncertainty' and v <= 0:
+                    raise ValueError('the expanded uncertainty is a positive value')
+            e[k] = (v if v not in (None,) else None) if k in ('uncertainty', 'uncertainty_k', 'uncertainty_probability') else (str(v) if v is not None else '')
         if any(x['certificate_id'] == certificate_id and x['serial'] == serial for x in self.list()):
             raise ValueError(f'certificate already filed: {certificate_id} for serial {serial}')
         os.makedirs(os.path.dirname(self.path) or '.', exist_ok=True)
@@ -110,11 +129,21 @@ class CertificateRegister:
                 continue
             days = (_parse(e['valid_until_utc']) - now).total_seconds() / 86400.0
             st = 'EXPIRED' if days < 0 else ('EXPIRING' if days <= self.warn_days else 'VALID')
+            from .conformance import certificate_conformance
+            cf = certificate_conformance(e)
             rows.append({'tag_id': tag, 'status': st, 'days_left': int(days), 'certificate_id': e['certificate_id'], 'serial': e['serial'],
                          'accuracy_pct_fs': e.get('accuracy_pct_fs'), 'full_scale': e.get('full_scale'), 'unit': e.get('unit'),
-                         'valid_until_utc': e['valid_until_utc'], 'lab': e.get('lab', '')})
+                         'valid_until_utc': e['valid_until_utc'], 'lab': e.get('lab', ''),
+                         'uncertainty': e.get('uncertainty'), 'uncertainty_k': e.get('uncertainty_k'), 'uncertainty_probability': e.get('uncertainty_probability'),
+                         'traceability': e.get('traceability', ''),
+                         'iso17025': {'status': cf['status'], 'carried': cf['carried'], 'n_items': cf['n_items'], 'missing': cf['missing']}})
         return rows
 
+    def conformance(self) -> dict:
+        """Every filed certificate against ISO/IEC 17025:2017 7.8, item by item."""
+        from .conformance import register_conformance
+        return register_conformance(self.list())
+
     @staticmethod
     def summary(rows: List[dict]) -> dict:
         c = {s: 0 for s in STATUSES}

{gea_program-0.14.0 → gea_program-0.15.0}/gea/client_reports.py

@@ -349,15 +349,28 @@ def gauge_drift_report(evaluation: dict, stream, catalogue: Optional[TagCatalogu
     if inst.get('swaps') or inst.get('certificates') or inst.get('swap_notes'):
         by_station = {st['channel']: st for st in stations}
         cert_rows = []
+        statements = []
+        from .conformance import decide as _decide, expanded_uncertainty as _eu
         for c in inst.get('certificates', []):
             st = by_station.get(c['tag_id'])
             band = None
             if c.get('accuracy_pct_fs') is not None and c.get('full_scale'):
                 band = float(c['accuracy_pct_fs']) / 100.0 * float(c['full_scale'])
-            inside = (abs(st.get('bias_psi') or 0) <= band) if (st and band is not None and st.get('bias_psi') is not None) else None
+            # the statement of conformity, with its decision rule named (ISO/IEC 17025:2017 7.8.6; ILAC-G8:09/2019):
+            # the bias over the window against the certificate's accuracy class, the bias's expanded uncertainty as the guard band
+            outcome = '-'
+            if st and band is not None and st.get('bias_psi') is not None:
+                eu = _eu(st.get('noise_sigma_psi'), st.get('n'))
+                dec = _decide(float(st['bias_psi']), band, eu['U'] if eu else None, k=(eu['k'] if eu else None), probability=(eu['probability'] if eu else None),
+                              unit='psi', what=f"bias of {c['tag_id']} over the evaluation window ({st.get('n') or '?'} samples)",
+                              spec=f"certificate {c.get('certificate_id') or '-'}: ±{_fmt(c['accuracy_pct_fs'])} % FS = ±{_fmt(band)} psi")
+                outcome = dec['outcome']
+                statements.append(dec['statement'] + '.')
+            iso = c.get('iso17025') or {}
             cert_rows.append([c['tag_id'], c.get('serial') or '-', c.get('certificate_id') or '-', c['status'],
                               c.get('valid_until_utc') or '-', (f"±{_fmt(c['accuracy_pct_fs'])} % FS" + (f" = ±{_fmt(band)}" if band is not None else '')) if c.get('accuracy_pct_fs') is not None else '-',
-                              _fmt(st.get('bias_psi')) if st else '-', ('inside' if inside else 'OUTSIDE') if inside is not None else '-'])
+                              _fmt(st.get('bias_psi')) if st else '-', outcome,
+                              (f"{iso.get('status')} ({iso.get('carried')}/{iso.get('n_items')})" if iso else '-')])
         swap_rows = [[e['swap_utc'], e['tag_id'], e.get('old_serial') or '-', e['new_serial'], e.get('certificate_id') or '-', e.get('recorded_by'), e.get('note', '')]
                      for e in inst.get('swaps', [])]
         note_rows = [[n['tag_id'], n.get('swap_utc') or '-', _fmt(n.get('samples_excluded')), _fmt(n.get('samples_kept')), 'applied' if n.get('applied') else n.get('reason', '')]
@@ -368,10 +381,15 @@ def gauge_drift_report(evaluation: dict, stream, catalogue: Optional[TagCatalogu
         if note_rows:
             tables.append(Table(['Tag', 'Fit starts at', 'Samples before (excluded)', 'Samples used', 'Applied'], note_rows, caption='Effect on this evaluation'))
         if cert_rows:
-            tables.append(Table(['Tag', 'Serial', 'Certificate', 'Status', 'Valid until', 'Stated accuracy', 'Measured bias (psi)', 'Bias vs accuracy'], cert_rows, caption='Calibration certificates'))
+            tables.append(Table(['Tag', 'Serial', 'Certificate', 'Status', 'Valid until', 'Stated accuracy', 'Measured bias (psi)', 'Conformity', 'ISO/IEC 17025 7.8'], cert_rows, caption='Calibration certificates'))
         cand = inst.get('candidates', [])
         par = ['A swapped gauge is a new instrument: the evaluation above fits only the samples after each tag\'s latest recorded swap. '
-               'A certificate\'s stated accuracy is printed beside the measured bias so a reader sees whether the bias is inside the instrument\'s own class.']
+               'A certificate\'s stated accuracy is printed beside the measured bias, and the conformity column is a statement of conformity in the '
+               'words of ISO/IEC 17025:2017 7.8.6: the result it applies to, the specification, and the decision rule, which is ILAC-G8:09/2019 '
+               'non-binary with a guard band equal to the bias\'s expanded uncertainty (k = 2, from the noise and the sample count) - PASS, '
+               'CONDITIONAL PASS, CONDITIONAL FAIL or FAIL. Without an uncertainty the rule falls back to simple acceptance and the statement says so. '
+               'The last column is the certificate itself against the items 7.8.2.1 and 7.8.4.1 ask it to carry, as the operator recorded them.']
+        par += statements
         if cand:
             par.append(f"{len(cand)} unconfirmed swap candidate(s) proposed by the step detector (not applied): "
                        + '; '.join(f"{c['tag_id']} at {c.get('swap_utc') or c['elapsed_s']} ({c['step']:+g} {c['unit']}, {c['confidence']})" for c in cand[:6]) + '.')