gea-program 0.30.1__tar.gz → 0.31.0__tar.gz

{gea_program-0.30.1/gea_program.egg-info → gea_program-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.30.1
+Version: 0.31.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 (377 checks)
+gea accept                     # the product gate (380 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]")
@@ -650,8 +650,26 @@ itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 
 ### Tools and ports
 
-The Tools & ports tab (`#/tools`, `gea tools`) is the program's two
-registers in one place: the tool library - every downhole and surface tool
+The Tools & ports tab (`#/tools`, `gea tools`) opens on the **downhole tool
+library**: every class of downhole tool in use across the industry - bits
+and hole openers, motors and rotary steerable systems, MWD and LWD, the drill
+string and its subs, casing and cementing equipment, completion and
+artificial lift, wireline and cased-hole tools, fishing and milling, test
+tools - ninety-six classes in nine categories. Point at a tool, or Tab to
+it, for a one-line description; click, tap or press Enter for its tutorial:
+what it is, where it runs, how it works, what it shows in the data, what to
+watch, and what this program does with it, with the published figures
+quoted from the pages they cite and the pages themselves. The tutorials
+carry no numbers of their own; a figure on a tool's card is the cited page's
+words, most often one maker's product, never a limit for the class. Your
+**fleet** - the tools you actually run - goes in beside the classes, each
+with its maker, model, serial and the datasheet that rates it
+(`gea tools --action fleet-add --workspace C:\site --class pdm_motor
+--maker ... --model ... --datasheet ...`, or from the tutorial), kept in the
+workspace and audited. `gea tools --action classes`, `--action tutorial
+--class drilling_jar`.
+
+Below it are the program's two registers: the gauge library - every gauge
 with its source citation, ratings, what it measures, the telemetry interface
 it declares and its datasheet aging rate where the vendor published one -
 and the ports, the file formats read and the eleven live protocols spoken,

{gea_program-0.30.1 → gea_program-0.31.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 (377 checks)
+gea accept                     # the product gate (380 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]")
@@ -611,8 +611,26 @@ itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 
 ### Tools and ports
 
-The Tools & ports tab (`#/tools`, `gea tools`) is the program's two
-registers in one place: the tool library - every downhole and surface tool
+The Tools & ports tab (`#/tools`, `gea tools`) opens on the **downhole tool
+library**: every class of downhole tool in use across the industry - bits
+and hole openers, motors and rotary steerable systems, MWD and LWD, the drill
+string and its subs, casing and cementing equipment, completion and
+artificial lift, wireline and cased-hole tools, fishing and milling, test
+tools - ninety-six classes in nine categories. Point at a tool, or Tab to
+it, for a one-line description; click, tap or press Enter for its tutorial:
+what it is, where it runs, how it works, what it shows in the data, what to
+watch, and what this program does with it, with the published figures
+quoted from the pages they cite and the pages themselves. The tutorials
+carry no numbers of their own; a figure on a tool's card is the cited page's
+words, most often one maker's product, never a limit for the class. Your
+**fleet** - the tools you actually run - goes in beside the classes, each
+with its maker, model, serial and the datasheet that rates it
+(`gea tools --action fleet-add --workspace C:\site --class pdm_motor
+--maker ... --model ... --datasheet ...`, or from the tutorial), kept in the
+workspace and audited. `gea tools --action classes`, `--action tutorial
+--class drilling_jar`.
+
+Below it are the program's two registers: the gauge library - every gauge
 with its source citation, ratings, what it measures, the telemetry interface
 it declares and its datasheet aging rate where the vendor published one -
 and the ports, the file formats read and the eleven live protocols spoken,

{gea_program-0.30.1 → gea_program-0.31.0}/gea/__init__.py

@@ -123,7 +123,7 @@ from .profile_catalog import (
     read_pangaea_txt,
 )
 
-__version__ = "0.30.1"
+__version__ = "0.31.0"
 __all__ = [
     "aging_rate", "rate_psi_yr", "accuracy_psi",
     "Sensor", "SimulatorConfig", "DownholeEngine",

{gea_program-0.30.1 → gea_program-0.31.0}/gea/__main__.py

@@ -285,6 +285,17 @@ def main(argv=None) -> int:
     p_tl.add_argument("--station", type=str, action="append", default=None, help="a station as DEPTH_FT:TOOL, e.g. 9850:quartz_pt_geoq177_16k")
     p_tl.add_argument("--surface-temp-f", type=float, default=75.0); p_tl.add_argument("--temp-gradient-f-ft", type=float, default=0.018)
     p_tl.add_argument("--surface-pressure-psi", type=float, default=14.7); p_tl.add_argument("--pressure-gradient-psi-ft", type=float, default=0.465)
+    p_tl.add_argument("--action", choices=["classes", "tutorial", "fleet", "fleet-add", "fleet-remove"], default=None,
+                      help="the downhole tool classes in use across the industry: classes (--category, --find), tutorial --class ID, and the workspace's own fleet (fleet, fleet-add, fleet-remove)")
+    p_tl.add_argument("--category", type=str, default=None, help="classes: one category (bits, drive, measure, bha, casing, completion, logging, fishing, testing)")
+    p_tl.add_argument("--find", type=str, default="", help="classes: words to look for in the name and description")
+    p_tl.add_argument("--class", dest="class_id", type=str, default=None, help="tutorial / fleet-add: the tool class id, e.g. pdm_motor")
+    p_tl.add_argument("--workspace", type=str, default=None, help="fleet actions: the workspace folder")
+    p_tl.add_argument("--maker", type=str, default=""); p_tl.add_argument("--model", type=str, default="")
+    p_tl.add_argument("--datasheet", type=str, default="", help="fleet-add: the datasheet that rates the tool - title and revision, or its URL (required)")
+    p_tl.add_argument("--serial", type=str, default=""); p_tl.add_argument("--od-in", type=float, default=None); p_tl.add_argument("--note", type=str, default="")
+    p_tl.add_argument("--id", type=str, default=None, help="fleet-remove: the fleet tool id (gea tools --action fleet lists them)")
+    p_tl.add_argument("--actor", type=str, default="cli")
     p_cc = sub.add_parser("comcat", help="USGS ComCat / any FDSN event service: --lat --lon --radius-km --start --end prints the text-format query to open; --file reads the export it returns")
     p_cc.add_argument("--lat", type=float, default=None); p_cc.add_argument("--lon", type=float, default=None); p_cc.add_argument("--radius-km", type=float, default=25.0)
     p_cc.add_argument("--start", type=str, default=None); p_cc.add_argument("--end", type=str, default=None); p_cc.add_argument("--min-mag", type=float, default=1.0)
@@ -2374,6 +2385,71 @@ def main(argv=None) -> int:
     elif a.cmd == "tools":
         import json as _json
         from . import tool_catalog as _TC
+        if a.action:
+            from . import tool_taxonomy as _TX
+            from .cli import _safe_stdout
+            _safe_stdout()                                  # the cited figures carry fractions and degree signs
+            if a.action == "classes":
+                cs = _TX.classes(a.category, a.find)
+                if a.category and a.category not in _TX.CATEGORY_NAMES:
+                    raise SystemExit(f"tools: no category {a.category!r}; one of {', '.join(_TX.CATEGORY_NAMES)}")
+                if a.json:
+                    print(_json.dumps(cs, indent=1)); return 0
+                sm = _TX.summary()
+                print(f"{len(cs)} of {sm['classes']} tool classes; {sm['sources']} pages checked (fetched {sm['sources_fetched']}); {sm['figures']} published figures, each quoted from its page")
+                last = None
+                for t in cs:
+                    if t["category"] != last:
+                        print(f"\n{t['category_name']}"); last = t["category"]
+                    print(f"  {t['id']:<24s} {t['name']}")
+                    print(f"      {t['one_line']}")
+                print("\n`gea tools --action tutorial --class ID` opens one.")
+                return 0
+            if a.action == "tutorial":
+                if not a.class_id:
+                    raise SystemExit("tools: tutorial needs --class, e.g. --class pdm_motor (gea tools --action classes lists them)")
+                try:
+                    if a.json:
+                        print(_json.dumps(_TX.tool_class(a.class_id), indent=1)); return 0
+                    print(_TX.tutorial_text(a.class_id))
+                except KeyError as e:
+                    raise SystemExit(f"tools: {e.args[0]}")
+                return 0
+            if not a.workspace:
+                raise SystemExit(f"tools: --action {a.action} needs --workspace, e.g. --workspace C:\\site")
+            from .workspace import Workspace, WorkspaceError
+            try:
+                ws = Workspace(a.workspace)
+            except WorkspaceError as e:
+                raise SystemExit(f"tools: {e}")
+            if a.action == "fleet":
+                fl = _TX.fleet_list(ws.path)
+                if a.json:
+                    print(_json.dumps(fl, indent=1)); return 0
+                if not fl:
+                    print("the fleet is empty: gea tools --action fleet-add --workspace ... --class pdm_motor --maker ... --model ... --datasheet ...")
+                for t in fl:
+                    print(f"{t['id']:<32s} {t['class_name']}  -  {t['maker']} {t['model']}" + (f" s/n {t['serial']}" if t['serial'] else '') + (f", {t['od_in']:g} in OD" if t['od_in'] else ''))
+                    print(f"      datasheet: {t['datasheet']}")
+                return 0
+            if a.action == "fleet-add":
+                try:
+                    rec = _TX.fleet_add(ws.path, a.class_id or "", a.maker, a.model, a.datasheet, serial=a.serial, od_in=a.od_in, note=a.note, actor=a.actor)
+                except ValueError as e:
+                    raise SystemExit(f"tools: {e}")
+                ws.audit(a.actor, 'fleet.add', {'id': rec['id'], 'class': rec['class_id'], 'datasheet': rec['datasheet']})
+                print(f"added {rec['id']}: {rec['maker']} {rec['model']} ({rec['class_name']}); datasheet {rec['datasheet']}")
+                return 0
+            if a.action == "fleet-remove":
+                if not a.id:
+                    raise SystemExit("tools: fleet-remove needs --id (gea tools --action fleet lists them)")
+                try:
+                    rec = _TX.fleet_remove(ws.path, a.id)
+                except ValueError as e:
+                    raise SystemExit(f"tools: {e}")
+                ws.audit(a.actor, 'fleet.remove', {'id': rec['id'], 'class': rec['class_id']})
+                print(f"removed {rec['id']}")
+                return 0
         if a.rating or a.station:
             stations = []
             for spec in (a.station or []):

{gea_program-0.30.1 → gea_program-0.31.0}/gea/acceptance_tests.py

@@ -7856,6 +7856,155 @@ def section_by_edr(tmp: str) -> None:
        + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
 
 
+
+def section_bz_tool_library(tmp: str) -> None:
+    """Section BZ - the downhole tool library: every class of downhole tool in use across the industry, a one-line
+    description on hover and a tutorial that opens on a click, the published figures quoted from the pages they cite and
+    nothing more, and the operator's own fleet tied to the classes and to the datasheets that rate them."""
+    import http.cookiejar
+    import re as _re
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    from urllib.parse import urlparse
+    from . import tool_taxonomy as TX
+    from . import helplib as H
+    from .client_reports import FORBIDDEN_TERMS
+    from .tool_library import TOOL_LIBRARY
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bz"); d.mkdir()
+
+    def _raises(fn, exc, words=""):
+        try:
+            fn()
+        except exc as e:
+            return words in str(e)
+        return False
+
+    sm = TX.summary()
+    cls = list(TX.TAXONOMY.values())
+    prose = lambda t: " ".join([t["one_line"]] + [t["tutorial"][p] for p in TX.PARTS])
+    lowtier = _re.compile(r"(wikipedia\.org|rigzone\.com|drillingmanual\.com|petroleumacronyms|turbodrill\.com)$")
+    figs = [f for t in cls for f in t["figures"]]
+    c1 = {
+        "breadth": sm["classes"] >= 90 and len(sm["categories"]) == 9 and all(c["classes"] >= 1 for c in sm["categories"])
+                   and {"pdm_motor", "rss_push", "mwd_mud_pulse", "lwd_gamma", "drilling_jar", "production_packer", "esp", "perforating_gun",
+                        "pdg", "wl_formation_tester", "cbl", "overshot", "dst"} <= set(TX.TAXONOMY),
+        "hover": all(0 < len(t["one_line"]) <= 140 for t in cls),
+        "tutorial": all(all(len(t["tutorial"][p]) > 20 for p in TX.PARTS) for t in cls) and TX.PARTS == ("what", "where", "how", "reads", "watch", "program"),
+        "no_numbers_in_prose": not any(_re.search(r"\d", prose(t)) for t in cls),
+        "words": not any(w in (t["name"] + " " + prose(t)).lower() for t in cls for w in FORBIDDEN_TERMS),
+        "sources": all(t["sources"] for t in cls) and all(urlparse(x["url"]).scheme == "https" and x.get("publisher") for t in cls for x in t["sources"])
+                   and not any(lowtier.search(urlparse(x["url"]).netloc.lower()) for t in cls for x in t["sources"])
+                   and (pkg / "reference" / "tool_sources.json").is_file() and sm["sources"] >= 150 and sm["sources_fetched"] == "2026-10-14",
+        "figures": len(figs) == sm["figures"] and len(figs) >= 150 and all(f.get("quote") and f.get("url") and f.get("publisher") and f.get("what") for f in figs)
+                   and not any("..." in f["quote"] for f in figs)
+                   and all(("not a limit for the class" in t["figures_note"]) if t["figures"] else ("supply your model's datasheet" in t["figures_note"]) for t in cls),
+        "lookup": [t["id"] for t in TX.classes("drive")][:1] == ["pdm_motor"] and {t["id"] for t in TX.classes(None, "packer")} >= {"production_packer"}
+                  and TX.classes(None, "no such tool zzz") == [],
+        "unknown": _raises(lambda: TX.tool_class("no_such_tool"), KeyError),
+        "text": all(TX.PART_TITLES[p] + ": " in TX.tutorial_text("pdm_motor") for p in TX.PARTS) and "Sources (fetched 2026-10-14)" in TX.tutorial_text("pdm_motor")
+                and "Published figures (" in TX.tutorial_text("agitator") and "8-12 Hz" in TX.tutorial_text("agitator"),
+        "gauges": all(TX.GAUGE_CLASS_TO_TAXONOMY.get(t.tool_class) in TX.TAXONOMY for t in TOOL_LIBRARY.values()),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BZ1 the downhole tool library: at least ninety classes in nine categories from bits to test tools, each with a one-line description for the hover "
+       "and a six-part tutorial for the pop-open; the prose carries no number at all and none of the words a client report may not; every class checked "
+       "against at least one public page (none of them an encyclopaedia or a re-publisher); every published figure is the cited page's own words with its "
+       "unit and page, never a limit for the class, and a class with none says to supply the datasheet; the classes searchable; an unknown class named; "
+       "every gauge in the gauge library opens its class's tutorial"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    wsp = str(d / "ws"); Workspace.create(wsp, "Pad 3", actor="tester")
+    e_ds = _raises(lambda: TX.fleet_add(wsp, "pdm_motor", "Acme", "M1", ""), ValueError, "datasheet")
+    e_cls = _raises(lambda: TX.fleet_add(wsp, "warp_drive", "Acme", "M1", "sheet"), ValueError, "no tool class")
+    r1 = TX.fleet_add(wsp, "pdm_motor", "Acme", "M1", "Acme M1 datasheet rev B", serial="A100", od_in=6.75)
+    e_dup = _raises(lambda: TX.fleet_add(wsp, "pdm_motor", "Acme", "M1", "Acme M1 datasheet rev B", serial="A100"), ValueError, "already")
+    users = Users(str(Path(wsp, "users.json"))); users.add("op", "operator-pass-1", "operator"); users.add("v", "viewer-pass-1", "viewer")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def session():
+        o = 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"); req.add_header("X-GEA-Action", "1")
+            try:
+                with o.open(req, timeout=60) as rr_:
+                    return rr_.status, json.loads(rr_.read())
+            except urllib.error.HTTPError as e:
+                return e.code, json.loads(e.read())
+        return call
+    try:
+        view, op = session(), session()
+        view("POST", "/api/login", {"name": "v", "password": "viewer-pass-1"}); op("POST", "/api/login", {"name": "op", "password": "operator-pass-1"})
+        st_t, tx = view("GET", "/api/tools/taxonomy")
+        st_q, txq = view("GET", "/api/tools/taxonomy?q=jar")
+        st_v, _ = view("POST", "/api/tools/fleet", {"class_id": "esp", "maker": "Acme", "model": "P2", "datasheet": "Acme P2 sheet"})
+        st_nods, nods = op("POST", "/api/tools/fleet", {"class_id": "esp", "maker": "Acme", "model": "P2", "datasheet": ""})
+        st_add, added = op("POST", "/api/tools/fleet", {"class_id": "esp", "maker": "Acme", "model": "P2", "datasheet": "Acme P2 sheet rev A", "od_in": "5.38"})
+        st_fl, fl = view("GET", "/api/tools/fleet")
+        st_rm, _ = op("POST", f"/api/tools/fleet/{r1['id']}/remove", {})
+        st_rm2, _ = op("POST", "/api/tools/fleet/nothing-here/remove", {})
+    finally:
+        svc.stop()
+    audit = Path(wsp, "records", "audit.jsonl").read_text(encoding="utf-8")
+    c2 = {
+        "fleet_rules": e_ds and e_cls and e_dup and r1["id"] == "acme-m1-a100" and r1["class_name"] == TX.TAXONOMY["pdm_motor"]["name"] and r1["od_in"] == 6.75
+                       and Path(wsp, "config", "fleet.json").is_file(),
+        "api": st_t == 200 and len(tx["classes"]) == sm["classes"] and [p[0] for p in tx["parts"]] == list(TX.PARTS) and tx["summary"]["figures"] == sm["figures"]
+               and st_q == 200 and {c["id"] for c in txq["classes"]} >= {"drilling_jar", "jar_accelerator"} and len(txq["classes"]) < 10
+               and tx["fleet"] and tx["fleet"][0]["id"] == "acme-m1-a100",
+        "roles": st_v == 403 and st_nods == 400 and "datasheet" in nods.get("error", "") and st_add == 200 and added["od_in"] == 5.38
+                 and st_fl == 200 and {t["id"] for t in fl["tools"]} == {"acme-m1-a100", "acme-p2"} and st_rm == 200 and st_rm2 == 404
+                 and [t["id"] for t in TX.fleet_list(wsp)] == ["acme-p2"],
+        "audit": '"fleet.add"' in audit and '"fleet.remove"' in audit and "Acme P2 sheet rev A" in audit,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BZ2 the fleet: a tool of yours needs its class and its datasheet citation, and is not added twice; it is kept in the workspace's config; the API "
+       "serves the classes, the tutorial parts and the fleet to any signed-in user, adds and removes for an operator and not a viewer, says why an "
+       "addition without a datasheet is turned away, and every addition and removal is in the audit log"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "tools.md").read_text(encoding="utf-8")
+    r_cls = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "classes"], capture_output=True, text=True)
+    r_cat = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "classes", "--category", "fishing"], capture_output=True, text=True)
+    r_tut = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "tutorial", "--class", "drilling_jar"], capture_output=True, text=True)
+    r_none = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "tutorial"], capture_output=True, text=True)
+    r_bad = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "tutorial", "--class", "warp_drive"], capture_output=True, text=True)
+    r_add = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet-add", "--workspace", wsp, "--class", "drilling_jar", "--maker", "Acme",
+                     "--model", "J9", "--datasheet", "Acme J9 sheet rev C"], capture_output=True, text=True)
+    r_nods = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet-add", "--workspace", wsp, "--class", "drilling_jar", "--maker", "Acme",
+                      "--model", "J10"], capture_output=True, text=True)
+    r_list = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet", "--workspace", wsp], capture_output=True, text=True)
+    r_nows = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet"], capture_output=True, text=True)
+    c3 = {
+        "page": all(x in page_src for x in ("Downhole tool library", "class=\"tl-chip\"", 'role="tooltip"', "aria-haspopup=\"dialog\"", ".tl-chip:focus-visible .tl-tip",
+                                             "@media (hover:none)", "showModal()", "dialog.tl-dlg::backdrop", "/api/tools/taxonomy", "/api/tools/fleet", "Add one of yours",
+                                             "Your fleet", "tl-open", "Esc closes it")),
+        "cli": r_cls.returncode == 0 and f"{sm['classes']} of {sm['classes']} tool classes" in r_cls.stdout and "Fishing, milling and intervention" in r_cls.stdout
+               and r_cat.returncode == 0 and "overshot" in r_cat.stdout and "pdm_motor" not in r_cat.stdout
+               and r_tut.returncode == 0 and "What it is: " in r_tut.stdout and "In this program: " in r_tut.stdout
+               and r_none.returncode != 0 and "--class pdm_motor" in (r_none.stderr + r_none.stdout) and "<" not in (r_none.stderr + r_none.stdout)
+               and r_bad.returncode != 0 and "no tool class 'warp_drive'" in (r_bad.stderr + r_bad.stdout),
+        "cli_fleet": r_add.returncode == 0 and "added acme-j9" in r_add.stdout and r_nods.returncode != 0 and "datasheet" in (r_nods.stderr + r_nods.stdout)
+                     and r_list.returncode == 0 and "Acme J9 sheet rev C" in r_list.stdout and r_nows.returncode != 0 and "needs --workspace" in (r_nows.stderr + r_nows.stdout),
+        "help": not H.check("tools") and "tutorial" in help_md and "fleet" in help_md and "the tutorials carry no numbers at all" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "BZ3 the page and the command line: a chip per class that shows its description on hover and on keyboard focus (not on a touch screen, where a tap "
+       "opens it), a tutorial dialog that opens on click, tap or Enter and closes on Esc or the backdrop, a find box and a category filter, the fleet card, "
+       "the gauge library's Tutorial buttons; `gea tools --action classes | tutorial | fleet | fleet-add`, each refusing a missing argument by name without "
+       "a placeholder; the help page"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
 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:
@@ -7936,6 +8085,7 @@ def main() -> int:
         section_bw_catalog_map(tmp)
         section_bx_pasteable(tmp)
         section_by_edr(tmp)
+        section_bz_tool_library(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

gea_program-0.31.0/gea/help/tools.md

@@ -0,0 +1,11 @@
+# Tools and ports
+
+> What this program knows how to measure with, what is run in the hole around it, and what it knows how to speak. The downhole tool library is every class of downhole tool in use across the industry - bits, motors and steerable systems, MWD and LWD, the drill string and its subs, casing and cementing equipment, completion and artificial lift, wireline and cased-hole tools, fishing and milling, test tools - each with a one-line description on hover and a tutorial that opens on a click; the fleet is your own tools in those classes, each tied to its datasheet. The gauge library is the downhole and surface tools - each with the citation its numbers came from, the conditions it is rated for, and the telemetry interface it declares; the port registry is the file formats and live protocols that bring a tool's readings in. The page draws the line between them: a tool declares an interface, a port speaks one, and a tool whose interface no port in this build speaks is named rather than hidden.
+
+**The command**: the page is Tools & ports on the dashboard. Point at a tool class (or Tab to it) for its one-line description; click, tap or press Enter for the tutorial - what it is, where it runs, how it works, what it shows in the data, what to watch, what this program does with it, the published figures and the pages it was checked against; Esc or Close puts it away. `gea tools --action classes` lists the classes (`--category measure`, `--find packer`), `gea tools --action tutorial --class pdm_motor` prints one, `gea tools --action fleet-add --workspace C:\site --class pdm_motor --maker Acme --model M1 --serial A100 --datasheet "Acme M1 datasheet rev B"` adds a tool of yours (an operator may also add it from the tutorial), `--action fleet` lists them and `--action fleet-remove --id ...` takes one out. `gea tools` alone prints the same register at the command line (`--json` for the machine record, `--rating --station 9850:quartz_pt_geoq177_16k ...` for the rating check). A tool whose vendor published no numbers is listed as PARAMETERS_USER_SUPPLIED: `gea config` takes your own datasheet (`load_gauge_spec_json`) and the tool is then simulated and aged from it. The live protocols each name what the site must supply before they run and what to rehearse against - `gea wits0-sim`, `gea etp-sim`, `gea seedlink-sim`, or the stand-in slave, outstation, device and historian the field ports ship with.
+
+**What it writes**: the fleet, to `config\fleet.json` in the workspace, every addition and removal in the audit log; everything else on the page is a register, not a record. Per tool class it states the tutorial, the published figures - each the cited page's own words and unit, quoted as read on the date the pages were fetched, most of them one maker's product and never a limit for the class - and the sources. Per gauge it states: the class, what it measures, the temperature and pressure ratings, the published aging rate in %FS/yr where the datasheet gives one (and the reason there is none where it does not), the interface it declares, the ports that can carry it, and its source. Per port: the transport, the status (IMPLEMENTED, or DECLARED_SITE_DETAILS_REQUIRED with what is missing), and what it speaks to. The rating check returns, per station, the temperature and pressure at that depth, the tool's ratings and whether the station is within them, with the basis of the conditions printed beside the answer.
+
+**The number to check**: a published figure against the page it cites, and your own tool's rating against its datasheet, never against the class's figures; the aging rate against your own datasheet before you trust a drift report built on it, and the rating check's per-station temperature against the tool's rating - the check that catches a 177 °C gauge hung in a 233 °C zone before the well does.
+
+**What this page will not call a measurement**: a figure for a whole class of tools - the tutorials carry no numbers at all, and every number on a tool's card is quoted from the page it cites; a rating for a fleet tool its datasheet does not give - the fleet carries the datasheet citation and nothing more unless you give the numbers; a vendor number nobody published - a tool with no datasheet rate carries none and raises rather than inventing one, and the page says PARAMETERS_USER_SUPPLIED. A rating as a prediction - a station within its ratings is arithmetic on the vendor's number and the declared conditions, not a promise the tool survives. The conditions themselves - without a well profile they are the gradients declared on the page, and the answer prints which basis it used. A port as a connection - a port listed here speaks a protocol; whether the site's own device answers is what the Patch panel shows.

{gea_program-0.30.1 → gea_program-0.31.0}/gea/helplib.py

@@ -43,7 +43,7 @@ INDEX: List[tuple] = [
     ('edr', 'The drilling recorder', 'the rig\'s one-second EDR export read as delivered - sections, depths, hours on bottom, the rate of penetration, the recorder\'s MD-TVD table - and what the record will not say'),
     ('dlis', 'The DLIS log', 'a well log as it is delivered (API RP66 V1), read as the standard lays it out: the frames, the channels, what was skipped; into the strata survey'),
     ('historian', 'The historian pull', 'an operator\'s gauge history out of the PI System through PI Web API, read-only, every value with its archive time and flags'),
-    ('tools', 'Tools and ports', 'the downhole and surface tools this program knows, each with its citation and ratings, the formats and protocols that bring their readings in, and the rating check on a tool string'),
+    ('tools', 'Tools and ports', 'every class of downhole tool in use across the industry with a hover description and a pop-open tutorial, your own fleet with its datasheets, the gauges this program reads with their citations and ratings, the formats and protocols that bring readings in, and the rating check on a tool string'),
     ('field-ports', 'The field ports', 'Modbus RTU on the serial line, DNP3 from the pad RTU, HART-IP from the transmitter itself - read-only, polled, with the stand-ins to rehearse against'),
     ('slip', 'Slip tendency on the mapped faults', 'the declared stress state resolved on each mapped fault around a well: the slip tendency, the pressure to slip, the World Stress Map as the SHmax source, the published Hennings values beside'),
     ('interval', 'The interval against the mapped tops', 'the declared disposal interval, subsea, beside each formation-top bracket; the depth tier against the mapped base; the catalogue events against the mapped faults'),