gea-program 0.36.0__tar.gz → 0.38.0__tar.gz

{gea_program-0.36.0/gea_program.egg-info → gea_program-0.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.36.0
+Version: 0.38.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,28 @@ 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`.
 
+### The client well report
+
+`gea well-report` writes one printable document per well and one for the
+pad: the drilling record and its depth events with who checked them, a chart
+of depth against days, the declared location and what the mapped structure
+says there, the well path from its survey in plan and section, and the
+declared cost against the market while it was drilled - each number with
+where it came from, and what the report cannot say yet with what would
+supply it. Buttons on the well page and the Reports page; included in the
+month-end packet. `gea help well-report`.
+
+### Economics
+
+The Economics tab puts each well's days on its drilling record, feet
+drilled and feet per day beside what it cost by the operator's own declared
+day rates, items and AFE - cost per foot, per day and by section, never
+divided while the rates leave time uncovered - and sets each well against
+the U.S. Energy Information Administration's daily WTI and Henry Hub spot
+prices while it was drilled. The prices ship with the program and refresh
+on request; any other series (a rig count) is imported with its source.
+`gea economics`, `gea help economics`.
+
 ### The well in 3D
 
 The 3D tab draws each well's path from its directional survey by the

{gea_program-0.36.0 → gea_program-0.38.0}/README.md

@@ -609,6 +609,28 @@ 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`.
 
+### The client well report
+
+`gea well-report` writes one printable document per well and one for the
+pad: the drilling record and its depth events with who checked them, a chart
+of depth against days, the declared location and what the mapped structure
+says there, the well path from its survey in plan and section, and the
+declared cost against the market while it was drilled - each number with
+where it came from, and what the report cannot say yet with what would
+supply it. Buttons on the well page and the Reports page; included in the
+month-end packet. `gea help well-report`.
+
+### Economics
+
+The Economics tab puts each well's days on its drilling record, feet
+drilled and feet per day beside what it cost by the operator's own declared
+day rates, items and AFE - cost per foot, per day and by section, never
+divided while the rates leave time uncovered - and sets each well against
+the U.S. Energy Information Administration's daily WTI and Henry Hub spot
+prices while it was drilled. The prices ship with the program and refresh
+on request; any other series (a rig count) is imported with its source.
+`gea economics`, `gea help economics`.
+
 ### The well in 3D
 
 The 3D tab draws each well's path from its directional survey by the

{gea_program-0.36.0 → gea_program-0.38.0}/gea/__init__.py

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

{gea_program-0.36.0 → gea_program-0.38.0}/gea/__main__.py

@@ -475,6 +475,30 @@ def main(argv=None) -> int:
     p_ck.add_argument("--note", type=str, default="", help="--confirm: what it was checked against (required)")
     p_ck.add_argument("--actor", type=str, default="cli")
 
+    p_wr = sub.add_parser("well-report", help="the client well report: one printable document per well (drilling record, depth events, progress chart, location and structure, well path, cost and the market) and one for the pad")
+    p_wr.add_argument("--workspace", type=str, required=True)
+    p_wr.add_argument("--well", type=str, default=None, help="one well's report (the default is every well and the pad)")
+    p_wr.add_argument("--pad", action="store_true", help="the pad report only")
+    p_wr.add_argument("--actor", type=str, default="cli")
+
+    p_ec = sub.add_parser("economics", help="each well's time, footage and declared cost against the market while it was drilled; declare rates, items and an AFE; refresh or import price series")
+    p_ec.add_argument("--workspace", type=str, required=True)
+    p_ec.add_argument("--json", action="store_true")
+    p_ec.add_argument("--well", type=str, default=None, help="the well a rate, item or AFE is for")
+    p_ec.add_argument("--rate", type=float, default=None, help="a day rate, USD/day, over --from/--to (open when left out)")
+    p_ec.add_argument("--item", type=float, default=None, help="a one-off cost, USD (a bit, a cement job), optionally --section N")
+    p_ec.add_argument("--afe", type=float, default=None, help="the well's AFE, USD")
+    p_ec.add_argument("--what", type=str, default="", help="what the rate or item pays for")
+    p_ec.add_argument("--section", type=int, default=None)
+    p_ec.add_argument("--from", dest="date_from", type=str, default=None, help="rate start, ISO date or date-time on the recorder's clock")
+    p_ec.add_argument("--to", dest="date_to", type=str, default=None, help="rate end")
+    p_ec.add_argument("--source", type=str, default="", help="where the number came from (contract, invoice, AFE number)")
+    p_ec.add_argument("--refresh-prices", action="store_true", help="fetch the latest EIA spot-price copies into the workspace")
+    p_ec.add_argument("--import-series", type=str, default=None, help="a CSV of dates and values to keep beside the prices (a rig count)")
+    p_ec.add_argument("--name", type=str, default="")
+    p_ec.add_argument("--unit", type=str, default="")
+    p_ec.add_argument("--actor", type=str, default="cli")
+
     p_tj = sub.add_parser("trajectory", help="attach a well's directional survey (WITSML trajectory or a table of MD, Inc, Azi), kept verbatim beside the well, so the 3D tab can draw its path")
     p_tj.add_argument("--workspace", type=str, required=True)
     p_tj.add_argument("--well", type=str, required=True)
@@ -1954,6 +1978,63 @@ def main(argv=None) -> int:
         else:
             print(_SC.text(r))
         return 0 if r["ready"] else 2
+    elif a.cmd == "economics":
+        import json as _json
+        from . import economics as _EC
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace)
+        except WorkspaceError as e:
+            raise SystemExit(f"economics: {e}")
+        try:
+            if a.rate is not None:
+                r = _EC.set_rate(ws, a.well or "", a.actor, a.rate, a.what, a.source, a.date_from, a.date_to)
+                print(f"{a.well}: {r['usd_per_day']:,.2f} USD/day {r['what']} from {r['from'] or 'open'} to {r['to'] or 'open'}")
+                return 0
+            if a.item is not None:
+                r = _EC.add_item(ws, a.well or "", a.actor, a.item, a.what, a.source, a.section)
+                print(f"{a.well}: {r['usd']:,.2f} USD {r['what']}")
+                return 0
+            if a.afe is not None:
+                r = _EC.set_afe(ws, a.well or "", a.actor, a.afe, a.source)
+                print(f"{a.well}: AFE {r['usd']:,.2f} USD ({r['source']})")
+                return 0
+            if a.refresh_prices:
+                for r in _EC.refresh_prices(ws, a.actor):
+                    print(f"{r['id']}: {r['status']}" + (f" to {r['as_of']} ({r['rows']} days)" if r.get('as_of') else f" - {r.get('why', '')}"))
+                return 0
+            if a.import_series:
+                with open(a.import_series, "rb") as f:
+                    r = _EC.import_series(ws, a.actor, a.name, a.unit, a.source, f.read())
+                print(f"{r['name']}: {r['rows']} values, {r['first']} to {r['as_of']} ({r['unit']})")
+                return 0
+        except (ValueError, KeyError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"economics: {e.args[0] if e.args else e}")
+        e = _EC.economics(ws)
+        print(_json.dumps(e, indent=1) if a.json else _EC.text(e))
+        return 0
+    elif a.cmd == "well-report":
+        from . import well_report as _WR
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace)
+        except WorkspaceError as e:
+            raise SystemExit(f"well-report: {e}")
+        ids = [w["id"] for w in ws.wells()]
+        if a.well and a.well not in ids:
+            raise SystemExit(f"well-report: no well {a.well} (the wells are: {', '.join(ids) or 'none'})")
+        todo = [] if a.pad else ([a.well] if a.well else ids)
+        for wid in todo:
+            r = _WR.write_well(ws, wid, __version__, actor=a.actor)
+            print(f"{wid}: {r['paths']['html']}" + (f"\n  not in it yet: {'; '.join(r['missing'])}" if r["missing"] else ""))
+        if a.pad or not a.well:
+            r = _WR.write_pad(ws, __version__, actor=a.actor)
+            print(f"pad: {r['paths']['html']}")
+        return 0
     elif a.cmd in ("trajectory", "well3d"):
         import json as _json
         from . import well3d as _W3

