gea-program 0.45.0__tar.gz → 0.47.0__tar.gz

{gea_program-0.45.0 → gea_program-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.45.0
+Version: 0.47.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
@@ -648,6 +648,30 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### Rig time
+
+What the rig did each second of the drilling record, read from the hook
+load, the block, the bit, the pumps and the rotary: drilling, in the slips,
+tripping, circulating, reaming, off the hook. Every drilling connection is
+timed weight to weight with its three parts, every trip by its speed over
+the pipe-handling hours with its breaks beside it, and the time each loses
+against a target - the drilling program's, or this pad's own best quarter -
+is summed per report day and priced at the contract's operating rate. The
+**Rig time** tab, `gea rig-time`, `gea help rig-time`; the invoice check
+shows each day's lost time beside the bill.
+
+### The invoice cross-check
+
+The drilling contractor's daywork invoice, day by day, against the daily
+drilling reports and the drilling record, at the contract's terms as the
+operator declares them: hours billed against hours reported, standby billed
+at the operating rate, rig repair past the allowance, a trip or a circulation
+the recorder never saw, a depth or footage overstated, an amount that is not
+quantity times price, a day billed with no report. Each day AGREES, is in
+QUESTION or DIFFERS, with the dollars in question and the line each comes
+from; a client report with its PDF. The **Invoice check** tab, `gea
+invoice-check`, `gea help invoice-check`.
+
 ### The lateral, the printable reports, the daily summary and the key
 
 An earthquake near a well with a directional survey is measured from the

{gea_program-0.45.0 → gea_program-0.47.0}/README.md

@@ -609,6 +609,30 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### Rig time
+
+What the rig did each second of the drilling record, read from the hook
+load, the block, the bit, the pumps and the rotary: drilling, in the slips,
+tripping, circulating, reaming, off the hook. Every drilling connection is
+timed weight to weight with its three parts, every trip by its speed over
+the pipe-handling hours with its breaks beside it, and the time each loses
+against a target - the drilling program's, or this pad's own best quarter -
+is summed per report day and priced at the contract's operating rate. The
+**Rig time** tab, `gea rig-time`, `gea help rig-time`; the invoice check
+shows each day's lost time beside the bill.
+
+### The invoice cross-check
+
+The drilling contractor's daywork invoice, day by day, against the daily
+drilling reports and the drilling record, at the contract's terms as the
+operator declares them: hours billed against hours reported, standby billed
+at the operating rate, rig repair past the allowance, a trip or a circulation
+the recorder never saw, a depth or footage overstated, an amount that is not
+quantity times price, a day billed with no report. Each day AGREES, is in
+QUESTION or DIFFERS, with the dollars in question and the line each comes
+from; a client report with its PDF. The **Invoice check** tab, `gea
+invoice-check`, `gea help invoice-check`.
+
 ### The lateral, the printable reports, the daily summary and the key
 
 An earthquake near a well with a directional survey is measured from the

{gea_program-0.45.0 → gea_program-0.47.0}/gea/__init__.py

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

{gea_program-0.45.0 → gea_program-0.47.0}/gea/__main__.py

@@ -590,6 +590,36 @@ def main(argv=None) -> int:
     p_dz.add_argument("--actor", type=str, default="cli")
     p_dz.add_argument("--json", action="store_true")
 
+    p_rt = sub.add_parser("rig-time", help="what the rig did each second of the drilling record - drilling, connections, trips, the slips - and the time lost against the pad's own best")
+    p_rt.add_argument("--workspace", type=str, required=True)
+    p_rt.add_argument("--well", type=str, default=None, help="with --write: one well's report (without it, the pad's)")
+    p_rt.add_argument("--write", action="store_true", help="write the client report")
+    p_rt.add_argument("--w2w-min", type=str, default=None, help="declare the weight-to-weight connection target, minutes ('' removes it)")
+    p_rt.add_argument("--trip-in", type=str, default=None, help="declare the tripping-in target, ft/h")
+    p_rt.add_argument("--trip-out", type=str, default=None, help="declare the tripping-out target, ft/h")
+    p_rt.add_argument("--source", type=str, default="", help="where the targets came from")
+    p_rt.add_argument("--block-weight", type=str, default=None, help="with --well: the block weight in klbf where the estimate is wrong ('' removes it)")
+    p_rt.add_argument("--actor", type=str, default="cli")
+    p_rt.add_argument("--json", action="store_true")
+
+    p_iv = sub.add_parser("invoice-check", help="the drilling contractor's daywork invoice, day by day, against the daily drilling reports and the drilling record, at the contract's terms")
+    p_iv.add_argument("--workspace", type=str, default=None)
+    p_iv.add_argument("--well", type=str, default=None)
+    p_iv.add_argument("--template", type=str, default=None, choices=["ddr", "invoice"], help="print the headings a file needs")
+    p_iv.add_argument("--attach-ddr", type=str, default=None, help="a daily drilling report (CSV)")
+    p_iv.add_argument("--attach-invoice", type=str, default=None, help="an invoice (CSV)")
+    p_iv.add_argument("--source", type=str, default="", help="with --attach-*: where the file came from")
+    p_iv.add_argument("--terms-source", type=str, default=None, help="declare the contract's terms: where they came from")
+    p_iv.add_argument("--day-start", type=str, default="06:00")
+    p_iv.add_argument("--report-date", type=str, default="start", choices=["start", "end"])
+    for k_ in ("operating", "standby", "repair", "moving", "force-majeure"):
+        p_iv.add_argument(f"--{k_}", type=float, default=None, help=f"the {k_.replace('-', ' ')} day rate, USD")
+    p_iv.add_argument("--repair-hours-job", type=float, default=None)
+    p_iv.add_argument("--repair-hours-month", type=float, default=None)
+    p_iv.add_argument("--write", action="store_true", help="write the client report")
+    p_iv.add_argument("--actor", type=str, default="cli")
+    p_iv.add_argument("--json", action="store_true")
+
     p_ps = sub.add_parser("pad-summary", help="the daily pad summary: what changed since the last one, what is due, what is still missing - one page, kept in report history; the service writes it each day and sends it through the notification rules")
     p_ps.add_argument("--workspace", type=str, required=True)
     p_ps.add_argument("--send", action="store_true", help="also hand it to the notification rules (the event pad.summary)")
@@ -2338,6 +2368,72 @@ def main(argv=None) -> int:
         print(f"  {os.path.join(ws.reports_dir, e['path'])}")
         print(f"  key fingerprint {e['fingerprint']}")
         return 0
+    elif a.cmd == "rig-time":
+        import json as _json
+        from . import rig_state as _RS
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace)
+            if a.w2w_min is not None or a.trip_in is not None or a.trip_out is not None or a.block_weight is not None:
+                if a.block_weight is not None and not a.well:
+                    raise ValueError("--block-weight needs --well")
+                s_ = _RS.set_settings(ws, a.actor, a.source, a.w2w_min, a.trip_in, a.trip_out, (a.well, a.block_weight) if a.block_weight is not None else None)
+                print("targets: " + (", ".join(f"{k} {v:g}" for k, v in s_.get("targets", {}).items()) or "none declared")
+                      + "; block weights: " + (", ".join(f"{k} {v:g} klbf" for k, v in s_.get("block_weight_klbf", {}).items()) or "estimated"))
+                return 0
+            if a.write:
+                r_ = _RS.write_report(ws, __version__, a.actor, a.well)
+                print(f"wrote {r_['report_id']}: {r_['paths']['html']}")
+                if r_['paths'].get('pdf'):
+                    print(f"  printable: {r_['paths']['pdf']}")
+                return 0
+            p_ = _RS.pad(ws)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"rig-time: {e.args[0] if e.args else e}")
+        print(_json.dumps(p_, default=str) if a.json else _RS.text(p_))
+        return 0
+    elif a.cmd == "invoice-check":
+        import json as _json
+        from . import invoice_check as _IC
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        if a.template:
+            print(_IC.template(a.template), end="")
+            return 0
+        if not a.workspace:
+            raise SystemExit("invoice-check: give --workspace C:\\site (or --template ddr)")
+        try:
+            ws = Workspace(a.workspace)
+            if a.terms_source is not None:
+                t_ = _IC.set_terms(ws, a.actor, a.terms_source, a.day_start, a.report_date,
+                                   {"operating": a.operating, "standby": a.standby, "repair": a.repair, "moving": a.moving, "force_majeure": a.force_majeure},
+                                   a.repair_hours_job, a.repair_hours_month)
+                print("terms kept: " + ", ".join(f"{k} {v:,.2f} USD/day" for k, v in t_["rates_usd_per_day"].items()) + f"; report day from {t_['day_start']}")
+                return 0
+            wid = a.well or (ws.wells()[0]["id"] if ws.wells() else None)
+            if wid is None:
+                raise SystemExit("invoice-check: the workspace has no wells")
+            for kind, f_ in (("ddr", a.attach_ddr), ("invoice", a.attach_invoice)):
+                if f_:
+                    with open(f_, "rb") as fh:
+                        r_ = _IC.attach(ws, a.actor, wid, kind, os.path.basename(f_), fh.read(), a.source)
+                    print(f"attached {r_['name']}: {r_['lines']} line(s)" + (f", {len(r_['errors'])} not read" if r_['errors'] else ""))
+            if a.attach_ddr or a.attach_invoice:
+                return 0
+            if a.write:
+                r_ = _IC.write_report(ws, wid, __version__, a.actor)
+                print(f"wrote {r_['report_id']} ({r_['status']}): {r_['paths']['html']}")
+                if r_['paths'].get('pdf'):
+                    print(f"  printable: {r_['paths']['pdf']}")
+                return 0
+            r = _IC.check(ws, wid)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"invoice-check: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _IC.text(r))
+        return 0
     elif a.cmd == "pad-summary":
         import json as _json
         from . import pad_summary as _PS

