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

{gea_program-0.37.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.37.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,17 @@ 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

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

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

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

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

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

@@ -475,6 +475,12 @@ 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")
@@ -2009,6 +2015,26 @@ def main(argv=None) -> int:
         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.37.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)}
@@ -8970,6 +8970,173 @@ def section_cf_economics(tmp: str) -> None:
        + (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:
@@ -9057,6 +9224,7 @@ def main() -> int:
         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.37.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)

gea_program-0.38.0/gea/help/well-report.md

@@ -0,0 +1,11 @@
+# The client well report
+
+> One printable document per well, and one for the pad, assembled from what the workspace already holds: 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 directional survey in plan and section with the mapped tops, and the declared cost against the market while it was drilled. Each number says where it came from, and the report lists what it cannot say yet and what would supply it.
+
+**The command**: on a well's page, **Write the well report** (the operator role); on the Reports page, **Write the pad report** or one button per well. From a terminal: `gea well-report --workspace C:\site` writes every well's report and the pad report; `--well Well-30636033` writes one; `--pad` the pad alone. The month-end packet writes and includes them for every well with a drilling record.
+
+**What it writes**: `reports/wells/<well>/well_report.html`, `.md` and `.json`, with its drawings beside it as SVG (`well_report_progress.svg`, `well_report_plan.svg`, `well_report_section.svg`, one per price series) and inline in the HTML, which prints with no drawing split across two pages; `reports/pad_report.*` with `pad_report_progress.svg`. Each run is a line in the audit log with the report's ID and what it still lacks. The rendered text passes the same vocabulary check as every client report before it is written.
+
+**The number to check**: the summary against the drilling record it came from (total depth, feet drilled, days, hours on bottom - the same numbers, read as delivered); the well-path table against the survey stations (minimum curvature, the dogleg in degrees per 30 m); a mapped top's depth below the reference against the two contours the location lies between, subtracted from the declared reference elevation; the cost against the Economics tab, which is where it is declared.
+
+**What this page will not call a measurement**: a declared number - the surface location, the reference elevation, the US Well Number, a day rate, an item, the AFE - is printed as declared, with its source, and never as measured; a mapped top at the well - a contour map is read as the two contours the surface location lies between, and a well that deviates meets each top somewhere else; a well path drawn without a survey - with no survey attached, the section says so; a missing part as zero - a well with no surface location, no survey or no declared cost has the part left out and named under "What this report will not say", with what would supply it; a price as the cause of a cost.

{gea_program-0.37.0 → gea_program-0.38.0}/gea/helplib.py

