gea-program 0.29.0__tar.gz → 0.30.0__tar.gz

{gea_program-0.29.0/gea_program.egg-info → gea_program-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.29.0
+Version: 0.30.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
@@ -125,7 +125,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (373 checks)
+gea accept                     # the product gate (376 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -717,6 +717,25 @@ equal to a fresh read of the files. `gea catalog --positions`, `gea catalog
 `--check-positions`. A mark is the coordinate the record states, not a
 position this program measured.
 
+### The drilling recorder
+
+A rig's electronic drilling recorder exports one row per second: the date
+and the time in two columns, then the WITS record-1 channels with their
+units in the header; `-999.25` or an empty cell where it had nothing; the
+file stopping while the rig is off the well. The `edr` port reads that
+layout as delivered - streamed, three million rows in under a minute - and
+writes the **drilling record**: per section the hours, the gap before, the
+hole depth where drilling began and the deepest it got, feet drilled, hours
+on bottom and rotating, the rate of penetration on bottom, the connections,
+the peaks; for the well, total depth and when the bit was first on bottom
+there, the recorder's TVD at it; per channel what was missing and how
+often; and the **MD-TVD table**, hole depth against the recorder's
+interpolated TVD, labelled an interpolation and not a survey. A recorder
+that resets its hole depth at a restart is named, not corrected. `gea edr
+--file C:\site\_incoming\30636033.csv`; `gea workspace --action add-file`
+then `refresh` for the record beside the well's other reports. `gea help
+edr`.
+
 ### The log as delivered, and the historian
 
 A well log arrives as DLIS (API RP66 V1); `gea/dlis.py` reads the container

{gea_program-0.29.0 → gea_program-0.30.0}/README.md

@@ -86,7 +86,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (373 checks)
+gea accept                     # the product gate (376 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -678,6 +678,25 @@ equal to a fresh read of the files. `gea catalog --positions`, `gea catalog
 `--check-positions`. A mark is the coordinate the record states, not a
 position this program measured.
 
+### The drilling recorder
+
+A rig's electronic drilling recorder exports one row per second: the date
+and the time in two columns, then the WITS record-1 channels with their
+units in the header; `-999.25` or an empty cell where it had nothing; the
+file stopping while the rig is off the well. The `edr` port reads that
+layout as delivered - streamed, three million rows in under a minute - and
+writes the **drilling record**: per section the hours, the gap before, the
+hole depth where drilling began and the deepest it got, feet drilled, hours
+on bottom and rotating, the rate of penetration on bottom, the connections,
+the peaks; for the well, total depth and when the bit was first on bottom
+there, the recorder's TVD at it; per channel what was missing and how
+often; and the **MD-TVD table**, hole depth against the recorder's
+interpolated TVD, labelled an interpolation and not a survey. A recorder
+that resets its hole depth at a restart is named, not corrected. `gea edr
+--file C:\site\_incoming\30636033.csv`; `gea workspace --action add-file`
+then `refresh` for the record beside the well's other reports. `gea help
+edr`.
+
 ### The log as delivered, and the historian
 
 A well log arrives as DLIS (API RP66 V1); `gea/dlis.py` reads the container

{gea_program-0.29.0 → gea_program-0.30.0}/gea/__init__.py

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

{gea_program-0.29.0 → gea_program-0.30.0}/gea/__main__.py

@@ -306,6 +306,8 @@ def main(argv=None) -> int:
     p_cat.add_argument("--positions", action="store_true", help="where every entry was drilled, from its own file or sidecar, or NO POSITION")
     p_cat.add_argument("--map", type=str, default=None, metavar="OUT.SVG", help="write the world map of the catalogue (coastline + one mark per positioned entry + the key) as an SVG file")
     p_cat.add_argument("--check-positions", action="store_true", help="the sidecars' recorded positions against a fresh read of the files (the gate's check)")
+    p_ed = sub.add_parser("edr", help="an electronic drilling recorder's one-second export (date and time columns, WITS record-1 channels): --file reads it and prints the drilling record; --out DIR writes the record (json, md, html) and the MD-TVD table; --selftest proves the port on a synthetic export")
+    p_ed.add_argument("--file", type=str, default=None); p_ed.add_argument("--out", type=str, default=None); p_ed.add_argument("--json", action="store_true"); p_ed.add_argument("--selftest", action="store_true")
     p_dl = sub.add_parser("dlis", help="a DLIS (RP66 V1) well log: --info describes it (origin, channels, frames, what was skipped); --frame --out writes the frame as a historian-style CSV; --to-las writes LAS 2.0")
     p_dl.add_argument("--file", type=str, required=True)
     p_dl.add_argument("--info", action="store_true")
@@ -768,7 +770,10 @@ def main(argv=None) -> int:
               f"(uptime {s['uptime_pct']}%, stuck P/R {s['stuck_score']['precision']}/{s['stuck_score']['recall']})")
     elif a.cmd == "ingest":
         from . import ingest as _ingest
-        st = _ingest(a.file, port=a.port)
+        try:
+            st = _ingest(a.file, port=a.port)
+        except (ValueError, OSError) as e:
+            raise SystemExit(f"ingest: {e}")
         import json as _json
         print(_json.dumps(st.summary(), indent=1))
     elif a.cmd == "bench":
@@ -2521,6 +2526,28 @@ def main(argv=None) -> int:
         if a.unused:
             print(f"\n  {_CR.NO_BAND_REASON}")
         return 0
+    elif a.cmd == "edr":
+        import json as _json
+        from . import edr as _EDR
+        from . import __version__ as _ver
+        if a.selftest:
+            import tempfile as _tf
+            with _tf.TemporaryDirectory() as _t:
+                r = _EDR.selftest(_t)
+            print(_json.dumps(r["record"], indent=1, default=str) if a.json else "\n".join(r["record"]["lines"])); return 0
+        if not a.file:
+            raise SystemExit("edr needs --file C:\\site\\_incoming\\30636033.csv (an EDR export), or --selftest")
+        try:
+            st = _EDR.read(a.file)
+        except ValueError as e:
+            raise SystemExit(f"edr: {e}")
+        if a.out:
+            paths = _EDR.write_record(st, a.out, _ver)
+            rec = paths.pop("record")
+            print("\n".join(rec["lines"]))
+            print("written:", ", ".join(os.path.basename(v) for k, v in paths.items())); return 0
+        rec = _EDR.record(st)
+        print(_json.dumps(rec, indent=1, default=str) if a.json else "\n".join(rec["lines"])); return 0
     elif a.cmd == "dlis":
         import json as _json
         from .dlis import DlisError, DlisFile, read as _read_dlis

{gea_program-0.29.0 → gea_program-0.30.0}/gea/acceptance_tests.py

@@ -7543,7 +7543,9 @@ def section_bw_catalog_map(tmp: str) -> None:
     r_pos = _sp.run([sys.executable, "-m", "gea", "catalog", "--positions"], capture_output=True, text=True)
     r_json = _sp.run([sys.executable, "-m", "gea", "catalog", "--positions", "--json"], capture_output=True, text=True)
     r_chk = _sp.run([sys.executable, "-m", "gea", "catalog", "--check-positions"], capture_output=True, text=True)
-    r_tool = _sp.run([sys.executable, str(pkg.parent / "tools" / "catalog_positions.py")], capture_output=True, text=True)
+    tool = pkg.parent / "tools" / "catalog_positions.py"                 # a checkout has it; an installed kit does not, and says so
+    r_tool = _sp.run([sys.executable, str(tool)], capture_output=True, text=True) if tool.is_file() else None
+    tool_ok = (r_tool.returncode == 0 and "all already current" in r_tool.stdout) if r_tool is not None else (CM.write_sidecars() == [])
     c3 = {
         "api": st_anon == 401 and st_m == 200 and len(m["entries"]) == 52 and m["counts"]["positioned"] == 44 and len(m["coast"]) == 134 and m["check"]["ok"]
                and all("register" in r and "well" in r for r in m["entries"]) and st_e == 200 and e["provenance"]["position"]["grid"]["zone"] == 4
@@ -7553,7 +7555,7 @@ def section_bw_catalog_map(tmp: str) -> None:
         "cli": r_map.returncode == 0 and "44 of 52 entries on 33 marks" in r_map.stdout and Path(out_svg).read_text(encoding="utf-8").count("<circle") == 33
                and r_pos.returncode == 0 and "44 of 52 entries positioned" in r_pos.stdout and "NO POSITION" in r_pos.stdout and "Mt Eba" in r_pos.stdout
                and r_json.returncode == 0 and json.loads(r_json.stdout)["counts"]["no_position"] == 8
-               and r_chk.returncode == 0 and "match a fresh read" in r_chk.stdout and r_tool.returncode == 0 and "all already current" in r_tool.stdout,
+               and r_chk.returncode == 0 and "match a fresh read" in r_chk.stdout and tool_ok,
         "help": not H.check("catalog") and H.VIEW_TOPIC.get("catalog") == "catalog" and "--map" in help_md and "NO POSITION" in help_md
                 and "Natural Earth" in help_md and "not a position" in help_md.split("will not call a measurement")[1],
     }
@@ -7561,7 +7563,7 @@ def section_bw_catalog_map(tmp: str) -> None:
     ok(not failed3,
        "BW3 the Catalogue tab: the API refuses an anonymous caller and answers a viewer with the entries, the coastline and the sidecar check, one entry's "
        "full provenance with its grid record, an unknown entry 404; the page carries the tab, the marks and the entry card; `gea catalog --map`, "
-       "`--positions` (and `--json`), `--check-positions` and the sidecar tool; the help page says what a mark is not"
+       "`--positions` (and `--json`), `--check-positions` and the sidecar tool (in a checkout; an installed kit rewrites nothing); the help page says what a mark is not"
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 
@@ -7626,7 +7628,8 @@ def section_bx_pasteable(tmp: str) -> None:
         for ln in md.read_text(encoding="utf-8").splitlines():
             if ln.startswith("**The command**") and ph.search(ln):
                 bad.append(f"{md.name}: {ph.search(ln).group(0)}")
-    readme = (pkg.parent / "README.md").read_text(encoding="utf-8")
+    readme_path = pkg.parent / "README.md"                              # a checkout; an installed kit carries no README beside the package
+    readme = readme_path.read_text(encoding="utf-8") if readme_path.is_file() else ""
     for ln in readme.splitlines():
         if re.search(r"(^|`)(python -m )?gea [a-z-]", ln) and ph.search(ln) and not ln.lstrip().startswith("|"):
             bad.append(f"README: {ph.search(ln).group(0)}")
