gea-program 0.46.0__tar.gz → 0.48.0__tar.gz

{gea_program-0.46.0 → gea_program-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.46.0
+Version: 0.48.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,31 @@ 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`.
 
+### One record, tied together
+
+The invoice check, rig time, the daily summary, the alerts, the signed
+dossier and the declarations sheet now read each other: an invoice that
+differs is an alert; the morning summary carries each well's invoice check
+and yesterday's rig time; a signed dossier carries the contract, the
+invoices and daily reports as attached, the rig-time targets and casing,
+and both checks as they read at signing. The declarations sheet declares
+the contract, the rig-time targets, block weights, casing shoes and the
+watch and summary settings, and every file the program reads as a table -
+the sheet, an invoice, a daily report - may be an Excel workbook. Casing
+shoes split rig time by hole section.
+
+### 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

{gea_program-0.46.0 → gea_program-0.48.0}/README.md

@@ -609,6 +609,31 @@ 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`.
 
+### One record, tied together
+
+The invoice check, rig time, the daily summary, the alerts, the signed
+dossier and the declarations sheet now read each other: an invoice that
+differs is an alert; the morning summary carries each well's invoice check
+and yesterday's rig time; a signed dossier carries the contract, the
+invoices and daily reports as attached, the rig-time targets and casing,
+and both checks as they read at signing. The declarations sheet declares
+the contract, the rig-time targets, block weights, casing shoes and the
+watch and summary settings, and every file the program reads as a table -
+the sheet, an invoice, a daily report - may be an Excel workbook. Casing
+shoes split rig time by hole section.
+
+### 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

{gea_program-0.46.0 → gea_program-0.48.0}/gea/__init__.py

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

{gea_program-0.46.0 → gea_program-0.48.0}/gea/__main__.py

@@ -590,6 +590,21 @@ 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("--casing", type=str, default=None, help="with --well, --shoe-md and --source: declare a casing shoe, its size in inches as written (13-3/8)")
+    p_rt.add_argument("--shoe-md", type=str, default=None, help="the shoe's measured depth, ft")
+    p_rt.add_argument("--set-time", type=str, default=None, help="when the casing was set (the recorder's clock); otherwise when the hole is 50 ft past the shoe")
+    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)
@@ -2193,9 +2208,10 @@ def main(argv=None) -> int:
         if not a.file:
             raise SystemExit("declare: give --file <sheet.csv> (or --template <out.csv> to start one)")
         try:
-            with open(a.file, encoding="utf-8-sig") as f:
-                text_ = f.read()
-        except OSError as e:
+            from . import xlsx_read as _XR
+            with open(a.file, "rb") as f:
+                text_ = _XR.text_of(f.read())
+        except (OSError, ValueError, KeyError) as e:
             raise SystemExit(f"declare: {e}")
         p = _DC.apply(ws, text_, a.actor, os.path.dirname(os.path.abspath(a.file)), write=a.apply)
         print(_json.dumps(p, default=str) if a.json else _DC.text(p))
@@ -2356,6 +2372,38 @@ 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.casing:
+                if not a.well:
+                    raise ValueError("--casing needs --well")
+                c_ = _RS.set_casing(ws, a.actor, a.well, a.casing, a.shoe_md, a.source, a.set_time)
+                print(f"casing {c_['size']} in, shoe at {c_['shoe_md_ft']:,.0f} ft MD ({c_['source']})")
+                return 0
+            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

{gea_program-0.46.0 → gea_program-0.48.0}/gea/acceptance_tests.py