@@ -44,6 +44,7 @@ INDEX: List[tuple] = [
     ('dlis', 'The DLIS log', 'a well log as it is delivered (API RP66 V1), read as the standard lays it out: the frames, the channels, what was skipped; into the strata survey'),
     ('historian', 'The historian pull', 'an operator\'s gauge history out of the PI System through PI Web API, read-only, every value with its archive time and flags'),
     ('map', 'The site map', 'everything with a position in one frame: the placed wells, the structure layers, the stress directions, the stations and response areas over the state and county outline; what every layer says about any spot'),
+    ('well-report', 'The client well report', 'one printable document per well and one for the pad: the drilling record, depth events, progress chart, location and structure, well path and cost, each number with its source'),
     ('economics', 'Economics', 'each well\'s days, footage and cost by the operator\'s own declared rates, against the EIA oil and gas spot prices while it was drilled, and any series the site imports'),
     ('well3d', 'The well in 3D', 'each well\'s path from its directional survey, set among the mapped formation surfaces and contours with its picks, coloured by what was measured along it, and the drill string replayed from the record; the Volve field shipped as the worked example'),
     ('charts', 'The charts', 'a well\'s channels stacked on one axis with a linked cursor, zoom and pan from every sample, time or depth for a drilling recorder, the depth events marked, and the drilling progress of every well'),

{gea_program-0.37.0 → gea_program-0.38.0}/gea/month_end.py

@@ -122,6 +122,13 @@ def assemble(ws, period: str, actor: str = 'system', refresh: bool = True, catal
          'the SLA month is written by the refresh with --month; none for this period')
     item('site', '-', 'FAT/SAT protocol', _copy_family(rep, ['fat_protocol', 'sat_protocol'], os.path.join(out, 'site')), 'no protocol written (gea fat-sat, or the refresh with --sat)')
     item('site', '-', 'Model cards and SBOM', _copy_family(rep, ['model_cards_index', 'sbom'], os.path.join(out, 'site')), 'never refreshed')
+    if any(os.path.isfile(os.path.join(rep, 'wells', w['id'], 'drilling_record.json')) for w in ws.wells()):
+        try:
+            from .well_report import write_pad
+            write_pad(ws, __version__, actor=actor)
+        except Exception as e:
+            errors.append(f'pad report: {e}')
+        item('site', '-', 'Pad report', _copy_family(rep, ['pad_report'], os.path.join(out, 'site')), 'the pad report failed to write (see errors)')
     # -- every well -------------------------------------------------------------------------------------------------
     for w in ws.wells():
         wd = os.path.join(rep, 'wells', w['id'])
@@ -133,6 +140,13 @@ def assemble(ws, period: str, actor: str = 'system', refresh: bool = True, catal
         item('well', w['id'], f"{w['display']}: data resilience", _copy_family(wd, ['data_resilience_report'], dst), 'no store-and-forward outage was given to the refresh')
         item('well', w['id'], f"{w['display']}: machine vibration", _copy_family(wd, ['vibration_report'], dst),
              'no machine record for this well (gea workspace --action vibration-report)')
+        if os.path.isfile(os.path.join(wd, 'drilling_record.json')):
+            try:
+                from .well_report import write_well
+                write_well(ws, w['id'], __version__, actor=actor)
+            except Exception as e:
+                errors.append(f"well report {w['id']}: {e}")
+            item('well', w['id'], f"{w['display']}: client well report", _copy_family(wd, ['well_report'], dst), 'the well report failed to write (see errors)')
         # certificate conformity: the register's standing, written here from the register as it stands
         reg = os.path.join(ws.path, 'wells', w['id'], 'records', 'certificates.jsonl')
         if os.path.isfile(reg):

{gea_program-0.37.0 → gea_program-0.38.0}/gea/service.py

@@ -2189,6 +2189,18 @@ def make_handler(app: App):
                             raise ApiError(400, str(e))
                     finally:
                         shutil.rmtree(tmp_dir, ignore_errors=True)
+                if path == '/api/reports/well-report':
+                    from . import well_report as WR
+                    from . import __version__ as _v
+                    App.require(user, 'operator')
+                    if body.get('pad'):
+                        r = WR.write_pad(app.ws, _v, actor=user['name'])
+                        return self._json(200, {'report_id': r['report_id'], 'url': '/reports/pad_report.html'})
+                    wid = str(body.get('well_id', ''))
+                    if not any(w['id'] == wid for w in app.ws.wells()):
+                        raise ApiError(404, f'no well {wid}')
+                    r = WR.write_well(app.ws, wid, _v, actor=user['name'])
+                    return self._json(200, {'report_id': r['report_id'], 'missing': r['missing'], 'url': f'/reports/wells/{wid}/well_report.html'})
                 if path.startswith('/api/economics/'):
                     from . import economics as EC
                     import base64 as _b64

{gea_program-0.37.0 → gea_program-0.38.0}/gea/web/app.html

@@ -308,6 +308,9 @@ VIEWS.well = async (id) => {
     else if (ga.status) h += `<p class="small">Gamma log: ${esc(ga.status)} — ${esc(ga.how || '')}.</p>`;
     if ((dr.observations || []).length) h += `<p class="small"><b>Observations</b>: ${dr.observations.map(o => esc(o.channel + ' ' + o.what + ' in ' + o.samples.toLocaleString() + ' samples — ' + o.note)).join('; ')}.</p>`;
     h += `<p class="small muted">${esc(dr.lines[dr.lines.length - 1])}</p></div>`; }
+  // the client well report
+  if (R.drilling_record || R.well_report) { const wr = R.well_report;
+    h += `<div class="card"><h3>Client well report <span class="small muted">${wr ? esc(wr.report_id) + ' · ' + reportLinks(dir, 'well_report') : 'not written yet'}</span></h3><p class="small muted">One printable document for the client: the drilling record, the depth events and who checked them, the progress chart, the location and the mapped structure, the well path from its survey, and the declared cost against the market — each number with where it came from, and what the report cannot say yet.</p>${wr && (wr.missing || []).length ? `<p class="small">Not in it yet: ${wr.missing.map(esc).join('; ')}.</p>` : ''}${can('operator') ? `<button id="wrRun" class="secondary" type="button">${wr ? 'Write it again' : 'Write the well report'}</button>` : ''}</div>`; }
   // drift
   if (R.gauge_drift_report) { const ev = R.gauge_drift_report.evaluation, dq = R.gauge_drift_report.data_quality || {};
     h += `<div class="card"><h3>Gauge drift and reconciliation <span class="small muted">${esc(R.gauge_drift_report.report_id)} · ${reportLinks(dir, 'gauge_drift_report')}</span></h3>`;
@@ -361,6 +364,7 @@ VIEWS.well = async (id) => {
   $('#main').innerHTML = h;
   const run = async (args, label) => { try { const j = await post('/api/jobs', {args, label}); toast(label + ': job ' + j.id, 'ok'); watch(j.id, () => route()); } catch (e) { toast(e.message, 'err'); } };
   const wsPath = (await get('/api/overview')).workspace.path;
+  const wrb = $('#wrRun'); if (wrb) wrb.onclick = async () => { wrb.disabled = true; try { const j = await post('/api/reports/well-report', {well_id: id}); toast('Well report written: ' + j.report_id, 'ok'); route(); } catch (e) { toast(e.message, 'err'); wrb.disabled = false; } };
   const b1 = $('#runDrift'); if (b1) b1.onclick = () => run(['workspace', '--path', wsPath, '--action', 'refresh', '--actor', me.name], 'drift report (all wells)');
   intervalCardBind(id); slipCardBind(id);
   const b2 = $('#runAlarms'); if (b2) b2.onclick = () => run(['workspace', '--path', wsPath, '--action', 'refresh', '--actor', me.name], 'alarms (all wells)');
@@ -1577,11 +1581,15 @@ VIEWS.reports = async () => {
   h += `<div class="card"><h3>Month-end packet <span class="small muted">the month's deliverable, assembled once</span></h3><p class="small muted">The refresh for the month, then every report - each well's drift, alarm month, well tests, shut-ins, vibration and certificate conformity; each site's SRA packet and site report; every station and track; the accuracy statement and the SLA month - collected into one dated folder and one archive with an index (INCLUDED with the files, or NOT AVAILABLE with the reason) and a manifest of every file's hash. Nothing is recomputed in the index.</p>
     ${ME.packets.length ? `<table><thead><tr><th>Period</th><th>Closed</th><th>Generated</th><th>Included</th><th>Not available</th><th>Failed</th><th>Files</th><th>Index</th><th>Archive</th></tr></thead><tbody>${ME.packets.slice().reverse().map(p => `<tr><td>${esc(p.period)}</td><td>${p.closed ? 'yes' : statusPill('warn', 'OPEN')}</td><td class="small">${tz(p.generated_utc)}</td><td>${p.included}</td><td>${p.not_available}</td><td>${p.errors.length}</td><td>${p.n_files}</td><td><a href="/reports/month_end/${esc(p.period)}/INDEX.html" target="_blank" rel="noopener">INDEX.html</a></td><td class="mono small">${p.present ? `<a href="/reports/month_end/${esc(p.archive.split(/[\\/]/).pop())}" target="_blank" rel="noopener">${esc(p.archive.split(/[\\/]/).pop())}</a>` : 'archive missing'}</td></tr>`).join('')}</tbody></table>` : `<p class="muted small">No packet yet.</p>`}
     ${can('operator') ? `<div class="row"><label>Period (YYYY-MM)<input id="mePeriod" value="${esc(ME.previous)}" style="width:8em"></label><button id="meRun" type="button">Assemble the packet</button>${can('admin') ? `<label>Monthly on day<input id="meDay" type="number" min="1" max="28" value="${esc(ME.schedule ? ME.schedule.monthly_day : 1)}" style="width:4em"></label><label>at (UTC)<input id="meAt" value="${esc(ME.schedule ? ME.schedule.daily_at : '03:00')}" style="width:6em"></label><button class="secondary" id="meSched" type="button">Schedule monthly</button><span class="small muted">${ME.schedule ? `scheduled: day ${esc(ME.schedule.monthly_day)} at ${esc(ME.schedule.daily_at)} UTC, the previous month` : 'not scheduled'}</span>` : ''}</div>` : need('operator')}</div>`;
+  h += `<div class="card"><h3>Client well reports <span class="small muted">one printable document per well, and one for the pad</span></h3><p class="small muted">Assembled from what the workspace holds — drilling record, depth events, location and structure, well path, declared cost and the market — with drawings made from the report's own tables. Each says what it cannot say yet and what would supply it.</p>
+    <p class="small">${r.site.includes('pad_report.html') ? `Pad report · ${['html', 'md', 'json'].map(x => `<a href="/reports/pad_report.${x}" target="_blank" rel="noopener">${x}</a>`).join(' · ')}` : '<span class="muted">No pad report yet.</span>'}</p>
+    ${can('operator') ? `<div class="row"><button data-wr="__pad__" type="button">Write the pad report</button>${Object.keys(r.wells).map(w => `<button class="secondary" data-wr="${esc(w)}" type="button">${esc(w)}</button>`).join('')}</div>` : ''}</div>`;
   h += `<div class="card"><h3>Site</h3><p class="mono small">${r.site.map(f => `<a href="/reports/${esc(f)}" target="_blank" rel="noopener">${esc(f)}</a>`).join(' · ') || 'none yet'}</p></div>`;
   for (const [w, files] of Object.entries(r.wells)) h += `<div class="card"><h3><a href="#/wells/${esc(w)}">${esc(w)}</a></h3><p class="mono small">${files.map(f => `<a href="/reports/wells/${esc(w)}/${esc(f)}" target="_blank" rel="noopener">${esc(f)}</a>`).join(' · ')}</p></div>`;
   $('#main').innerHTML = h;
   const meRun = $('#meRun'); if (meRun) meRun.onclick = async () => { meRun.disabled = true; try { const j = await post('/api/month-end/run', {period: $('#mePeriod').value.trim()}); toast('Month-end packet started: job ' + j.id, 'ok'); watch(j.id, () => route()); } catch (e) { toast(e.message, 'err'); meRun.disabled = false; } };
   const meSched = $('#meSched'); if (meSched) meSched.onclick = async () => { try { const e = await post('/api/month-end/schedule', {day: +$('#meDay').value, at: $('#meAt').value}); toast(`Scheduled monthly: day ${e.monthly_day} at ${e.daily_at} UTC`, 'ok'); route(); } catch (e) { toast(e.message, 'err'); } };
+  document.querySelectorAll('[data-wr]').forEach(b => b.onclick = async () => { b.disabled = true; try { const k = b.dataset.wr; const j = await post('/api/reports/well-report', k === '__pad__' ? {pad: true} : {well_id: k}); toast('Written: ' + j.report_id, 'ok'); route(); } catch (e) { toast(e.message, 'err'); b.disabled = false; } });
   document.querySelectorAll('[data-run]').forEach(b => b.onclick = async () => { const k = b.dataset.run; try { let j; if (k === 'refresh') j = await post('/api/refresh', {}); else if (k === 'sla') { const m = $('#slaMonth').value; if (!m) return toast('give the month', 'err'); j = await post('/api/refresh', {month: m}); } else if (k === 'model-cards') j = await post('/api/jobs', {args: ['model-cards', '--out', o.workspace.path + '/reports'], label: 'model cards'}); else j = await post('/api/verify', {what: k}); toast('Started: job ' + j.id, 'ok'); watch(j.id, () => route()); } catch (e) { toast(e.message, 'err'); } });
 };