{gea_program-0.36.0 → gea_program-0.38.0}/gea/acceptance_tests.py

@@ -2917,7 +2917,7 @@ def section_am_report_samples(tmp: str) -> None:
             "model_card_strata_property_estimator.html", "gauge_drift_report_monitored_SYNTHETIC.html", "alarm_event_report_SYNTHETIC.html",
             "data_resilience_report_SYNTHETIC.html", "sla_report_SYNTHETIC.html", "sat_protocol.html", "seismic_station_report_SYNTHETIC.html", "seismic_track_report_SYNTHETIC.html",
             "seismic_dataset_report_SYNTHETIC.html", "seismic_field_report_SYNTHETIC.html", "site_report_SYNTHETIC.html",
-            "sra_packet_SYNTHETIC.html"}
+            "sra_packet_SYNTHETIC.html", "well_report_SYNTHETIC.html", "pad_report_SYNTHETIC.html"}
     have = {p.name for p in d.glob("*.html")}
     md = (d / "SAMPLES.md").read_text(encoding="utf-8") if (d / "SAMPLES.md").exists() else ""
     texts = {n: (d / n).read_text(encoding="utf-8", errors="replace") for n in sorted(have & want)}
@@ -8800,6 +8800,343 @@ def section_ce_well3d(tmp: str) -> None:
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 
+
+def section_cf_economics(tmp: str) -> None:
+    """Section CF - economics: the shipped EIA spot prices checked against their provenance and against two days EIA
+    published, series refreshed and imported only when they read, a well's cost from declared rates done by hand and
+    left undivided when the rates leave time uncovered, the market while the well was drilled, the API, the CLI, the tab."""
+    import base64 as _b64
+    import gzip as _gz
+    import hashlib as _hl
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    from datetime import datetime as _dt
+    from . import economics as EC
+    from . import edr as E
+    from . import helplib as H
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "cf"); d.mkdir()
+
+    prov = json.loads((pkg / "reference" / "eia_prices.provenance.json").read_text(encoding="utf-8"))
+    hashes = all(_hl.sha256((pkg / "reference" / s["file"]).read_bytes()).hexdigest() == s["sha256"]
+                 and _hl.sha256(_gz.decompress((pkg / "reference" / s["file"]).read_bytes())).hexdigest() == s["sha256_uncompressed"]
+                 and len(s["source"]["commit"]) == 40 for s in prov["series"].values())
+    wd, wv, _ = EC.read_series(None, "wti")
+    hd, hv, _ = EC.read_series(None, "henry_hub")
+    refused = 0
+    for bad in ("Date,Price\n2020-01-01,1\n2020-01-01,2\n", "Date,Price\n2020-01-01,1\n2020-01-02,x\n", "Date,Price\n2020-13-01,1\n2020-01-02,2\n", "Date,Price\n"):
+        try:
+            EC._parse_series(bad)
+        except ValueError:
+            refused += 1
+    bd, bv, _ = EC._parse_series("Date,Price\n2020-01-03,3\n2020-01-01,1\n2020-01-02,\n")
+    ev = E.selftest_events(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wb = ws.add_well_file(ev["path"], display="Well B", actor="tester"); wc = ws.add_well_file(ev["path"], display="Well C", actor="tester")
+    later = ("Date,Price\n" + "".join(f"{x},{y}\n" for x, y in zip(wd, wv)) + "2099-01-01,50.0\n").encode()
+    hh_short = "Date,Price\n2001-01-02,9.0\n2001-01-03,9.5\n".encode()
+    calls = {}
+
+    def fake(u):
+        calls[u] = True
+        if "oil-prices" in u:
+            return later
+        if "natural-gas" in u:
+            return hh_short
+        raise OSError("no network")
+    ref = EC.refresh_prices(ws, "tester", fetch=fake)
+    ref_status = {r["id"]: r["status"] for r in ref}
+    imp_refused = 0
+    for kw in ({"name": "", "unit": "rigs", "source": "s"}, {"name": "Rigs", "unit": "", "source": "s"}, {"name": "Rigs", "unit": "rigs", "source": ""}, {"name": "wti", "unit": "x", "source": "s"}):
+        try:
+            EC.import_series(ws, "tester", kw["name"], kw["unit"], kw["source"], b"Date,Count\n2026-06-26,300\n2026-07-03,301\n")
+        except ValueError:
+            imp_refused += 1
+    imp = EC.import_series(ws, "tester", "Permian rig count", "rigs", "test", b"Week,Rigs\n2026-06-26,300\n2026-07-03,301\n2026-07-10,299\n")
+    c1 = {
+        "shipped": hashes and prov["series"]["wti"]["eia_series"] == "RWTC" and prov["series"]["henry_hub"]["eia_series"] == "RNGWHHD"
+                   and "public domain" in prov["license"].lower() and wv[wd.index("2020-04-20")] == -36.98 and hv[hd.index("2021-02-17")] == 23.86
+                   and len(wd) == prov["series"]["wti"]["rows"] and wd == sorted(wd),
+        "parse": refused == 4 and bd == ["2020-01-01", "2020-01-03"] and bv == [1.0, 3.0],
+        "refresh": ref_status == {"wti": "REFRESHED", "henry_hub": "NOT REFRESHED"} and EC.read_series(ws, "wti")[0][-1] == "2099-01-01"
+                   and EC.read_series(ws, "henry_hub")[2]["kind"] == "shipped" and len(calls) == 2,
+        "import": imp_refused == 4 and imp["id"] == "permian_rig_count" and imp["rows"] == 3 and imp["date_column"] == "Week" and imp["value_column"] == "Rigs"
+                  and Path(wsp, "economics", "series", "permian_rig_count.csv").read_bytes().startswith(b"Week,Rigs"),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CF1 the price series: EIA's daily WTI (RWTC) and Henry Hub (RNGWHHD) spot prices shipped with their provenance and hashes, carrying the "
+       "-36.98 of 20 April 2020 and the 23.86 of 17 February 2021 as EIA published them; a series with a repeated or bad date or a bad number "
+       "refused, a blank day left out; a refreshed copy kept only when it reads and runs later than the one held; an imported series kept byte "
+       "for byte with its name, unit and source"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    ws.refresh_dashboard(actor="tester")
+    rec = json.loads(Path(ws.reports_dir, "wells", wb["id"], "drilling_record.json").read_text(encoding="utf-8"))
+    t0, t1 = _dt.fromisoformat(rec["start"]), _dt.fromisoformat(rec["end"])
+    days = (t1 - t0).total_seconds() / 86400.0
+    mid = "2026-07-02T12:00:00"
+    EC.set_rate(ws, wb["id"], "tester", 30000, "rig spread", "contract", rec["start"], mid)
+    part = EC.economics(ws)
+    pb = next(w for w in part["wells"] if w["well_id"] == wb["id"])
+    bad = 0
+    for args in ((30000, "rig", "c", "2026-07-02", "2026-07-05"), (30000, "", "c", None, None), (30000, "rig", "", None, None), (-5, "rig", "c", "2027-01-01", None),
+                 (30000, "rig", "c", "2027-01-02", "2027-01-01")):
+        try:
+            EC.set_rate(ws, wb["id"], "tester", *args)
+        except ValueError:
+            bad += 1
+    EC.set_rate(ws, wb["id"], "tester", 32000, "rig spread", "contract", mid, None)
+    EC.add_item(ws, wb["id"], "tester", 18000, "bit", "invoice", 1)
+    EC.set_afe(ws, wb["id"], "tester", 150000, "AFE 1")
+    full = EC.economics(ws)
+    fb = next(w for w in full["wells"] if w["well_id"] == wb["id"])
+    first = (_dt.fromisoformat(mid) - t0).total_seconds() / 86400.0
+    by_hand = round(30000 * first + 32000 * (days - first) + 18000, 2)
+    win = [v for x, v in zip(wd, wv) if rec["start"][:10] <= x <= rec["end"][:10]]
+    c2 = {
+        "partial": pb["cost"]["complete"] is False and pb["cost"]["per_ft"] is None and "cover" in pb["cost"]["why_incomplete"]
+                   and abs(pb["cost"]["usd"] - round(30000 * first, 2)) < 0.01,
+        "refused": bad == 5,
+        "by_hand": fb["cost"]["complete"] and abs(fb["cost"]["usd"] - by_hand) < 0.01 and abs(fb["cost"]["per_ft"] - round(by_hand / rec["feet_drilled"], 2)) < 0.01
+                   and abs(fb["cost"]["vs_afe_pct"] - round(100 * (by_hand - 150000) / 150000, 1)) < 0.05 and fb["days"] == round(days, 2),
+        "sections": all(s["complete"] for s in fb["sections"]) and fb["sections"][0]["cost_usd"] > 18000,
+        "market": fb["market"]["wti"]["n"] == len(win) and abs(fb["market"]["wti"]["mean"] - round(sum(win) / len(win), 3)) < 1e-9
+                  and full["chart"]["wells"][0]["from"] == rec["start"][:10] and "permian_rig_count" in full["chart"]["series"],
+        "correlation": "spearman_cost_per_ft_vs_wti" not in full["correlation"] and full["correlation"]["n_wells"] == 1
+                       and abs(EC._spearman([1, 2, 3, 4], [10, 20, 30, 40]) - 1) < 1e-12 and abs(EC._spearman([1, 2, 3, 4], [4, 3, 2, 1]) + 1) < 1e-12,
+        "audit": all(a in [x["action"] for x in ws.audit_log(500)] for a in ("economics.rate", "economics.item", "economics.afe", "economics.prices.refresh", "economics.series.import")),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CF2 a well's cost: two day rates and a bit over the drilling record's own time come to the dollar the hand sum gives, with cost per foot "
+       "and the difference from the AFE; while the rates leave time uncovered the cost is shown, marked incomplete and not divided by the footage; "
+       "overlapping periods, a rate with no source or no purpose, a negative rate and a period that ends before it starts refused; the WTI mean "
+       "while drilling equal to the days EIA published in that window; no correlation across fewer than ten wells; every declaration audited"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    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")
+        st_g, eg = call(V, "GET", "/api/economics")
+        st_vr, _ = call(V, "POST", "/api/economics/rate", {"well_id": wc["id"], "usd_per_day": 1000, "what": "rig", "source": "s"})
+        st_or, _ = call(O, "POST", "/api/economics/rate", {"well_id": wc["id"], "usd_per_day": 25000, "what": "rig spread", "source": "contract"})
+        st_bad, _ = call(O, "POST", "/api/economics/rate", {"well_id": wc["id"], "usd_per_day": "x", "what": "rig", "source": "s"})
+        st_imp, imp2 = call(O, "POST", "/api/economics/import", {"name": "Midland WTI", "unit": "USD/bbl", "source": "test", "content_b64": _b64.b64encode(b"Date,Price\n2026-07-01,70\n2026-07-02,71\n").decode()})
+        st_rm, _ = call(O, "POST", "/api/economics/remove", {"well_id": wc["id"], "kind": "rate", "index": 0})
+        st_rm2, _ = call(O, "POST", "/api/economics/remove", {"well_id": wc["id"], "kind": "rate", "index": 0})
+        st_ac, _ = call(O, "POST", "/api/economics/nope", {})
+    finally:
+        svc.stop()
+    cli = _sp.run([sys.executable, "-m", "gea", "economics", "--workspace", wsp], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "economics.md").read_text(encoding="utf-8")
+    c3 = {
+        "api": st_g == 200 and len(eg["wells"]) == 2 and st_vr == 403 and st_or == 200 and st_bad == 400 and st_imp == 200 and imp2["id"] == "midland_wti"
+               and st_rm == 200 and st_rm2 == 404 and st_ac == 404,
+        "cli": cli.returncode == 0 and "USD/ft" in cli.stdout and "incomplete" not in cli.stdout.split("Well B")[1].split("Well C")[0] and "U.S. Energy Information Administration" in cli.stdout,
+        "page": all(x in page_src for x in ("VIEWS.economics", "['#/economics', 'Economics']", "ecChart", "ec-hit", "ArrowLeft", "/api/economics/rate",
+                                             "/api/economics/import", "/api/economics/refresh", "incomplete", "a gap of more than six days is not bridged")),
+        "help": any(t["topic"] == "economics" for t in H.topics()) and not H.check("economics") and H.VIEW_TOPIC.get("economics") == "economics"
+                and "fewer than ten wells" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CF3 the API (a viewer reads, only an operator declares; a bad number, an unknown action and a second removal of the same rate named), "
+       "the CLI and the Economics tab: one chart per series on its own axis with the wells' drilling windows shaded and a crosshair by pointer or "
+       "arrows, the wells' cost table, the cost-basis forms, refresh and import; the help page"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
+def section_cg_well_report(tmp: str) -> None:
+    """Section CG - the client well report: one document per well and one for the pad, assembled from the drilling record,
+    the depth events and their check, the declared location and the mapped structure there, the survey's path, and the
+    declared cost against the market; drawings made from the report's own numbers; each missing part named with what
+    would supply it, never drawn as zero; the vocabulary guard; the month-end packet, the API, the CLI, the pages."""
+    import http.cookiejar
+    import math as _m
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import xml.etree.ElementTree as _ET
+    from . import client_reports as CR
+    from . import economics as EC
+    from . import edr as E
+    from . import helplib as H
+    from . import month_end as ME
+    from . import setup_checklist as SC
+    from . import shapefile as SF
+    from . import well3d as W
+    from . import well_report as WR
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "cg"); d.mkdir()
+    ev = E.selftest_events(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wb = ws.add_well_file(ev["path"], display="Well B", actor="tester"); wc = ws.add_well_file(ev["path"], display="Well C", actor="tester")
+    ws.set_well(wb["id"], surface={"lat": 31.42, "lon": -104.10, "datum": "NAD83", "elevation": {"ft": 3000.0, "datum": "KB", "source": "test plat"}},
+                identity={"api_number": "42-389-12345"}, actor="tester")
+    lat1, lon1 = 31.42, -104.10
+    kmlon = 1.0 / (111.195 * _m.cos(_m.radians(lat1)))
+    SF.write(str(d / "Top_A"), "PolyLine", [([[(lon1 + (i - 1.5) * kmlon + 0.0005 * k, lat1 - 0.05 + 0.001 * k) for k in range(100)]], {"ElevTop_ft": -1500.0 - 100.0 * i}) for i in range(4)],
+             [("ElevTop_ft", "F", 10, 1)], SF.NAD83_GEOGCS)
+    ws.add_layer(str(d / "Top_A.shp"), "Top A", actor="tester", formation="A", role="top", citation="test")
+    csv_ok = "MD (ft),Inc (deg),Azi (deg)\n0,0,0\n1000,0,0\n2000,10,90\n3000,30,90\n4000,45,95\n5750,60,100\n"
+    W.attach_trajectory(ws, wb["id"], "s.csv", csv_ok.encode(), "tester", "true", "ft", None, None, None, "test survey")
+    ws.add_site("Pad 3", wells=[wb["id"], wc["id"]], client="Test Client", actor="tester")
+    ws.refresh_dashboard(actor="tester")
+    rec = json.loads(Path(ws.reports_dir, "wells", wb["id"], "drilling_record.json").read_text(encoding="utf-8"))
+    EC.set_rate(ws, wb["id"], "tester", 30000, "rig spread", "contract")
+    EC.add_item(ws, wb["id"], "tester", 18000, "bit", "invoice", 1)
+    EC.set_afe(ws, wb["id"], "tester", 150000, "AFE 1")
+    SC.confirm(ws, f"events:{wb['id']}", "tester", "daily drilling reports 1-5")
+    r = WR.write_well(ws, wb["id"], "0.0-test", actor="tester")
+    wdir = Path(ws.reports_dir, "wells", wb["id"])
+    md = (wdir / "well_report.md").read_text(encoding="utf-8"); ht = (wdir / "well_report.html").read_text(encoding="utf-8")
+    js = json.loads((wdir / "well_report.json").read_text(encoding="utf-8"))
+    figs = sorted(Path(p).name for p in r["paths"].get("figures", []))
+    parsed = 0
+    for f in figs:
+        try:
+            _ET.fromstring((wdir / f).read_text(encoding="utf-8")); parsed += 1
+        except _ET.ParseError:
+            pass
+    st = W.trajectory_of(ws, wb["id"])["stations"]
+    p = W.Path([x["md"] for x in st], [x["incl"] for x in st], [x["azi"] for x in st], 0.0, 0.0, 0.0, 0.0)
+    tvd_ft = float(p.tvd[-1]) / 0.3048
+    fb = next(w for w in EC.economics(ws)["wells"] if w["well_id"] == wb["id"])
+    c1 = {
+        "complete": r["missing"] == [] and js["missing"] == [] and js["report_id"] == r["report_id"] and "42-389-12345" in md and "Test Client" in md
+                    and "KB 3,000.0 ft (test plat)" in md,
+        "record": f"{rec['total_depth_md_ft']:,.1f} ft" in md and f"{rec['feet_drilled']:,.1f} ft" in md and rec["source"] in md
+                  and md.count("\n| STALE OPENING |") + md.count("\n| RE-REFERENCE |") + md.count("\n| SIDETRACK |") + md.count("\n| CORRECTION |") == len(rec["depth_events"])
+                  and "Checked by tester" in md and "daily drilling reports 1-5" in md,
+        "figures": figs == sorted(["well_report_progress.svg", "well_report_plan.svg", "well_report_section.svg", "well_report_wti.svg", "well_report_henry_hub.svg"])
+                   and parsed == 5 and ht.count("<figure") == 5 and ht.count("<figcaption") == 5 and md.count("![") == 5 and "@media print" in ht and "break-inside:avoid" in ht,
+        "path": f"{tvd_ft:,.1f}" in md and f"reaches {tvd_ft:,.0f} ft true vertical depth" in md and "6 stations, azimuths true" in md,
+        "tops": "| A | 4,500 to 4,600 | -1,600 and -1,500 | Top A |" in md and "Between the -1,600 ft and -1,500 ft contours" in md,
+        "cost": f"${fb['cost']['usd']:,.0f}" in md and f"${fb['cost']['per_ft']:,.2f}" in md and "over the whole record" in md and "$18,000.00 bit (section 1)" in md
+                and f"{fb['market']['wti']['mean']:,.2f}" in md,
+        "guarded": not CR.forbidden_terms(md) and not CR.forbidden_terms(ht),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CG1 a well's report: the identity, client and declared reference with their sources; the drilling record's own total depth, footage "
+       "and every depth event with the person's check; depth against days, the plan and the vertical section from the survey (TVD to the "
+       "minimum-curvature value), the mapped top at the location as a depth band from the two contours it lies between below the declared "
+       "reference, the declared cost to the dollar of the Economics tab and the market while drilling - five drawings, each valid SVG with a "
+       "caption and words for a reader who cannot see it, none split across a printed page"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    rc = WR.write_well(ws, wc["id"], "0.0-test", actor="tester")
+    cdir = Path(ws.reports_dir, "wells", wc["id"])
+    mdc = (cdir / "well_report.md").read_text(encoding="utf-8")
+    EC.add_item(ws, wb["id"], "tester", 1, "lattice rental", "test")                          # a declared word the client register does not carry
+    guarded = False
+    try:
+        WR.write_well(ws, wb["id"], "0.0-test", actor="tester")
+    except ValueError as e:
+        guarded = "lattice" in str(e)
+    EC.remove(ws, wb["id"], "tester", "item", 1)
+    rp = WR.write_pad(ws, "0.0-test", actor="tester")
+    pmd = Path(ws.reports_dir, "pad_report.md").read_text(encoding="utf-8")
+    psvg = Path(ws.reports_dir, "pad_report_progress.svg").read_text(encoding="utf-8")
+    pk = ME.assemble(ws, "2026-09", actor="tester", refresh=False)
+    idx = json.loads((Path(pk["folder"]) / "INDEX.json").read_text(encoding="utf-8"))
+    by_name = {i["name"]: i for i in idx["items"]}
+    c2 = {
+        "missing_named": rc["missing"] == ["a person's check of the depth events", "the surface location", "the directional survey", "the cost basis (day rates)"]
+                         and "not declared" in mdc and "No directional survey is attached" in mdc and "the well is not placed" in mdc
+                         and "Cost (declared)" not in mdc and "Not yet checked by a person" in mdc and "what would supply it" in mdc
+                         and sorted(Path(x).name for x in rc["paths"]["figures"]) == ["well_report_henry_hub.svg", "well_report_progress.svg", "well_report_wti.svg"],
+        "guard": guarded and not Path(ws.reports_dir, "wells", wb["id"], "well_report.html").read_text(encoding="utf-8").lower().count("lattice"),
+        "pad": "| Well B | 2026-07-01 |" in pmd and "| Well C | 2026-07-01 |" in pmd and psvg.count("<path ") == 2 and "| Well B | nothing |" in pmd
+               and "| Well C | a person's check of the depth events; the surface location; the directional survey; the cost basis (day rates) |" in pmd,
+        "month_end": by_name[f"Well B: client well report"]["status"] == "INCLUDED" and "well_report_section.svg" in [f["file"] for f in by_name["Well B: client well report"]["files"]]
+                     and by_name["Pad report"]["status"] == "INCLUDED" and pk["errors"] == [],
+        "audit": [a["action"] for a in ws.audit_log(500)].count("report.well") >= 3 and "report.pad" in [a["action"] for a in ws.audit_log(500)],
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CG2 what a report cannot say: a well with no check of its depth events, no surface location, no survey and no cost basis gets its "
+       "record, its progress and the market, and each missing part named with what would supply it - no path, no cost, nothing drawn as "
+       "zero; a declared word the client register does not carry stops the report before it is written; the pad report puts every well side "
+       "by side on one chart with what each still lacks; the month-end packet writes and includes them with their drawings; every run audited"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    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_:
+                ct = rr_.headers.get("Content-Type", "")
+                raw = rr_.read()
+                return rr_.status, (json.loads(raw) if "json" in ct else raw.decode("utf-8", "replace"))
+        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")
+        st_v, _ = call(V, "POST", "/api/reports/well-report", {"well_id": wb["id"]})
+        st_o, jo = call(O, "POST", "/api/reports/well-report", {"well_id": wb["id"]})
+        st_p, jp = call(O, "POST", "/api/reports/well-report", {"pad": True})
+        st_n, _ = call(O, "POST", "/api/reports/well-report", {"well_id": "nope"})
+        st_h, page = call(V, "GET", jo.get("url", "/x") if isinstance(jo, dict) else "/x")
+        st_r, ri = call(V, "GET", "/api/reports")
+    finally:
+        svc.stop()
+    cli = _sp.run([sys.executable, "-m", "gea", "well-report", "--workspace", wsp], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_bad = _sp.run([sys.executable, "-m", "gea", "well-report", "--workspace", wsp, "--well", "nope"], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c3 = {
+        "api": st_v == 403 and st_o == 200 and jo["missing"] == [] and jo["url"] == f"/reports/wells/{wb['id']}/well_report.html" and st_p == 200
+               and jp["url"] == "/reports/pad_report.html" and st_n == 404 and st_h == 200 and "<figure" in page and st_r == 200 and "pad_report.html" in ri["site"]
+               and "well_report_plan.svg" in ri["wells"][wb["id"]],
+        "cli": cli.returncode == 0 and f"{wb['id']}: " in cli.stdout and "pad: " in cli.stdout and "not in it yet" in cli.stdout.split(f"{wc['id']}: ")[1]
+               and cli_bad.returncode != 0 and "no well nope" in cli_bad.stderr,
+        "page": all(x in page_src for x in ("/api/reports/well-report", "wrRun", "data-wr", "Client well report", "Write the pad report", "Not in it yet")),
+        "help": any(t[0] == "well-report" for t in H.INDEX) and not H.check("well-report"),
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CG3 the API (a viewer reads the report, only an operator writes it; an unknown well named), the CLI (every well and the pad, or one, "
+       "or the pad alone), the buttons on the well page and the Reports page, 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:
@@ -8886,6 +9223,8 @@ def main() -> int:
         section_cc_site_map(tmp)
         section_cd_control_room(tmp)
         section_ce_well3d(tmp)
+        section_cf_economics(tmp)
+        section_cg_well_report(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.36.0 → gea_program-0.38.0}/gea/client_reports.py

@@ -90,12 +90,23 @@ class Table:
     caption: str = ''
 
 
+@dataclass
+class Figure:
+    """A drawing the report carries: SVG made by the program from the numbers in the report's own tables, with a caption
+    and the words a reader who cannot see it gets instead."""
+    name: str                       # the file stem it is written under, beside the report
+    svg: str
+    caption: str
+    alt: str
+
+
 @dataclass
 class Section:
     number: str
     title: str
     paragraphs: List[str] = field(default_factory=list)
     tables: List[Table] = field(default_factory=list)
+    figures: List[Figure] = field(default_factory=list)
 
 
 @dataclass
@@ -910,6 +921,11 @@ def render_markdown(doc: Document) -> str:
         for p in s.paragraphs:
             L.append(p)
             L.append('')
+        for fg in s.figures:
+            L.append(f'![{fg.alt}]({fg.name}.svg)')
+            L.append('')
+            L.append(f'*{fg.caption}*')
+            L.append('')
         for t in s.tables:
             if t.caption:
                 L.append(f'*{t.caption}*')
@@ -932,7 +948,9 @@ _CSS = ('body{font-family:Segoe UI,Arial,sans-serif;margin:2rem auto;max-width:1
         'font-size:.85rem;width:100%}th,td{border:1px solid #d0d0d0;padding:.3rem .5rem;text-align:left;'
         'vertical-align:top}th{background:#f2f2f2}caption{text-align:left;font-style:italic;padding:.2rem 0}'
         '.front td:first-child{font-weight:600;width:14rem}.result-bad{color:#a40000;font-weight:700}'
-        '.result-ok{color:#0a6b1f;font-weight:700}footer{margin-top:2rem;font-size:.8rem;color:#555}')
+        '.result-ok{color:#0a6b1f;font-weight:700}footer{margin-top:2rem;font-size:.8rem;color:#555}'
+        'figure{margin:1rem 0}figure svg{max-width:100%;height:auto;display:block}figcaption{font-size:.8rem;font-style:italic;color:#444}'
+        '@media print{body{margin:0;max-width:none}h2{break-after:avoid}table,figure{break-inside:avoid}}')
 
 
 def render_html(doc: Document) -> str:
@@ -950,6 +968,8 @@ def render_html(doc: Document) -> str:
         H.append(f'<h2>{e(s.number)}. {e(s.title)}</h2>')
         for p in s.paragraphs:
             H.append(f'<p>{e(p)}</p>')
+        for fg in s.figures:
+            H.append(f'<figure role="img" aria-label="{e(fg.alt)}">{fg.svg}<figcaption>{e(fg.caption)}</figcaption></figure>')
         for t in s.tables:
             H.append('<table>')
             if t.caption:
@@ -1888,6 +1908,12 @@ def write(doc: Document, out_dir: str, basename: str = 'gauge_drift_report') ->
         f.write(md)
     with open(paths['html'], 'w', encoding='utf-8', newline='') as f:
         f.write(ht)
+    for s in doc.sections:
+        for fg in s.figures:
+            fp = os.path.join(out_dir, fg.name + '.svg')
+            with open(fp, 'w', encoding='utf-8', newline='') as f:
+                f.write(fg.svg)
+            paths.setdefault('figures', []).append(fp)
     machine = {k: v for k, v in doc.data.items() if not k.startswith('_')}
     with open(paths['json'], 'w', encoding='utf-8') as f:
         json.dump(machine, f, indent=1, default=str)