@@ -10761,6 +10761,358 @@ def section_co_invoice_check(tmp: str) -> None:
        + (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 section_cq_tied_together(tmp: str) -> None:
+    """Section CQ - the recent parts tied together: an Excel workbook read without Excel (shared and inline strings,
+    numbers, booleans, dates and times from their cell formats, the 1904 epoch, a named sheet) and taken wherever a
+    CSV is - the invoice check's files and the declarations sheet; the declarations sheet's new tables (the contract,
+    the rig-time targets, block weights, casing, the watch and summary settings) planned, written, round-tripped and
+    refused when wrong; rig time by hole section from declared casing; the invoice differing raised as an alert and
+    cleared; the daily summary carrying each invoice check and yesterday's rig time; a signed dossier carrying the
+    contract, the files, the targets, the casing and both checks as they read at signing; the API, the CLI, the tabs
+    and the help pages."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import base64 as _b64
+    import zipfile as _zf
+    from datetime import datetime as _dtm, timedelta as _td, timezone as _tz
+    from . import __version__
+    from . import alerts as AL
+    from . import declarations as DC
+    from . import dossier as DZ
+    from . import helplib as H
+    from . import invoice_check as IC
+    from . import pad_summary as PS
+    from . import rig_state as RS
+    from . import seismic_watch as SW
+    from . import xlsx_read as XR
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "cq"); d.mkdir()
+
+    # -- CQ1 the workbook -------------------------------------------------------------------------------------------------
+    XR.write_simple(str(d / "a.xlsx"), [["Date", "Rate Type", "Quantity", "Note"], [_dtm(2026, 7, 1), "Operating day rate", 1, 'with, a "comma"'],
+                                        [_dtm(2026, 7, 2, 6, 30), "Standby", 12.5, None]])
+    a = XR.rows((d / "a.xlsx").read_bytes())
+    ns = 'xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"'
+    with _zf.ZipFile(d / "b.xlsx", "w") as z:                 # a hand-made workbook: two sheets, inline strings, booleans, the 1904 epoch, a custom date format
+        z.writestr("xl/workbook.xml", f'<workbook {ns}><workbookPr date1904="1"/><sheets><sheet name="Notes" sheetId="1" r:id="rId1"/><sheet name="Invoice" sheetId="2" r:id="rId2"/></sheets></workbook>')
+        z.writestr("xl/_rels/workbook.xml.rels", '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Target="worksheets/sheet1.xml" Type="x"/><Relationship Id="rId2" Target="/xl/worksheets/sheet2.xml" Type="x"/></Relationships>')
+        z.writestr("xl/styles.xml", f'<styleSheet {ns}><numFmts count="1"><numFmt numFmtId="164" formatCode="dd/mm/yyyy\\ hh:mm"/><numFmt numFmtId="165" formatCode="#,##0.00"/></numFmts>'
+                                    '<cellXfs count="3"><xf numFmtId="0"/><xf numFmtId="164"/><xf numFmtId="165"/></cellXfs></styleSheet>')
+        z.writestr("xl/worksheets/sheet1.xml", f'<worksheet {ns}><sheetData><row r="1"><c r="A1" t="inlineStr"><is><t>notes</t></is></c></row></sheetData></worksheet>')
+        z.writestr("xl/worksheets/sheet2.xml", f'<worksheet {ns}><sheetData><row r="1"><c r="A1" t="inlineStr"><is><t>When</t></is></c><c r="C1" t="inlineStr"><is><t>Paid</t></is></c></row>'
+                                               '<row r="3"><c r="A3" s="1"><v>44743.25</v></c><c r="B3" s="2"><v>1234.5</v></c><c r="C3" t="b"><v>1</v></c></row></sheetData></worksheet>')
+    bx = (d / "b.xlsx").read_bytes()
+    b2 = XR.rows(bx, "Invoice")
+    c1 = {
+        "simple": a == [["Date", "Rate Type", "Quantity", "Note"], ["2026-07-01", "Operating day rate", "1", 'with, a "comma"'], ["2026-07-02T06:30", "Standby", "12.5"]],
+        "csv": XR.to_csv((d / "a.xlsx").read_bytes()).splitlines()[1] == '2026-07-01,Operating day rate,1,"with, a ""comma"""',
+        "sheets": XR.sheets(bx) == ["Notes", "Invoice"] and XR.rows(bx) == [["notes"]],
+        "hand_made": b2 == [["When", "", "Paid"], [], ["2026-07-02T06:00", "1234.5", "TRUE"]],
+        "text_of": XR.text_of(b"a,b\n1,2\n") == "a,b\n1,2\n" and not XR.is_xlsx(b"PK not a zip"),
+    }
+    try:
+        XR.rows(bx, "Nope"); c1["named"] = False
+    except ValueError as e:
+        c1["named"] = "Notes, Invoice" in str(e)
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CQ1 an Excel workbook read with the standard library: shared and inline strings, a comma and quotes kept, whole numbers without "
+       "'.0', dates and date-times from built-in and custom formats, the 1904 epoch, booleans, a gap row kept as a gap, the first or a "
+       "named sheet; CSV text passed through" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CQ2 the declarations sheet, casing, and the invoice as a workbook --------------------------------------------------
+    F = RS.selftest_edr(str(d))
+    G = IC.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad CQ", actor="tester")
+    w1 = ws.add_well_file(F["path"], display="RIG-1", actor="tester"); w2 = ws.add_well_file(F["path"], display="RIG-2", actor="tester")
+    wi = ws.add_well_file(G["edr"], display="INV-1", actor="tester")
+    sheet = ("[contract],day_start,report_date,operating,standby,repair,repair_hours_per_month,source\n,06:00,start,30000,25000,0,2,daywork contract A\n"
+             "[rig_time],w2w_min,trip_in_ft_h,source\n,,2800,program 2026\n[block_weights],well,block_weight_klbf\n,RIG-2,42\n"
+             "[casing],well,size_in,shoe_md_ft,set,source\n,RIG-1,9-5/8,10150,,tally\n,RIG-2,9-5/8,10150,,tally\n,RIG-1,13-3/8,2000,,tally\n"
+             "[settings],setting,value\n,watch_every_min,10\n,summary_at,10:45\n,summary_send,no\n")
+    rows_ = [ln.split(",") for ln in sheet.strip().splitlines()]
+    XR.write_simple(str(d / "decl.xlsx"), rows_)
+    p_x = DC.plan(ws, XR.text_of((d / "decl.xlsx").read_bytes()))
+    p_w = DC.apply(ws, sheet, "tester", write=True)
+    p_rt = DC.plan(ws, DC.template(ws))
+    p_bad = DC.plan(ws, "[contract],operating,source\n,30000,\n[settings],setting,value\n,watch_mode,sometimes\n,colour,blue\n[casing],well,size_in,shoe_md_ft,source\n,RIG-1,9 5/8,100,x\n,NOPE,7,100,x\n")
+    pad = RS.pad(ws)
+    W1 = next(w for w in pad["wells"] if w["display"] == "RIG-1")
+    secs = [c["section"] for c in W1["connection_list"]]
+    XR.write_simple(str(d / "inv.xlsx"), [ln.split(",") if i == 0 else [(_dtm.fromisoformat(x) if j == 0 else (float(x) if re.fullmatch(r"[\d.]+", x) else x)) for j, x in enumerate(ln.split(","))]
+                                          for i, ln in enumerate(G["invoice"].strip().splitlines())])
+    IC.attach(ws, "tester", wi["id"], "ddr", "ddr.csv", G["ddr"].encode(), "reports")
+    IC.attach(ws, "tester", wi["id"], "invoice", "inv.xlsx", (d / "inv.xlsx").read_bytes(), "invoice as a workbook")
+    ic = IC.check(ws, wi["id"])
+    c2 = {
+        "xlsx_sheet": p_x["counts"]["NEW"] == 6 and p_x["counts"]["CHANGE"] == 3 and not p_x["errors"],
+        "written": p_w["applied"] and IC.terms(ws)["rates_usd_per_day"] == {"operating": 30000.0, "standby": 25000.0, "repair": 0.0}
+                   and RS.settings(ws)["targets"] == {"trip_in_ft_h": 2800.0} and RS.settings(ws)["block_weight_klbf"] == {w2["id"]: 42.0}
+                   and [x["size"] for x in RS.casing(ws)[w1["id"]]] == ["13-3/8", "9-5/8"] and SW.settings(ws)["every_min"] == 10
+                   and PS.settings(ws)["at"] == "10:45" and PS.settings(ws)["send"] is False,
+        "round_trip": p_rt["counts"]["NEW"] == 0 and p_rt["counts"]["CHANGE"] == 0 and not p_rt["errors"],
+        "refused": len(p_bad["errors"]) == 5 and any("watch_mode" in e for e in p_bad["errors"]) and any("no setting 'colour'" in e for e in p_bad["errors"])
+                   and any("13-3/8, 9-5/8 or 7" in e for e in p_bad["errors"]) and any("came from" in e for e in p_bad["errors"]),
+        "sections": secs == ["below the 13-3/8 in shoe", "below the 9-5/8 in shoe", "below the 9-5/8 in shoe"]
+                    and all(x["hole"] == "CASED" for x in W1["trips"]) and set(pad["targets"]["by_section"]) == {"below the 9-5/8 in shoe"}
+                    and next(w for w in pad["wells"] if w["display"] == "RIG-2")["block_weight_klbf"] == 42.0,
+        "invoice_xlsx": ic["status"] == "DIFFERS" and ic["totals"]["usd_in_question"] == 37666.67,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CQ2 the declarations sheet's new tables - the contract, the rig-time targets, a block weight, casing shoes, the watch and summary "
+       "settings - read from a workbook, written, round-tripped to nothing to do, and refused when wrong (no source, an unknown setting, a "
+       "size not in inches as written, a well not there); connections by hole section and trips inside casing; an invoice attached as a "
+       "workbook checked to the same 37,666.67" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CQ3 the alert, the summary, the dossier ----------------------------------------------------------------------
+    now = _dtm(2026, 7, 2, 12, 0, tzinfo=_tz.utc)
+    k1 = AL.check_conditions(ws, None, now, force=True)
+    st1 = dict(AL.state(ws)["conditions"])
+    g = PS.gather(ws, _dtm(2026, 8, 2, 7, 0, tzinfo=_tz.utc), _dtm(2026, 8, 1, 0, 0, tzinfo=_tz.utc))
+    RS.write_report(ws, __version__, "tester")
+    e1 = DZ.build(ws, "tester", __version__, None)
+    with _zf.ZipFile(os.path.join(ws.reports_dir, e1["path"])) as z:
+        names = set(z.namelist())
+        rt = json.loads(z.read("results/rig_time.json"))
+        icj = json.loads(z.read(f"results/invoice_check/{wi['id']}.json"))
+    v1 = DZ.verify(os.path.join(ws.reports_dir, e1["path"]), ws)
+    for f_ in IC.files(ws, wi["id"]):                     # the corrected report and invoice replace them
+        IC.remove(ws, "tester", f_["file"])
+    ddr_ok = G["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(ws, "tester", wi["id"], "ddr", "ddr_ok.csv", ddr_ok.encode(), "corrected reports")
+    IC.attach(ws, "tester", wi["id"], "invoice", "inv_ok.csv", inv_ok.encode(), "corrected invoice")
+    k2 = AL.check_conditions(ws, None, now + _td(minutes=1))
+    c3 = {
+        "alert": [a_["event"] for a_ in k1 if a_["event"] == "invoice.differs"] == ["invoice.differs"] and f"invoice.differs:{wi['id']}" in st1
+                 and "37,666.67" in next(a_ for a_ in k1 if a_["event"] == "invoice.differs")["detail"],
+        "cleared": [a_["event"] for a_ in k2] == ["condition.cleared"] and k2[0]["cleared"] == "invoice.differs",
+        "summary": any(x["item"] == "the invoice check of INV-1" and x["status"] == "DIFFERS" for x in g["due"])
+                   and [x["well"] for x in g["rig_time"]] == ["RIG-1", "RIG-2"] and all(x["connections"] == 3 and x["date"] == "2026-08-01" for x in g["rig_time"])
+                   and all(x["lost_usd"] is not None for x in g["rig_time"]),
+        "dossier": v1["status"] == "VALID" and {"declarations/economics/invoices/terms.json", "declarations/economics/invoices/files.json",
+                                                 "declarations/drillstring/rig_time.json", "declarations/drillstring/casing.json"} <= names
+                   and any(n.startswith(f"declarations/economics/invoices/{wi['id']}/") and n.endswith("_inv.xlsx") for n in names)
+                   and icj["status"] == "DIFFERS" and len(rt["wells"]) == 3 and rt["targets"]["trip_in_ft_h"]["value"] == 2800,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CQ3 an invoice that differs raised as an alert with its dollars, and cleared when a corrected invoice replaces it; the daily summary "
+       "carrying the invoice check and yesterday's rig time well by well with its cost at the contract's rate; a signed pad dossier carrying "
+       "the contract, the invoice files as attached, the targets and the casing, and both checks as they read at signing - VALID"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CQ4 the API, the CLI, the tabs, the help ------------------------------------------------------------------------
+    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_vc, _ = call(V, "POST", "/api/rig-time/casing", {"well_id": w2["id"], "size": "7", "shoe_md_ft": 9000, "source": "x"})
+        s_oc, ocj = call(O, "POST", "/api/rig-time/casing", {"well_id": w2["id"], "size": "7", "shoe_md_ft": 9000, "source": "tally"})
+        s_ob, _ = call(O, "POST", "/api/rig-time/casing", {"well_id": w2["id"], "size": "seven", "shoe_md_ft": 9000, "source": "tally"})
+        s_or, _ = call(O, "POST", "/api/rig-time/casing/remove", {"well_id": w2["id"], "size": "7"})
+        s_dx, dxj = call(O, "POST", "/api/declare", {"content_b64": _b64.b64encode((d / "decl.xlsx").read_bytes()).decode()})
+        s_ia, iaj = call(O, "POST", "/api/invoice-check/attach", {"well_id": wi["id"], "kind": "invoice", "filename": "inv2.xlsx", "source": "workbook",
+                                                                   "content_b64": _b64.b64encode((d / "inv.xlsx").read_bytes()).decode()})
+        s_al, alj = call(V, "GET", "/api/alerts")
+    finally:
+        svc.stop()
+    cli_c = _sp.run([sys.executable, "-m", "gea", "rig-time", "--workspace", wsp, "--well", w2["id"], "--casing", "13-3/8", "--shoe-md", "2000", "--source", "tally"],
+                    capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_d = _sp.run([sys.executable, "-m", "gea", "declare", "--workspace", wsp, "--file", str(d / "decl.xlsx")], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c4 = {
+        "api": s_vc == 403 and s_oc == 200 and ocj["shoe_md_ft"] == 9000 and s_ob == 400 and s_or == 200 and s_dx == 200 and dxj["counts"]["SAME"] == 9
+               and s_ia == 200 and iaj["lines"] == 7 and s_al == 200 and "invoice.differs" in alj["events"],
+        "cli": cli_c.returncode == 0 and "13-3/8 in, shoe at 2,000 ft" in cli_c.stdout and cli_d.returncode == 0 and "already declared" in cli_d.stdout,
+        "page": all(x in page_src for x in ("rtC", "/api/rig-time/casing", ".xlsx", "content_b64: DC.b64", "'invoice.differs': 'Invoice differs'")),
+        "help": all(not H.check(t_) for t_ in ("declare", "rig-time", "invoice-check", "dossier", "alerts", "pad-summary"))
+                and "[casing]" in (pkg / "help" / "declare.md").read_text(encoding="utf-8") and "Hole sections" in (pkg / "help" / "rig-time.md").read_text(encoding="utf-8")
+                and "invoice.differs" in (pkg / "help" / "alerts.md").read_text(encoding="utf-8") and "results/" in (pkg / "help" / "dossier.md").read_text(encoding="utf-8"),
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "CQ4 on the API (only an operator declares or removes a casing shoe, a size that is not one refused; a declarations workbook and an "
+       "invoice workbook sent as they are; the new alert listed), the CLI (a casing shoe, a declarations workbook), the tabs and the help pages"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 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:
@@ -10857,6 +11209,8 @@ def main() -> int:
         section_cm_watch_and_alerts(tmp)
         section_cn_four(tmp)
         section_co_invoice_check(tmp)
+        section_cp_rig_time(tmp)
+        section_cq_tied_together(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.46.0 → gea_program-0.48.0}/gea/alerts.py

@@ -13,7 +13,9 @@ worth an event, for the conditions the operator does not watch by hand:
 - `penetrator.outside` - a line of an ESP well's penetrator check is OUTSIDE its rating (the Completion tab);
 - `dossier.changed` - the newest signed dossier of a well or the pad no longer matches the workspace: a source
   record or an earlier audit line has changed since it was signed (checked once a day);
-- `condition.cleared` - one of the last three is no longer so.
+- `invoice.differs` - a well's invoice cross-check finds a day that DIFFERS (checked once a day, and when a file is
+  attached);
+- `condition.cleared` - one of the last four is no longer so.
 
 Every alert is written to `records/alerts.jsonl` whether or not any notification channel is set up - the Alarms
 tab lists them - and is handed to the notification rules, which send it where the site said (a rule per event
@@ -28,7 +30,7 @@ from datetime import datetime, timezone
 from typing import Dict, List, Optional
 
 EVENTS = ('seismic.protocol', 'seismic.event', 'seismic.watch_down', 'seismic.watch_up', 'motor.due', 'penetrator.outside',
-          'dossier.changed', 'condition.cleared')
+          'dossier.changed', 'invoice.differs', 'condition.cleared')
 CONDITIONS_EVERY_S = 900          # motors and penetrators: every 15 minutes
 DOSSIERS_EVERY_S = 86400          # dossiers: once a day
 _LOCK = threading.Lock()
@@ -173,5 +175,21 @@ def check_conditions(ws, notifier, now: Optional[datetime] = None, force: bool =
                              'dossier_id': e['dossier_id'], 'detail': '; '.join(f"{c['check']}: {c['detail']}" for c in bad)}, now, raised)
         except Exception as ex:
             last['dossiers_error'] = f'{type(ex).__name__}: {ex}'
+    if due('invoices', DOSSIERS_EVERY_S):
+        last['invoices'] = _utc(now)
+        try:
+            from . import invoice_check as IC
+            if IC.terms(ws):
+                for wid in sorted({f['well_id'] for f in IC.files(ws)}):
+                    if wid not in wells:
+                        continue
+                    r = IC.check(ws, wid)
+                    T = r.get('totals') or {}
+                    _transition(ws, notifier, st, f'invoice.differs:{wid}', r.get('status') == 'DIFFERS',
+                                {'event': 'invoice.differs', 'well_id': wid, 'well': wells[wid], 'what': f'the invoice cross-check of {wells[wid]}',
+                                 'detail': f"{T.get('differs', 0)} day(s) differ, {T.get('usd_in_question', 0):,.2f} USD in question of {T.get('billed_checked_usd', 0):,.2f} billed at day rates",
+                                 'usd_in_question': T.get('usd_in_question')}, now, raised)
+        except Exception as ex:
+            last['invoices_error'] = f'{type(ex).__name__}: {ex}'
     save_state(ws, st)
     return raised