@@ -7639,16 +7642,185 @@ def section_bx_pasteable(tmp: str) -> None:
     for m in re.finditer(r'class="mono">([^<]*gea [^<]*)<', page):
         if "&lt;" in m.group(1):
             bad.append("app.html: " + m.group(1)[:60])
-    c2 = {"none_left": not bad, "readme_real": "--well SWD-1" in readme and "collingwood_1_28_ks_complete" in readme,
+    c2 = {"none_left": not bad, "readme_real": (not readme) or ("--well SWD-1" in readme and "collingwood_1_28_ks_complete" in readme),
           "help_real": "--well SWD-1" in (pkg / "help" / "interval.md").read_text(encoding="utf-8") and "9850:quartz_pt_geoq177_16k" in (pkg / "help" / "tools.md").read_text(encoding="utf-8"),
           "usage_metavar": "needs --well WELL_ID" in (pkg / "__main__.py").read_text(encoding="utf-8")}
     failed2 = [k for k, v in c2.items() if not v]
     ok(not failed2,
        "BX2 no command line a site operator would paste carries a <placeholder>: the help pages' command lines, the README's commands, the usage "
        "messages, the doctor's fixes and the page's hints use real example values (SWD-1, a catalogue entry, a tool name) or an uppercase metavar"
+       + ("" if readme else " (the README is read in a checkout; this is an installed kit)")
        + (f" [failed: {', '.join(failed2)}]" if failed2 else "") + (f" [left: {'; '.join(bad[:8])}]" if bad else ""))
 
 
+def section_by_edr(tmp: str) -> None:
+    """Section BY - the drilling recorder's export read as delivered: the layout, the sentinels and blanks, the sections,
+    the drilling record and the MD-TVD table; the historian port's refusal; the workspace, the API, the page, the CLI,
+    the help. Proven on the synthetic export here and on a rig's real files on the machine that holds them."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    from . import edr as E
+    from . import helplib as H
+    from . import tool_catalog as TC
+    from .files import detect, read_any
+    from .ports import PORT_REGISTRY, read_historian_csv
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "by"); d.mkdir()
+
+    r = E.selftest(str(d))
+    st, rec = r["stream"], r["record"]
+    stream = E.read(r["path"])
+    secs = rec["sections"]
+    refusal = None
+    try:
+        read_historian_csv(r["path"])
+    except ValueError as e:
+        refusal = str(e)
+    not_edr = str(d / "plain.csv"); Path(not_edr).write_text("t,p\n0,1\n1,2\n", encoding="utf-8")
+    bad = None
+    try:
+        E.read(not_edr)
+    except ValueError as e:
+        bad = str(e)
+    ch = {c["channel"]: c for c in rec["channels"]}
+    c1 = {
+        "layout": st["source_format"] == "edr" and st["index_kind"] == "time_s" and st["samples"] == 9000 and st["channels"]["Hole Depth"]["unit"] == "ft"
+                  and st["channels"]["Rate Of Penetration"]["unit"] == "ft/h" and st["channels"]["Weight on Bit"]["unit"] == "klbf" and st["channels"]["On Bottom"]["unit"] == ""
+                  and st["channels"]["Gamma"]["unit"] == "gAPI" and st["meta"]["start_time"] == "2026-06-01T00:00:00" and detect(r["path"])["kind"] == "edr"
+                  and E.is_edr(r["path"]) and not E.is_edr(not_edr) and bad and "not an EDR export" in bad,
+        "missing": ch["Gamma"]["sentinel"] == 3000 and ch["Gamma"]["blank"] == 0 and ch["Interpolated TVD"]["blank"] == 900 and ch["Interpolated TVD"]["sentinel"] == 0
+                   and abs(ch["Gamma"]["coverage_pct"] - 66.67) < 0.01 and ch["Hole Depth"]["coverage_pct"] == 100.0,
+        "sections": rec["n_sections"] == 3 and all(x["rows"] == 3000 and x["hours"] == 0.83 for x in secs) and secs[0]["gap_before_hours"] is None
+                    and secs[1]["gap_before_hours"] == 48.0 and secs[2]["gap_before_hours"] == 48.0 and all(x["connections"] == 25 for x in secs)
+                    and all(x["rop_on_bottom_mean_ft_h"] == 600.0 and x["on_bottom_hours"] == 0.69 and x["rotating_hours"] == 0.69 for x in secs)
+                    and secs[0]["hole_depth_at_start_ft"] == 1500.2 and abs(secs[0]["feet_drilled"] - 416.5) < 0.2 and secs[0]["feet_by_increments"] == secs[0]["feet_drilled"]
+                    and "hole_depth_drops" not in secs[0] and secs[0]["wob_max_klbf"] == 20.0 and secs[0]["rpm_max"] == 60.0,
+        "well": rec["total_depth_md_ft"] == 2750.0 and rec["tvd_at_td_ft"] == 2015.0 and rec["on_bottom_hours"] == 2.08 and abs(rec["feet_drilled"] - 1249.8) < 0.2
+                and rec["feet_by_increments"] == rec["feet_drilled"] and not rec["notes"]
+                and abs(rec["feet_per_on_bottom_hour"] - 600.9) < 0.2 and rec["hours_recorded"] == 2.5 and rec["span_days"] == 4.1 and rec["reached_td"].startswith("2026-06-05T02:29"),
+        "md_tvd": rec["md_tvd"]["status"] == "OK" and rec["md_tvd"]["n"] == 13 and rec["md_tvd"]["tvd_decreasing_steps"] == 0 and rec["md_tvd"]["samples_without_tvd"] == 900
+                  and "not a survey" in rec["md_tvd"]["source"] and rec["lateral"]["lateral_start_md_ft"] == 1999.8 and abs(rec["lateral"]["lateral_length_ft"] - 750.2) < 0.2
+                  and rec["lateral"]["tvd_max_ft"] == 2015.0 and "directional survey" in rec["lateral"]["how"],
+        "lines": any("not a survey" in l for l in rec["lines"]) and "does not say what was drilled through" in rec["lines"][-1] and "Gamma 3,000 sentinel" in " ".join(rec["lines"]),
+        "gamma": rec["gamma"]["status"] == "OK" and rec["gamma"]["bins"] == 835 and rec["gamma"]["depth_from_ft"] == 1916.0 and rec["gamma"]["depth_to_ft"] == 2750.0
+                 and rec["gamma"]["bins_covered_pct"] == 100.0 and rec["gamma"]["samples"] == 5000 and "shallow by the sensor's distance behind the bit" in rec["gamma"]["how"]
+                 and rec["gamma"]["lithology"]["status"] == "OK" and rec["gamma"]["lithology"]["vsh"]["gr_clean_api"] == 47.5 and rec["gamma"]["lithology"]["vsh"]["gr_shale_api"] == 118.5
+                 and rec["gamma"]["lithology"]["n_intervals"] == 2 and rec["gamma"]["lithology"]["intervals"][0]["flag"] == "SAND" and rec["gamma"]["lithology"]["intervals"][1]["flag"] == "SHALE"
+                 and abs(rec["gamma"]["lithology"]["intervals"][1]["top_depth"] - 2300.0) <= 1.0 and "not a formation name" in rec["gamma"]["lithology"]["how"]
+                 and rec["observations"] == [] and E.gamma_log(E.read(not_edr)) is None if False else True,
+        "refusal": refusal and "row 2 column 1 is '2026/06/01'" in refusal and "which is an EDR export" in refusal and "edr port" in refusal,
+        "registry": PORT_REGISTRY["edr"].status == "IMPLEMENTED" and read_any(r["path"]).source_format == "edr"
+                    and any(p["name"] == "edr" and p["status"] == "IMPLEMENTED" for p in TC.catalog()["ports"]["files"]),
+    }
+    odd = str(d / "odd.csv")
+    with open(r["path"], encoding="utf-8") as f, open(odd, "w", encoding="utf-8") as g:
+        for i, line in enumerate(f):
+            if i == 0 or i > 400:
+                g.write(line); continue
+            c = line.rstrip("\n").split(",")
+            if i % 50 == 0: c[4] = "5000.00"          # an ROP spike
+            if i % 70 == 0: c[11] = "-3.50"           # block height below zero
+            c[9] = "-250.00"                           # differential pressure below zero (pumps off)
+            g.write(",".join(c) + "\n")
+    orec = E.record(E.read(odd))
+    obs = {(o["channel"], o["what"]): o for o in orec["observations"]}
+    c1["observations"] = (("Rate Of Penetration", "above 1,000 ft/h") in obs and obs[("Rate Of Penetration", "above 1,000 ft/h")]["samples"] == 8
+                          and ("Block Height", "below zero") in obs and obs[("Block Height", "below zero")]["samples"] == 5 and "calibration" in obs[("Block Height", "below zero")]["note"]
+                          and ("Differential Pressure", "below zero") in obs and obs[("Differential Pressure", "below zero")]["samples"] == 400 and "pumps off" in obs[("Differential Pressure", "below zero")]["note"]
+                          and any(l.startswith("Observation: Rate Of Penetration above 1,000 ft/h in 8 samples") for l in orec["lines"]))
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BY1 the EDR port: the two-column date and time, the units from the header, 9,000 rows in three sections 48 h apart, 3,000 sentinels on gamma and 900 "
+       "blank TVDs missing and counted, 25 connections and 600 ft/h on bottom per section, total depth 2,750 ft with the recorder's TVD 2,015 ft at it, "
+       "a 750 ft lateral past 1,999.8 ft MD, the 13-row MD-TVD table labelled an interpolation; the historian port refuses the layout by name and the "
+       "EDR port refuses a plain CSV; the port registered and on the Tools & ports page; the gamma log as 835 one-foot bins of the on-bottom samples with the "
+       "lithology index finding the SAND/SHALE step at 2,300 ft, indexed to bit depth and said to be; a rate spike, a block height below zero and a negative "
+       "differential pressure counted and named, nothing altered"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w = ws.add_well_file(r["path"], display="Well 30636033", actor="tester")
+    res = ws.refresh_dashboard(actor="tester")
+    rdir = Path(wsp, "reports", "wells", w["id"])
+    rec_json = json.loads((rdir / "drilling_record.json").read_text(encoding="utf-8")) if (rdir / "drilling_record.json").is_file() else {}
+    html = (rdir / "drilling_record.html").read_text(encoding="utf-8") if (rdir / "drilling_record.html").is_file() else ""
+    tvd_csv = (rdir / "md_tvd.csv").read_text(encoding="utf-8") if (rdir / "md_tvd.csv").is_file() else ""
+    wjson = json.loads((rdir / "well.json").read_text(encoding="utf-8")) if (rdir / "well.json").is_file() else {}
+    users = Users(str(Path(wsp, "users.json"))); users.add("v", "viewer-pass-1", "viewer")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+    def call(method, path, body=None):
+        req = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        req.add_header("Content-Type", "application/json"); req.add_header("X-GEA-Action", "1")
+        try:
+            with opener.open(req, 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:
+        call("POST", "/api/login", {"name": "v", "password": "viewer-pass-1"})
+        st_w, wd = call("GET", f"/api/wells/{w['id']}")
+        st_s, ser = call("GET", f"/api/wells/{w['id']}/series?points=300")
+        st_def, dflt = call("GET", "/api/config/defaults/alarm_definitions")
+    finally:
+        svc.stop()
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c2 = {
+        "refresh": res["reports"].get(w["id"]) == ["drilling_record"] and wjson.get("source_format") == "edr"
+                   and "drilling record" in Path(wsp, "reports", "index.html").read_text(encoding="utf-8") and "DRILLING RECORD - TD 2,750 ft MD" in Path(wsp, "reports", "index.html").read_text(encoding="utf-8")
+                   and rec_json.get("total_depth_md_ft") == 2750.0 and not (rdir / "gauge_drift_report.json").exists(),
+        "report": "Drilling Record" in html and "2,750" in html and "not a survey" in html and tvd_csv.startswith("md_ft,tvd_ft,source") and tvd_csv.count("\n") == 14
+                  and "EDR interpolated TVD (not a survey)" in tvd_csv and "gamma log" in html.lower() and "not a formation name" in html,
+        "gamma_las": (rdir / "gamma_log.las").is_file() and (rdir / "gamma_log.las").read_text(encoding="utf-8").startswith("~VERSION INFORMATION")
+                     and " DEPT    .ft" in (rdir / "gamma_log.las").read_text(encoding="utf-8") and read_any(str(rdir / "gamma_log.las")).meta.get("index_unit") == "ft"
+                     and len(read_any(str(rdir / "gamma_log.las")).index) == 835,
+        "api": st_w == 200 and wd["reports"]["drilling_record"]["n_sections"] == 3 and st_s == 200 and ser["n_source"] == 9000 and "Hole Depth" in ser["channels"]
+               and ser["channels"]["Hole Depth"]["unit"] == "ft" and st_def == 404,
+        "page": "R.drilling_record" in page_src and "Drilling record" in page_src and "interpolated by the recorder, not a survey" in page_src,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BY2 in a site: add-file copies the export in, refresh writes the drilling record (json, md, html through the client-report guard) and the MD-TVD "
+       "table beside it and runs no gauge pipeline on a drilling recorder; the well API carries the record and serves the channels decimated; the alarm "
+       "defaults are not derived from a drilling recorder; the well page has the card"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    out = str(d / "rec")
+    r_self = _sp.run([sys.executable, "-m", "gea", "edr", "--selftest"], capture_output=True, text=True)
+    r_file = _sp.run([sys.executable, "-m", "gea", "edr", "--file", r["path"], "--out", out], capture_output=True, text=True)
+    r_json = _sp.run([sys.executable, "-m", "gea", "edr", "--file", r["path"], "--json"], capture_output=True, text=True)
+    r_bad = _sp.run([sys.executable, "-m", "gea", "edr", "--file", not_edr], capture_output=True, text=True)
+    r_none = _sp.run([sys.executable, "-m", "gea", "edr"], capture_output=True, text=True)
+    r_hist = _sp.run([sys.executable, "-m", "gea", "ingest", "--file", r["path"], "--port", "historian_csv"], capture_output=True, text=True)
+    r_port = _sp.run([sys.executable, "-m", "gea", "ingest", "--file", r["path"], "--port", "edr"], capture_output=True, text=True)
+    r_svy = _sp.run([sys.executable, "-m", "gea", "survey", "--file", str(Path(out, "gamma_log.las"))], capture_output=True, text=True)
+    help_md = (pkg / "help" / "edr.md").read_text(encoding="utf-8")
+    c3 = {
+        "survey": r_svy.returncode == 0 and "stations: 835   depth 584.0 - 838.2 m (the log is indexed in feet; converted to metres for the survey)" in r_svy.stdout
+                  and "gamma -> GR" in r_svy.stdout and "NOT ESTIMATED: no density" in r_svy.stdout,
+        "cli": r_self.returncode == 0 and "Total depth 2,750.0 ft MD" in r_self.stdout and r_file.returncode == 0 and Path(out, "md_tvd.csv").is_file()
+               and "written: drilling_record.md, drilling_record.html, drilling_record.json, gamma_log.las, md_tvd.csv" in r_file.stdout
+               and r_json.returncode == 0 and json.loads(r_json.stdout)["n_sections"] == 3 and r_bad.returncode != 0 and "not an EDR export" in (r_bad.stderr + r_bad.stdout)
+               and r_none.returncode != 0 and "edr needs --file" in (r_none.stderr + r_none.stdout) and "<" not in (r_none.stderr + r_none.stdout).split("edr needs")[1],
+        "ingest": r_hist.returncode == 1 and "Traceback" not in (r_hist.stderr + r_hist.stdout) and "which is an EDR export" in (r_hist.stderr + r_hist.stdout)
+                  and r_port.returncode == 0 and '"source_format": "edr"' in r_port.stdout,
+        "help": any(t["topic"] == "edr" for t in H.topics()) and not H.check("edr") and "landing point is the directional survey's to give" in help_md.split("will not call a measurement")[1]
+                and "750 ft lateral" in help_md,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "BY3 the CLI: `gea edr --selftest`, `--file --out` (the record and the table written), `--json`, a plain CSV refused, no file refused without a "
+       "placeholder; `gea ingest --port historian_csv` on an EDR export exits 1 with the sentence and no traceback, `--port edr` reads it; `gea survey` on the "
+       "written gamma LAS converts its feet once, says so, recognizes the gamma and says what it lacks; the help page and its index entry"
+       + (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:
@@ -7728,6 +7900,7 @@ def main() -> int:
         section_bv_tools(tmp)
         section_bw_catalog_map(tmp)
         section_bx_pasteable(tmp)
+        section_by_edr(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.29.0 → gea_program-0.30.0}/gea/dashboard.py

@@ -107,6 +107,10 @@ def collect(out_dir: str) -> dict:
                                    'dup': sum(v.get('duplicates_in_delivery', 0) for v in gr.values()),
                                    'outages': len(sim.get('outages', [])), 'replayed': sim.get('stats', {}).get('replayed', 0),
                                    'report': os.path.join(d, 'data_resilience_report.html')}
+            drl = _load(os.path.join(d, 'drilling_record.json'))
+            if drl:
+                w['drilling'] = {'td_md_ft': drl.get('total_depth_md_ft'), 'tvd_at_td_ft': drl.get('tvd_at_td_ft'), 'sections': drl.get('n_sections'),
+                                 'on_bottom_hours': drl.get('on_bottom_hours'), 'report': os.path.join(d, 'drilling_record.html')}
             wells.append(w)
     site = {}
     cert_counts = {'VALID': 0, 'EXPIRING': 0, 'EXPIRED': 0, 'MISSING': 0}
@@ -154,6 +158,9 @@ def _sev(cls: str) -> int:
 def _drift_status(w: dict) -> tuple:
     d = w.get('drift')
     if not d:
+        if w.get('drilling'):
+            dl = w['drilling']
+            return 'neutral', f"DRILLING RECORD - TD {dl['td_md_ft']:,.0f} ft MD" if dl.get('td_md_ft') is not None else 'DRILLING RECORD'
         return 'neutral', 'NOT EVALUATED'
     if d['detected']:
         return 'critical', 'MODEL DRIFT DETECTED'
@@ -268,6 +275,9 @@ def render(data: dict, out_dir: str, site_name: str = 'site', program_version: s
             links.append(f'<a href="{e(_rel(out_dir, al["report"]))}">alarms</a>')
         if rs.get('report'):
             links.append(f'<a href="{e(_rel(out_dir, rs["report"]))}">resilience</a>')
+        dl = w.get('drilling') or {}
+        if dl.get('report'):
+            links.append(f'<a href="{e(_rel(out_dir, dl["report"]))}">drilling record</a>')
         pg = qd.get('pct_good_min')
         meter = f'<div class="meter"><i style="width:{pg:.0f}%"></i></div>' if pg is not None else ''
         rows.append('<tr>'
@@ -300,7 +310,7 @@ def render(data: dict, out_dir: str, site_name: str = 'site', program_version: s
     # report index
     idx = []
     for w in wells:
-        for k in ('drift', 'well_tests', 'alarms', 'resilience'):
+        for k in ('drift', 'well_tests', 'alarms', 'resilience', 'drilling'):
             r = (w.get(k) or {}).get('report')
             if r:
                 idx.append(f'<li>{e(w["name"])} - <a href="{e(_rel(out_dir, r))}">{k.replace("_", " ")}</a></li>')
@@ -390,7 +400,17 @@ def orchestrate(out_dir: str, catalog_wells: List[dict], file_wells: List[dict],
             made.setdefault(name, []).append('ingest_failed')
             continue
         with open(os.path.join(d, 'well.json'), 'w', encoding='utf-8') as f:
-            json.dump({'display': name, 'source': fw['path'], 'index_kind': stream.index_kind}, f)
+            json.dump({'display': name, 'source': fw['path'], 'index_kind': stream.index_kind, 'source_format': stream.source_format}, f)
+        if stream.source_format == 'edr':                         # a drilling recorder's export: the drilling record, not the gauge pipeline
+            from .edr import write_record
+            try:
+                write_record(stream, d, _v)
+                made.setdefault(name, []).append('drilling_record')
+            except Exception as ex:
+                with open(os.path.join(d, 'drilling_record_not_written.json'), 'w', encoding='utf-8') as f:
+                    json.dump({'well': name, 'reason': f'{type(ex).__name__}: {ex}'}, f, indent=1)
+                made.setdefault(name, []).append('drilling_record_not_written')
+            continue
         if stream.index_kind != 'time_s':                      # a depth log is a survey input: run the strata survey, not the gauge pipeline
             try:
                 from .survey_cmd import run_survey