{gea_program-0.45.0 → gea_program-0.47.0}/gea/acceptance_tests.py

@@ -10610,6 +10610,309 @@ def section_cn_four(tmp: str) -> None:
        + (f" [failed: {', '.join(failed5)}]" if failed5 else ""))
 
 
+def section_co_invoice_check(tmp: str) -> None:
+    """Section CO - the invoice cross-check: the daily drilling report and the invoice read by their headings in
+    whatever order and spelling a form uses, a file that is neither refused with the headings it needs; a labelled
+    scene of five report days with seven planted differences - a day billed twice, repair past the allowance at the
+    operating rate, a trip the record shows never happened, standby billed at the operating rate, a depth and footage
+    overstated, an amount that is not quantity times price, a day billed with no report and nothing on the record -
+    each found with the dollars it puts in question; the same days billed and reported correctly agree; the report
+    with its PDF; the API, the CLI, the tab and the help page."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import base64 as _b64
+    from . import __version__
+    from . import client_reports as CR
+    from . import helplib as H
+    from . import invoice_check as IC
+    from . import pdf_report as PDF
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "co"); d.mkdir()
+
+    # -- CO1 reading the files ---------------------------------------------------------------------------------------
+    t_ddr, t_inv = IC.read_ddr(IC.template("ddr")), IC.read_invoice(IC.template("invoice"))
+    odd = IC.read_ddr("Rpt Date;Start Time;End Time;IADC Code;Operations;MD From;MD To\n07/01/2026;0600;1800;2 - Drilling;Drill ahead;9500;10,100\n"
+                      "07/01/2026;1800;0600;33;Standby - waiting on orders;10100;10100\nnot a date;0600;0700;2;x;1;2\n")
+    span = IC.read_invoice("Period From,Period To,Charge,Qty,UOM,Rate,Ext Amount\n2026-07-01,2026-07-03,Stand-by rate,3,day,25000,75000\n"
+                           "2026-07-04,2026-07-04,Mobilization,1,lot,50000,50000\n")
+    try:
+        IC.read_ddr("Name,Value\na,1\n")
+        refused = ""
+    except ValueError as e:
+        refused = str(e)
+    c1 = {
+        "templates": len(t_ddr["lines"]) == 2 and t_ddr["lines"][0]["code"] == 2 and t_ddr["lines"][1]["hours"] == 12 and len(t_inv["lines"]) == 2
+                     and t_inv["lines"][1]["kind"] == "standby" and t_inv["lines"][1]["hours"] == 12,
+        "odd": len(odd["lines"]) == 2 and odd["lines"][0]["date"] == "2026-07-01" and odd["lines"][0]["hours"] == 12 and odd["lines"][1]["hours"] == 12
+               and odd["lines"][0]["depth_to_ft"] == 10100 and odd["lines"][1]["standby"] and len(odd["errors"]) == 1 and "row 4" in odd["errors"][0],
+        "span": span["lines"][0]["kind"] == "standby" and span["lines"][0]["price"] == 25000 and span["lines"][0]["to"] == "2026-07-03" and span["lines"][0]["hours"] == 72
+                and span["lines"][1]["kind"] == "moving",
+        "refused": "Date column" in refused and "--template ddr" in refused,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CO1 the files read by their headings: the templates; a semicolon report with its own headings, times without colons, a code with its "
+       "name, a standby line, a row that does not read named and the rest kept; an invoice span of days at a 'Rate' that is a price; a file "
+       "that is neither refused with the headings it needs" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CO2 the cross-check ---------------------------------------------------------------------------------------------
+    F = IC.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad CO", actor="tester")
+    w = ws.add_well_file(F["edr"], display="INV-1", actor="tester")
+    r_none = IC.check(ws, w["id"])
+    IC.set_terms(ws, "tester", "test daywork contract, Exhibit A", "06:00", "start", {"operating": 30000, "standby": 25000, "repair": 0}, None, 2)
+    r_nofiles = IC.check(ws, w["id"])
+    IC.attach(ws, "tester", w["id"], "ddr", "ddr.csv", F["ddr"].encode(), "test reports")
+    IC.attach(ws, "tester", w["id"], "invoice", "inv.csv", F["invoice"].encode(), "test invoice 1")
+    r = IC.check(ws, w["id"])
+    D = {x["date"]: x for x in r["days"]}
+    fd = lambda dk: {f["check"]: f for f in D[dk]["findings"]}
+    c2 = {
+        "states": r_none["status"] == "NO TERMS" and r_nofiles["status"] == "NO FILES" and r["status"] == "DIFFERS"
+                  and [D[k]["status"] for k in sorted(D)] == ["DIFFERS", "DIFFERS", "DIFFERS", "DIFFERS", "QUESTION"],
+        "day1": set(fd("2026-07-01")) == {"OVER 24 H", "BILLED TWICE"} and fd("2026-07-01")["OVER 24 H"]["usd_in_question"] == 30000
+                and abs(D["2026-07-01"]["record"]["drilling_h"] - 18) < 0.2 and D["2026-07-01"]["record"]["quiet_h"] < 0.2,
+        "day2": fd("2026-07-02")["REPAIR OVER ALLOWANCE"]["usd_in_question"] == 2500 and "14:00-16:00" in fd("2026-07-02")["LINE VS RECORD"]["detail"]
+                and fd("2026-07-02")["LINE VS RECORD"]["ref"] == "ddr.csv row 6" and "DRILLING HOURS" not in fd("2026-07-02"),
+        "day3": abs(fd("2026-07-03")["STANDBY AT OPERATING"]["usd_in_question"] - 4166.67) < 0.01 and fd("2026-07-03")["QUIET ON THE RECORD"]["severity"] == "QUESTION",
+        "day4": fd("2026-07-04")["ARITHMETIC"]["usd_in_question"] == 1000 and "7,600" in fd("2026-07-04")["DEPTH"]["detail"] and "1,200" in fd("2026-07-04")["FOOTAGE"]["detail"],
+        "day5": set(fd("2026-07-05")) == {"NO REPORT", "NOT IN THE RECORD"},
+        "totals": r["totals"]["usd_in_question"] == 37666.67 and r["totals"]["billed_checked_usd"] == 181000 and r["totals"]["billed_usd"] == 185200
+                  and [x["description"] for x in r["other_lines"]] == ["Fuel (diesel)"] and set(r["record"]["channels"]) == {"drilling flag", "pump output", "rotary", "bit depth"},
+    }
+    # the same days billed and reported as they happened
+    ws2 = Workspace.create(str(d / "ws2"), "Pad CO2", actor="tester")
+    w2 = ws2.add_well_file(F["edr"], display="INV-2", actor="tester")
+    IC.set_terms(ws2, "tester", "test daywork contract", "06:00", "start", {"operating": 30000, "standby": 25000, "repair": 0}, None, 2)
+    ddr_ok = F["ddr"].replace("2026-07-02,14:00,16:00,2,6,Trip out", "2026-07-02,14:00,16:00,2,7,Service rig").replace("6200,7600", "6200,7400")
+    inv_ok = ("Date,Rate Type,Quantity,Unit,Unit Price,Amount\n2026-07-01,Operating day rate,1,day,30000,30000\n"
+              "2026-07-02,Operating day rate,22,hour,1250,27500\n2026-07-02,Repair rate,2,hour,0,0\n"
+              "2026-07-03,Standby rate,20,hour,1041.6667,20833.33\n2026-07-03,Operating day rate,4,hour,1250,5000\n2026-07-04,Operating day rate,1,day,30000,30000\n")
+    IC.attach(ws2, "tester", w2["id"], "ddr", "ddr.csv", ddr_ok.encode(), "test reports")
+    IC.attach(ws2, "tester", w2["id"], "invoice", "inv.csv", inv_ok.encode(), "test invoice 2")
+    r2 = IC.check(ws2, w2["id"])
+    c2["clean"] = r2["status"] == "AGREES" and r2["totals"]["agrees"] == 4 and r2["totals"]["usd_in_question"] == 0 and r2["findings"] == []
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CO2 the cross-check: no terms, then no files, said so; five report days against the record - a day billed twice, 2 h of repair past "
+       "a 2 h allowance at the operating rate (2,500.00), a trip the record shows never moved, 20 h of standby billed at the operating rate "
+       "(4,166.67) with the quiet hours a question, an overstated depth and footage, an amount 1,000.00 over quantity times price, a day "
+       "billed with no report and nothing on the record; 37,666.67 in question; the fuel listed, not checked; the same days billed and "
+       "reported as they happened agree, the standby hours explaining the quiet" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CO3 the report, the API, the CLI, the tab, the help -----------------------------------------------------------
+    rep = IC.write_report(ws, w["id"], __version__, "tester")
+    rd = PDF.read(Path(rep["paths"]["pdf"]).read_bytes())
+    html_ = Path(rep["paths"]["html"]).read_text(encoding="utf-8")
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer"); Users(str(Path(wsp, "users.json"))).add("op", "op-pass-123", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def opener(name, pw_):
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+        rq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": name, "password": pw_}).encode())
+        rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+        return o
+
+    def call(o, method, path, body=None):
+        rq = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        if method == "POST":
+            rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1")
+        try:
+            with o.open(rq, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_g, gj = call(V, "GET", "/api/invoice-check?well=" + w["id"])
+        s_bad, _ = call(V, "GET", "/api/invoice-check?well=nope")
+        s_vt, _ = call(V, "POST", "/api/invoice-check/terms", {"source": "x", "operating": 1})
+        s_ot, otj = call(O, "POST", "/api/invoice-check/terms", {"source": "contract B", "day_start": "06:00", "operating": 30000, "standby": 25000, "repair": 0, "repair_hours_per_month": 2})
+        s_ob, _ = call(O, "POST", "/api/invoice-check/terms", {"source": "contract B", "day_start": "6am", "operating": 30000})
+        s_oa, oaj = call(O, "POST", "/api/invoice-check/attach", {"well_id": w["id"], "kind": "invoice", "filename": "inv2.csv", "source": "invoice 2",
+                                                                  "content_b64": _b64.b64encode(IC.template("invoice").encode()).decode()})
+        s_ow, owj = call(O, "POST", "/api/invoice-check/write", {"well_id": w["id"]})
+        s_or, _ = call(O, "POST", "/api/invoice-check/remove", {"file": oaj.get("file", "")})
+    finally:
+        svc.stop()
+    cli_t = _sp.run([sys.executable, "-m", "gea", "invoice-check", "--template", "invoice"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_c = _sp.run([sys.executable, "-m", "gea", "invoice-check", "--workspace", wsp, "--well", w["id"]], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_w = _sp.run([sys.executable, "-m", "gea", "invoice-check", "--workspace", wsp, "--well", w["id"], "--write"], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c3 = {
+        "report": rd["ok"] and rep["status"] == "DIFFERS" and "Invoice cross-check - INV-1" in rd["text"][0] and "37,666.67" in html_ and "REPAIR OVER ALLOWANCE" in html_
+                  and not CR.forbidden_terms(html_),
+        "api": s_g == 200 and gj["check"]["totals"]["usd_in_question"] == 37666.67 and s_bad == 404 and s_vt == 403 and s_ot == 200 and otj["source"] == "contract B"
+               and s_ob == 400 and s_oa == 200 and oaj["lines"] == 2 and s_ow == 200 and owj["report_id"].startswith("INV-") and s_or == 200,
+        "cli": cli_t.returncode == 0 and "Rate Type" in cli_t.stdout and cli_c.returncode == 0 and "REPAIR OVER ALLOWANCE" in cli_c.stdout and "37,666.67" in cli_c.stdout
+               and cli_w.returncode == 0 and "printable:" in cli_w.stdout,
+        "page": all(x in page_src for x in ("VIEWS.invoices", "['#/invoices', 'Invoice check']", "/api/invoice-check/attach", "ivTerms")),
+        "help": any(t[0] == "invoice-check" for t in H.INDEX) and not H.check("invoice-check") and H.VIEW_TOPIC.get("invoices") == "invoice-check",
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CO3 the report (with its PDF) and the check on the API (anyone signed in reads it; only an operator declares terms, attaches, "
+       "removes or writes; a start hour that is not one refused), the CLI (a template, the check, the report written), the tab and the help page"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
+def section_cp_rig_time(tmp: str) -> None:
+    """Section CP - rig time: a recorder export with known answers - three drilling connections of 6, 9 and 15 minutes
+    weight to weight, a 3,000 ft trip out at 2,449 ft/h and in at 3,333 ft/h over their pipe-handling hours, the block's
+    40 klbf - read back to the second; the slips not taken from a light string pushed into a lateral, a depth re-set
+    not taken for pipe moving, the weight off the hook for half an hour not a connection, the slips found from the block
+    when there is no hook load; the targets as the pad's best quarter or as declared, each connection's and trip's time
+    past them, priced at the contract's operating rate and beside each day of the invoice check; the report with its
+    PDF; the API, the CLI, the tab and the help page."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    from datetime import datetime as _dtm
+    from . import __version__
+    from . import helplib as H
+    from . import invoice_check as IC
+    from . import pdf_report as PDF
+    from . import rig_state as RS
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "cp"); d.mkdir()
+    F = RS.selftest_edr(str(d))
+    E_ = F["expect"]
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad CP", actor="tester")
+    w1 = ws.add_well_file(F["path"], display="RIG-1", actor="tester")
+    r = RS.well(ws, w1["id"])
+
+    # -- CP1 the states, the connections, the trips ------------------------------------------------------------------
+    cs = r["connections"]
+    tr = {x["direction"]: x for x in r["trips"]}
+    near = lambda a, b, tol: a is not None and abs(a - b) <= tol
+    t = np.arange(0.0, 7200.0)
+    n = len(t)
+    zeros = np.zeros(n)
+    lateral = RS.classify(t, {"hookload": np.full(n, 45.0), "block": 100.0 - t * 0.01, "bit": 15000.0 + t * 1.0, "hole": np.full(n, 25000.0),
+                              "flow": zeros, "spp": None, "rpm": zeros}, np.zeros(n, bool), block_weight=40.0)
+    jump_bit = np.where(t < 3600, 9000.0, 9600.0)
+    jump = RS.classify(t, {"hookload": np.full(n, 200.0), "block": np.full(n, 50.0), "bit": jump_bit, "hole": np.full(n, 9700.0), "flow": zeros,
+                           "spp": None, "rpm": zeros}, np.zeros(n, bool), block_weight=40.0)
+    hang = RS.classify(t, {"hookload": np.full(n, 40.0), "block": np.full(n, 50.0), "bit": np.full(n, 9000.0), "hole": np.full(n, 9700.0), "flow": zeros,
+                           "spp": None, "rpm": zeros}, np.zeros(n, bool), block_weight=40.0)
+    blk = 10.0 + (t % 120.0)
+    nohl = RS.classify(t, {"hookload": None, "block": blk, "bit": np.full(n, 9000.0), "hole": np.full(n, 9700.0), "flow": zeros, "spp": None, "rpm": zeros},
+                       np.zeros(n, bool))
+    c1 = {
+        "connections": [round(c["w2w_min"]) for c in cs] == [6, 9, 15] and all(near(c["w2w_min"], e, 0.1) for c, e in zip(cs, E_["connections_w2w_min"]))
+                       and all(near(c["slips_min"], e, 0.1) for c, e in zip(cs, E_["slips_min"])) and all(near(c["pre_min"], 1.0, 0.1) and near(c["post_min"], 1.0, 0.1) for c in cs),
+        "trips": set(tr) == {"IN", "OUT"} and near(tr["OUT"]["speed_ft_h"], E_["trip_out_ft_h"], 0.02 * E_["trip_out_ft_h"])
+                 and near(tr["IN"]["speed_ft_h"], E_["trip_in_ft_h"], 0.02 * E_["trip_in_ft_h"]) and near(tr["OUT"]["feet"], 3000, 30) and tr["OUT"]["connections"] >= 29
+                 and near(tr["OUT"]["moving_speed_ft_h"], 6000, 600),
+        "states": near(r["hours"]["ROTARY DRILLING"], 2.0, 0.02) and r["hours"]["SLIDE DRILLING"] == 0 and r["hours"]["OFF THE HOOK"] == 0
+                  and near(r["footage"]["rotary_ft"], 380, 2) and near(r["footage"]["rotary_rop_ft_h"], 190, 2),
+        "block": near(r["block_weight_klbf"], E_["block_weight_klbf"], 0.01) and r["block_weight_estimated"] and near(r["slips_threshold_klbf"], 60.0, 0.01),
+        "lateral": int((lateral["state"] == RS.SLIPS).sum()) == 0 and int((lateral["state"] == RS.TIN).sum()) > 0.9 * n,
+        "jump": int((jump["state"] == RS.TIN).sum()) == 0,
+        "off_hook": int((hang["state"] == RS.OFFHOOK).sum()) == n and int((hang["state"] == RS.SLIPS).sum()) == 0,
+        "no_hookload": nohl["slips"].sum() > 0.5 * n and "no hook load" in nohl["how"][0],
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CP1 the record read to the second: three connections of 6, 9 and 15 min weight to weight with 4, 7 and 13 min in the slips; a 3,000 ft "
+       "trip out at 2,449 ft/h and in at 3,333 ft/h over their pipe-handling hours; 2.0 h drilling 380 ft; the block's 40 klbf estimated; a light "
+       "string pushed into a lateral tripping, not in the slips; a depth re-set not pipe moving; the weight off the hook for two hours OFF THE "
+       "HOOK; the slips from the block when there is no hook load" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CP2 the targets and the time lost ----------------------------------------------------------------------------
+    w2 = ws.add_well_file(F["path"], display="RIG-2", actor="tester")
+    p0 = RS.pad(ws)
+    tg0 = p0["targets"]
+    w2w = sorted(c["w2w_min"] for w_ in p0["wells"] for c in w_["connection_list"])
+    lost0 = sum(max(0.0, x - tg0["w2w_min"]["value"]) for x in w2w) / 60.0
+    IC.set_terms(ws, "tester", "test contract", "06:00", "start", {"operating": 30000}, None, None)
+    try:
+        RS.set_settings(ws, "tester", "", 5)
+        no_source = False
+    except ValueError:
+        no_source = True
+    RS.set_settings(ws, "tester", "drilling program 2026", 5, 2800, None)
+    p1 = RS.pad(ws)
+    W1 = p1["wells"][0]
+    ti = next(x for x in W1["trips"] if x["direction"] == "IN")
+    IC.attach(ws, "tester", w1["id"], "invoice", "inv.csv", b"Date,Rate Type,Quantity,Unit,Unit Price,Amount\n2026-08-01,Operating day rate,1,day,30000,30000\n", "test")
+    ic = IC.check(ws, w1["id"])
+    c2 = {
+        "best_quarter": tg0["w2w_min"]["value"] == round(float(np.percentile(w2w, 25)), 2) and "best quarter" in tg0["w2w_min"]["how"] and tg0["trip_in_ft_h"] is None
+                        and abs(sum(w_["lost_connections_h"] for w_ in p0["wells"]) - lost0) < 0.02,
+        "declared": no_source and p1["targets"]["w2w_min"]["value"] == 5 and "drilling program 2026" in p1["targets"]["w2w_min"]["how"]
+                    and abs(W1["lost_connections_h"] - sum(c["w2w_min"] - 5 for c in W1["connection_list"]) / 60.0) < 0.01
+                    and abs(ti["lost_h"] - max(0.0, ti["hours"] - ti["feet"] / 2800.0)) < 0.001 and next(x for x in W1["trips"] if x["direction"] == "OUT")["lost_h"] is None,
+        "priced": p1["operating_usd_per_day"] == 30000 and abs(W1["lost_usd"] - W1["lost_h"] / 24.0 * 30000) < 0.006 * 30000 / 24.0,
+        "by_day": len(W1["days"]) == 1 and W1["days"][0]["date"] == "2026-08-01" and W1["days"][0]["connections"] == 3 and abs(W1["days"][0]["lost_h"] - W1["lost_h"]) < 0.02,
+        "invoice": ic["days"][0]["lost_time"] and abs(ic["days"][0]["lost_time"]["lost_h"] - W1["lost_h"]) < 0.02 and ic["days"][0]["status"] == "QUESTION",
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CP2 the targets: the pad's best quarter (the 25th percentile of its connections) when none is declared, a declared target needing its "
+       "source and then used; each connection's and trip's time past its target summed per well and per report day, priced at the contract's "
+       "operating rate, and shown beside the invoice check's day" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CP3 the report, the API, the CLI, the tab, the help ------------------------------------------------------------
+    rp = RS.write_report(ws, __version__, "tester")
+    rw = RS.write_report(ws, __version__, "tester", w1["id"])
+    rd = PDF.read(Path(rp["paths"]["pdf"]).read_bytes())
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer"); Users(str(Path(wsp, "users.json"))).add("op", "op-pass-123", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def opener(name, pw_):
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+        rq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": name, "password": pw_}).encode())
+        rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+        return o
+
+    def call(o, method, path, body=None):
+        rq = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        if method == "POST":
+            rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1")
+        try:
+            with o.open(rq, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_g, gj = call(V, "GET", "/api/rig-time")
+        s_vs, _ = call(V, "POST", "/api/rig-time/settings", {"w2w_min": 4, "source": "x"})
+        s_os, osj = call(O, "POST", "/api/rig-time/settings", {"w2w_min": 4.5, "source": "program B"})
+        s_bad, _ = call(O, "POST", "/api/rig-time/settings", {"w2w_min": -1, "source": "program B"})
+        s_bw, bwj = call(O, "POST", "/api/rig-time/settings", {"well_id": w2["id"], "block_weight_klbf": 42})
+        s_w, wj = call(O, "POST", "/api/rig-time/write", {"well_id": w2["id"]})
+    finally:
+        svc.stop()
+    cli_t = _sp.run([sys.executable, "-m", "gea", "rig-time", "--workspace", wsp], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_w = _sp.run([sys.executable, "-m", "gea", "rig-time", "--workspace", wsp, "--write"], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c3 = {
+        "report": rd["ok"] and "Rig time - Pad CP" in rd["text"][0] and Path(rw["paths"]["pdf"]).is_file() and "weight to weight" in Path(rp["paths"]["html"]).read_text(encoding="utf-8").lower(),
+        "api": s_g == 200 and len(gj["wells"]) == 2 and gj["targets"]["w2w_min"]["value"] == 5 and s_vs == 403 and s_os == 200 and osj["targets"]["w2w_min"] == 4.5
+               and s_bad == 400 and s_bw == 200 and bwj["block_weight_klbf"][w2["id"]] == 42 and s_w == 200 and wj["report_id"].startswith("RIG-"),
+        "cli": cli_t.returncode == 0 and "drilling connections: weight to weight median 9.0 min" in cli_t.stdout and "the block weight declared, 42 klbf" in cli_t.stdout
+               and cli_w.returncode == 0 and "printable:" in cli_w.stdout,
+        "page": all(x in page_src for x in ("VIEWS.rigtime", "['#/rigtime', 'Rig time']", "/api/rig-time/settings", "rtBars", "Lost vs targets")),
+        "help": any(t_[0] == "rig-time" for t_ in H.INDEX) and not H.check("rig-time") and H.VIEW_TOPIC.get("rigtime") == "rig-time",
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CP3 the pad's report and a well's, with their PDFs; the API (anyone signed in reads it; only an operator sets a target or a block "
+       "weight, or writes a report; a target below zero refused); the CLI (the rig time, the report); the tab and 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:
@@ -10705,6 +11008,8 @@ def main() -> int:
         section_cl_history_and_dossier(tmp)
         section_cm_watch_and_alerts(tmp)
         section_cn_four(tmp)
+        section_co_invoice_check(tmp)
+        section_cp_rig_time(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

gea_program-0.47.0/gea/help/invoice-check.md

@@ -0,0 +1,15 @@
+# The invoice cross-check
+
+> The drilling contractor's daywork invoice, day by day, against the daily drilling reports and the drilling record, at the contract's terms as the operator declares them: each day AGREES, is in QUESTION, or DIFFERS, with the dollars each difference puts in question and the line it comes from.
+
+**The command**: the **Invoice check** tab. Choose the well; declare the contract's terms once (where they came from, the hour the report day starts on the rig's clock and whether a report is dated by the day it starts or ends, the day rates - operating, and standby, repair, moving and force majeure where the contract has them - and the repair allowance in hours a job and a month); attach the daily drilling reports and the invoice as CSV files, each with its source. **Write the report** writes the client report with its PDF. From a terminal: `gea invoice-check --workspace C:\site --well W` prints the check; `--terms-source "..." --day-start 06:00 --operating 30000 --standby 25000 --repair 0 --repair-hours-month 24` declares the terms; `--attach-ddr FILE --source "..."` and `--attach-invoice FILE --source "..."` attach; `--write` writes the report; `--template ddr` or `--template invoice` prints the headings it reads.
+
+**The files**: saved from a spreadsheet as CSV and read by their headings. A daily drilling report: one row per line of the time breakdown - Date (the report's), Hours (or From and To), Code (the IADC operation code) or Activity, and Depth From and Depth To where it has them. An invoice: one row per charge - Date (or From and To for a span), Rate Type (operating, standby, repair, moving, force majeure; anything else - fuel, rentals - is listed and not checked), Quantity, Unit (day or hour), and Unit Price or Amount.
+
+**The checks**: the report's lines add up to 24 hours; hours reported drilling (code 2) against the record's hours on bottom making hole; the day's end depth and footage against the record's; a line coded drilling, reaming, circulating or trips over a span the record shows the pumps off, the rotary still and the bit still; a repair line over a span the record shows the rig working; more than 24 hours billed in a day, a day billed twice, billed with no report or nothing in the record; standby hours (code 33, or an activity that says standby or waiting on the operator's orders) billed at the operating rate; rig repair (code 8) past the allowance billed at the operating rate (IADC daywork contract, paragraph 4.4); a unit price that is not the contract's rate for its kind; quantity times price that is not the amount; and, as a question, a day billed at the operating rate on which the record shows the rig quiet six hours or more beyond the hours billed at standby, repair or force majeure.
+
+**What it writes**: the files and their index in `economics\invoices\`, the terms in `economics\invoices\terms.json`, the audit lines `invoice.terms`, `invoice.attach`, `invoice.remove`, `report.invoice_check`, and the report in `reports\wells\<well>\invoice_check.*` (PDF, HTML, markdown, JSON), kept in report history.
+
+**The number to check**: a day's dollars in question against its finding - the hours times the difference between the two rates, over 24; the record's hours against the well's charts for the same report day.
+
+**What this page will not call a measurement**: what is owed - the contract and the parties decide; this sets three accounts side by side at the terms as declared. The clocks - the report's and the recorder's are taken to be the rig's same clock. Quiet time on the recorder - waiting on cement, rigging up and repairs within the allowance are operating time with the pumps off, so quiet is a question, not a difference. A charge that is not a day rate.

gea_program-0.47.0/gea/help/rig-time.md

@@ -0,0 +1,15 @@
+# Rig time
+
+> What the rig did each second of the drilling record, read from the hook load, the block, the bit, the pumps and the rotary: the drilling connections timed weight to weight, the trips by speed, and the time lost against targets - the operator's declared targets, or this pad's own best quarter.
+
+**The command**: the **Rig time** tab: the hours of each well by rig state, the drilling connections (weight to weight, and its three parts), each well's connections over time against the target, its trips and its report days; the targets and the block weight (the operator role); **Write the pad's report** or one well's. From a terminal: `gea rig-time --workspace C:\site` prints it; `--write` (with `--well W` for one well) writes the report; `--w2w-min 5 --trip-in 2500 --trip-out 2800 --source "drilling program"` declares targets; `--well W --block-weight 45` sets a well's block weight.
+
+**The rig states**: IN SLIPS - the hook load below the block weight and half again, with the bit still (the rule rig-state software uses; the block weight is estimated from the hook load while the block moves and the bit does not, and printed); OFF THE HOOK - the same for half an hour or more (the string hung off, or no string: rigging, casing, waiting); ROTARY and SLIDE DRILLING - the record's own drilling samples, the rotary above 10 rpm or not; REAMING and WASHING - off bottom, pumping, the bit moving, with or without the rotary; CIRCULATING - pumping, the bit still; TRIPPING IN and OUT - the pumps off, the bit moving; STATIONARY - none of these.
+
+**The connections and trips**: a drilling connection is a break of an hour or less between two stretches of drilling, with the string set in the slips and the bit kept within a stand of bottom: weight to weight from the last second drilling to the first second drilling again, made of off bottom to slips set, in the slips, and slips pulled to drilling. A trip is a run of tripping and the slips between its stands, the pumps off, split where the bit turns back 500 ft, that moves the bit 1,000 ft or more: its speed is its footage over its pipe-handling hours (moving and in the slips); the breaks inside it are reported beside it.
+
+**What it writes**: the targets and block weights in `drillstring\rig_time.json`, the audit lines `rig_time.settings` and `report.rig_time`, and the reports `reports\rig_time_pad.*` and `reports\wells\<well>\rig_time.*` (PDF, HTML, markdown, JSON). The invoice check shows each report day's time lost beside the bill.
+
+**The number to check**: a connection's weight to weight against the well's charts at its time; the block weight printed for each well against the rig's; a trip's footage over its hours.
+
+**What this page will not call a measurement**: the cause of a long connection - a survey, a washout, a crew; the record shows the time, not the reason. A target beyond what this pad has done - the best quarter is this pad's own, not a technical limit. The slips themselves - a hook load threshold sees the weight leave the hook, and a block weight that differs from the estimate moves every slips time.

{gea_program-0.45.0 → gea_program-0.47.0}/gea/helplib.py

@@ -54,6 +54,8 @@ INDEX: List[tuple] = [
     ('report-history', 'Report history', 'every version of every client report kept in a dated folder with its SHA-256, when the next one replaces it'),
     ('pad-summary', 'The daily pad summary', 'one page each morning - what changed since the last one, what is due, what is still missing - kept in report history and sent through the notification rules'),
     ('dossier', 'The signed dossier', "a well's or the pad's reports, declarations, audit log and source hashes in one zip signed with the site's Ed25519 key, with a checker anyone can run without GEA"),
+    ('rig-time', 'Rig time', "what the rig did each second of the drilling record - drilling, the slips, tripping, circulating - its connections timed weight to weight, its trips by speed, and the time lost against the pad's own best quarter"),
+    ('invoice-check', 'The invoice cross-check', "the drilling contractor's daywork invoice, day by day, against the daily drilling reports and the drilling record at the contract's terms: hours, rates, standby, the repair allowance, depth and footage, with the dollars each difference puts in question"),
     ('economics', 'Economics', 'each well\'s days, footage and cost by the operator\'s own declared rates, against the EIA oil and gas spot prices while it was drilled, and any series the site imports'),
     ('well3d', 'The well in 3D', 'each well\'s path from its directional survey, set among the mapped formation surfaces and contours with its picks, coloured by what was measured along it, and the drill string replayed from the record; the Volve field shipped as the worked example'),
     ('charts', 'The charts', 'a well\'s channels stacked on one axis with a linked cursor, zoom and pan from every sample, time or depth for a drilling recorder, the depth events marked, and the drilling progress of every well'),
@@ -84,7 +86,7 @@ REQUIRED_LINES = ('**The command**', '**What it writes**', '**The number to chec
 VIEW_TOPIC: Dict[str, str] = {
     'home': 'start', 'wells': 'data-in', 'well': 'drift', 'live': 'patches', 'patch': 'patches', 'files': 'files', 'alarms': 'alarms',
     'approvals': 'well-tests', 'config': 'site', 'reports': 'drift', 'verify': 'start', 'survey': 'data-in', 'jobs': 'site',
-    'admin': 'site', 'prefs': 'site', 'search': 'start', 'welcome': 'start', 'seismic': 'seismic', 'seismic_station': 'seismic', 'track': 'seismic', 'sar': 'seismic', 'sites': 'sites', 'setup': 'setup', 'map': 'map', '3d': 'well3d', 'simulation': 'simulation', 'drillstring': 'drillstring', 'completion': 'penetrator', 'opseis': 'opseis', 'economics': 'economics', 'control': 'control-room', 'wall': 'control-room', 'audit': 'audit-update', 'tools': 'tools', 'catalog': 'catalog',
+    'admin': 'site', 'prefs': 'site', 'search': 'start', 'welcome': 'start', 'seismic': 'seismic', 'seismic_station': 'seismic', 'track': 'seismic', 'sar': 'seismic', 'sites': 'sites', 'setup': 'setup', 'map': 'map', '3d': 'well3d', 'simulation': 'simulation', 'drillstring': 'drillstring', 'completion': 'penetrator', 'opseis': 'opseis', 'economics': 'economics', 'invoices': 'invoice-check', 'rigtime': 'rig-time', 'control': 'control-room', 'wall': 'control-room', 'audit': 'audit-update', 'tools': 'tools', 'catalog': 'catalog',
 }