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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.46.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,18 @@ 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

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

@@ -609,6 +609,18 @@ 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

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

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

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

@@ -590,6 +590,18 @@ 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)
@@ -2356,6 +2368,32 @@ 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

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

@@ -10761,6 +10761,158 @@ 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 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 +11009,7 @@ def main() -> int:
         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/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.46.0 → gea_program-0.47.0}/gea/helplib.py

@@ -54,6 +54,7 @@ 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'),
@@ -85,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', 'invoices': 'invoice-check', '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',
 }
 
 

{gea_program-0.46.0 → gea_program-0.47.0}/gea/invoice_check.py

@@ -618,6 +618,13 @@ def check(ws, well_id: str) -> dict:
         D['status'] = 'DIFFERS' if 'DIFFERS' in sev else 'QUESTION' if 'QUESTION' in sev else 'AGREES'
         D['usd_in_question'] = round(sum(f['usd_in_question'] for f in D['findings']), 2)
         out['days'].append(D)
+    try:                                                  # the time lost against the pad's targets, beside each day (not a finding: daywork pays it)
+        from . import rig_state as RS
+        lost = RS.lost_by_day(ws, well_id)
+    except Exception:
+        lost = {}
+    for D in out['days']:
+        D['lost_time'] = lost.get(D['date'])
     out['totals'] = {'days': len(out['days']), 'agrees': sum(d['status'] == 'AGREES' for d in out['days']),
                      'question': sum(d['status'] == 'QUESTION' for d in out['days']), 'differs': sum(d['status'] == 'DIFFERS' for d in out['days']),
                      'billed_usd': round(sum(ln['amount'] or 0.0 for ln in inv), 2),
@@ -655,10 +662,13 @@ def build_report(ws, well_id: str, version: str):
     hw = r.get('how') or r.get('detail') or ''
     s1.paragraphs.append(hw[:1].upper() + hw[1:] + '.')
     s2 = CR.Section('2', 'Day by day', [], [])
-    s2.tables.append(CR.Table(['Day', 'Result', 'Billed (h)', 'Billed (USD)', 'Report (h)', 'Record: working / quiet / drilling (h)', 'USD in question'],
+    s2.tables.append(CR.Table(['Day', 'Result', 'Billed (h)', 'Billed (USD)', 'Report (h)', 'Record: working / quiet / drilling (h)', 'Time lost vs targets (h)', 'USD in question'],
                               [[d['date'], d['status'], ', '.join(f"{k.replace('_', ' ')} {v:g}" for k, v in d['billed_hours'].items()) or '-', f"{d['billed_usd']:,.2f}",
                                 f"{d['ddr_hours']:g}", (f"{d['record']['active_h']:.1f} / {d['record']['quiet_h']:.1f} / {d['record']['drilling_h']:.1f}" if d['record'] else 'not in the record'),
-                                f"{d['usd_in_question']:,.2f}"] for d in r['days']]))
+                                (f"{d['lost_time']['lost_h']:.2f}" if d.get('lost_time') else '-'), f"{d['usd_in_question']:,.2f}"] for d in r['days']]))
+    if any(d.get('lost_time') for d in r['days']):
+        s2.paragraphs.append('Time lost vs targets: the drilling connections\' weight-to-weight time and the trips\' pipe-handling time past the pad\'s targets '
+                             '(the Rig time tab). Under daywork the operator pays for it; it is shown beside the bill, not counted in question.')
     s3 = CR.Section('3', 'What differs, and what to ask', [], [])
     if r['findings']:
         s3.tables.append(CR.Table(['Day', 'Check', 'Result', 'What the three accounts say', 'USD', 'Line'],