gea-program 0.58.0__tar.gz → 0.60.0__tar.gz

{gea_program-0.58.0 → gea_program-0.60.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.58.0
+Version: 0.60.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
@@ -659,6 +659,30 @@ EIA) or a declared price, with the net revenue interest, severance tax and
 operating cost declared. A forecast is not a reserves report, and the page
 says so. The **Decline curves** tab, `gea decline`, `gea help decline`.
 
+### The declarations workbook
+
+Everything the operator declares about a pad goes in through one sheet -
+`gea declare --workspace C:\site --template pad3.xlsx` writes it as an
+Excel workbook already filled with what is declared; `gea declare
+--workspace C:\site --file pad3.xlsx` checks it row by row and `--apply`
+writes it. Beside the wells, rates, runs and casing, it carries the
+engineering: the survey program and plans, pore pressure and measured
+pressures, the torque-and-drag string, the hydraulics (string, hole, mud,
+viscometer, nozzles), frac stage tables and monitored wells, production
+and the decline terms. A well with no directional survey is read on the
+drilling recorder's own Interpolated TVD where one is needed, labelled as
+the recorder's interpolation. `gea help declare`.
+
+### When one well cannot be reported
+
+Refresh every report goes on past a well it cannot read: that well is
+written down with why (`reports\wells\<well>\refresh_failed.json`), shown
+NOT REPORTED on the overview and the printed dashboard, and named by the
+refresh job and the month-end packet; every other well is reported. A
+catalogue well is added only from an entry that carries a downhole gauge
+series, with a well inside it and its gauge depth; a live seismic station
+whose feed has written nothing yet is listed as having no recording yet.
+
 ### Hydraulics and ECD
 
 The pressures the mud makes while it circulates, from the six-speed

{gea_program-0.58.0 → gea_program-0.60.0}/README.md

@@ -620,6 +620,30 @@ EIA) or a declared price, with the net revenue interest, severance tax and
 operating cost declared. A forecast is not a reserves report, and the page
 says so. The **Decline curves** tab, `gea decline`, `gea help decline`.
 
+### The declarations workbook
+
+Everything the operator declares about a pad goes in through one sheet -
+`gea declare --workspace C:\site --template pad3.xlsx` writes it as an
+Excel workbook already filled with what is declared; `gea declare
+--workspace C:\site --file pad3.xlsx` checks it row by row and `--apply`
+writes it. Beside the wells, rates, runs and casing, it carries the
+engineering: the survey program and plans, pore pressure and measured
+pressures, the torque-and-drag string, the hydraulics (string, hole, mud,
+viscometer, nozzles), frac stage tables and monitored wells, production
+and the decline terms. A well with no directional survey is read on the
+drilling recorder's own Interpolated TVD where one is needed, labelled as
+the recorder's interpolation. `gea help declare`.
+
+### When one well cannot be reported
+
+Refresh every report goes on past a well it cannot read: that well is
+written down with why (`reports\wells\<well>\refresh_failed.json`), shown
+NOT REPORTED on the overview and the printed dashboard, and named by the
+refresh job and the month-end packet; every other well is reported. A
+catalogue well is added only from an entry that carries a downhole gauge
+series, with a well inside it and its gauge depth; a live seismic station
+whose feed has written nothing yet is listed as having no recording yet.
+
 ### Hydraulics and ECD
 
 The pressures the mud makes while it circulates, from the six-speed

{gea_program-0.58.0 → gea_program-0.60.0}/gea/__init__.py

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

{gea_program-0.58.0 → gea_program-0.60.0}/gea/__main__.py

@@ -533,11 +533,11 @@ def main(argv=None) -> int:
     p_ds.add_argument("--actor", type=str, default="cli")
     p_ds.add_argument("--json", action="store_true")
 
-    p_dc = sub.add_parser("declare", help="the declarations sheet: wells' identity, position and elevation, surveys, rates, items and AFEs, fleet tools, drill-string runs, ESP penetrators and drives - one CSV, checked against the workspace before anything is written")
+    p_dc = sub.add_parser("declare", help="the declarations sheet: wells' identity, position and elevation, surveys, rates, items and AFEs, fleet tools, drill-string runs, ESP penetrators and drives, the survey program and plans, pore pressure, torque and drag, hydraulics, frac stages, production - one CSV or Excel workbook, checked against the workspace before anything is written")
     p_dc.add_argument("--workspace", type=str, required=True)
     p_dc.add_argument("--file", type=str, default=None, help="the sheet (CSV); every row is planned NEW, CHANGE or SAME and nothing is written without --apply")
     p_dc.add_argument("--apply", action="store_true", help="write the NEW and CHANGE rows (only when the sheet has no error)")
-    p_dc.add_argument("--template", type=str, default=None, help="write the sheet for this workspace, filled with what is already declared, to this path")
+    p_dc.add_argument("--template", type=str, default=None, help="write the sheet for this workspace, filled with what is already declared, to this path (.xlsx: an Excel workbook; otherwise CSV)")
     p_dc.add_argument("--actor", type=str, default="cli")
     p_dc.add_argument("--json", action="store_true")
 
@@ -2352,8 +2352,11 @@ def main(argv=None) -> int:
         except WorkspaceError as e:
             raise SystemExit(f"declare: {e}")
         if a.template:
-            with open(a.template, "w", encoding="utf-8", newline="") as f:
-                f.write(_DC.template(ws))
+            if a.template.lower().endswith(".xlsx"):
+                _DC.template_xlsx(ws, a.template)
+            else:
+                with open(a.template, "w", encoding="utf-8", newline="") as f:
+                    f.write(_DC.template(ws))
             print(f"wrote {a.template}: fill in the blanks, then gea declare --workspace {a.workspace} --file {a.template}")
             return 0
         if not a.file:
@@ -3223,7 +3226,16 @@ def main(argv=None) -> int:
                 print(_json.dumps(ws.migrate_out_dir(a.from_dir, actor=a.actor), indent=1)); return 0
             elif a.action == "refresh":
                 r = ws.refresh_dashboard(actor=a.actor, outages=a.outage, month=a.month, run_sat=a.sat)
-                print("dashboard:", r.get("index") if isinstance(r, dict) else r); return 0
+                print("dashboard:", r.get("index") if isinstance(r, dict) else r)
+                for wname, kinds in sorted(((r.get("reports") or {}) if isinstance(r, dict) else {}).items()):
+                    if "refresh_failed" in kinds:
+                        try:
+                            with open(os.path.join(ws.reports_dir, "wells", wname, "refresh_failed.json"), encoding="utf-8") as fh:
+                                why = _json.load(fh).get("reason", "")
+                        except (OSError, ValueError):
+                            why = ""
+                        print(f"well {wname}: its reports could not be written - {why} (the other wells were reported)")
+                return 0
             elif a.action == "audit":
                 for row in ws.audit_log(limit=50):
                     print(row["utc"], row["actor"], row["action"], _json.dumps(row["detail"]))

{gea_program-0.58.0 → gea_program-0.60.0}/gea/acceptance_tests.py

@@ -10472,8 +10472,9 @@ def section_cn_four(tmp: str) -> None:
     t0 = now.replace(hour=10, minute=59, second=0) if now.hour < 23 else now.replace(hour=10, minute=59, second=0)
     due_before = PS.due_now(ws, t0)
     s1 = PS.write(ws, __version__, "tester", nt, now + timedelta(minutes=2))
-    due_after = PS.due_now(ws, (now + timedelta(minutes=2)).replace(hour=23, minute=0))
-    nxt = (now + timedelta(days=1)).replace(hour=11, minute=1, second=0)
+    w1 = now + timedelta(minutes=2)                               # the summary's own day: two minutes on may already be tomorrow (UTC)
+    due_after = PS.due_now(ws, w1.replace(hour=23, minute=0))
+    nxt = (w1 + timedelta(days=1)).replace(hour=11, minute=1, second=0)
     due_next = PS.due_now(ws, nxt)
     ws.audit("tester", "test.after", {})
     s2 = PS.write(ws, __version__, "tester", nt, now + timedelta(minutes=5), send=False)
@@ -13002,6 +13003,313 @@ def section_da_hydraulics(tmp: str) -> None:
        + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
 
 
+def section_db_declarations_engineering(tmp: str) -> None:
+    """Section DB - the declarations sheet carries the engineering: the survey program, a plan, the pore-pressure
+    settings and a measured pressure, the torque-and-drag string, the hydraulics, a frac stage table and its monitor,
+    production and the decline terms - planned NEW, written, then SAME on a second import and from the template; every
+    malformed row refused with nothing written; the sheet as an Excel workbook; a well with no survey read on the
+    drilling recorder's own TVD, labelled so."""
+    import csv as _csv
+    import io as _io
+    import shutil as _sh
+    import subprocess as _sp
+    from . import __version__ as _ver
+    from . import declarations as DC
+    from . import decline as DCA
+    from . import edr as E
+    from . import frac_hits as FH
+    from . import helplib as H
+    from . import hydraulics as HY
+    from . import pore_pressure as PPF
+    from . import torque_drag as TND
+    from . import wellplan as WPL
+    from . import xlsx_read as XR
+    from .workspace import Workspace
+    pkg = Path(__file__).parent
+    d = Path(tmp, "declare_eng"); d.mkdir()
+    hy = HY.selftest_files(str(d / "hy"))
+    fh = FH.selftest_files(str(d / "fh"))
+    dc = DCA.selftest_files(str(d / "dc"))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w1 = ws.add_well_file(hy["record"], display="HY-1", actor="tester")["id"]
+    w2 = ws.add_well_file(fh["gauge"], display="MON-1", actor="tester")["id"]
+    sheet_dir = d / "sheet"; sheet_dir.mkdir()
+    _sh.copy(hy["survey"], sheet_dir / "plan.csv"); _sh.copy(fh["stages"], sheet_dir / "stages.csv"); _sh.copy(dc["path"], sheet_dir / "production.csv")
+    rows = [
+        ["[survey_program]", "well", "program", "source"], ["", "HY-1", "0-1000:MWD+SRGM, 1000-:MWD+IFR1", "survey program rev 1 (test)"],
+        ["[plans]", "well", "file", "azimuth_reference", "md_unit", "source"], ["", "HY-1", "plan.csv", "true", "ft", "well plan rev 2 (test)"],
+        ["[pore_pressure]", "well", "indicator", "bit_in", "nct_top_m", "nct_bottom_m", "source"], ["", "HY-1", "dexponent", "8.75", "1300", "2000", "drilling program (test)"],
+        ["[pressures]", "well", "depth_m", "depth_kind", "value", "unit", "kind", "source"], ["", "HY-1", "2100", "tvd", "13.5", "ppg", "lot", "LOT at the 9-5/8 shoe (test)"],
+        ["[torque_drag]", "well", "string", "mud_ppg", "mu_cased", "mu_open", "source"], ["", "HY-1", "BHA:350:6.75:95:6.75; drill pipe::5:22.6:6.625", "11", "0.2", "0.28", "BHA report (test)"],
+        ["[hydraulics]", "well", "string", "hole", "mw_ppg", "fann", "flow_gpm", "nozzles_32", "bit_in", "tools_psi", "pp_ppg", "fg_ppg", "source"],
+        ["", "HY-1", "BHA:350:6.75:2.875; drill pipe::5:4.276", "9-5/8 casing:3500:8.681; open hole::8.75", "11", "600=60 300=38 100=21 6=7 3=6", "500",
+         "14 14 14 14 14", "8.75", "400", "9.5", "14.5", "mud report (test)"],
+        ["[frac_stages]", "well", "file", "depth_unit", "source"], ["", "HY-1", "stages.csv", "ft", "post-job report (test)"],
+        ["[frac_monitors]", "well", "channel"], ["", "MON-1", "P_gauge_psi"],
+        ["[production]", "well", "file", "source"], ["", "HY-1", "production.csv", "monthly report (test)"],
+        ["[decline_terms]", "well", "terminal_decline", "price_basis", "oil_price", "gas_price", "opex_month", "source"], ["", "HY-1", "0.08", "flat", "70", "3", "9000", "budget deck (test)"],
+    ]
+    buf = _io.StringIO(); _csv.writer(buf, lineterminator="\n").writerows(rows); text = buf.getvalue()
+    p1 = DC.apply(ws, text, "tester", str(sheet_dir))
+    a1 = DC.apply(ws, text, "tester", str(sheet_dir), write=True)
+    p2 = DC.apply(ws, text, "tester", str(sheet_dir))
+    tpl = DC.template(ws)
+    pt = DC.apply(ws, tpl, "tester", str(sheet_dir))
+    hcfg, tcfg, pcfg = HY.well_config(ws, w1), TND.well_config(ws, w1), PPF.well_config(ws, w1)
+    meas = (PPF._load(ws).get("measured") or {}).get(w1) or []
+    c1 = {
+        "planned": not p1["errors"] and p1["counts"]["NEW"] == 10 and p1["counts"]["CHANGE"] == 0 and sorted({s["table"] for s in p1["steps"]}) == sorted(DC.ENG_ORDER),
+        "written": a1["applied"] and len(a1["written"]) == 10,
+        "landed": WPL.well_settings(ws, w1)["program"] == [{"to_md_m": 1000.0, "model": "MWD+SRGM"}, {"to_md_m": None, "model": "MWD+IFR1"}]
+                  and bool(ws.well(w1).get("plan")) and pcfg["indicator"] == "dexponent" and pcfg["bit_in"] == 8.75
+                  and meas and meas[0]["kind"] == "lot" and meas[0]["unit"] == "ppg" and len(tcfg["string"]) == 2 and tcfg["mu_open"] == 0.28
+                  and hcfg["fann"] == {"600": 60.0, "300": 38.0, "100": 21.0, "6": 7.0, "3": 6.0} and hcfg["nozzles_32"] == [14.0] * 5 and len(hcfg["hole"]) == 2
+                  and FH.stages(ws).get(w1, {}).get("stages") == 6 and FH.settings(ws)["monitors"].get(w2, {}).get("channel") == "P_gauge_psi"
+                  and DCA.production(ws, w1) and DCA.well_config(ws, w1)["oil_price"] == 70.0,
+        "again": not p2["errors"] and p2["counts"]["NEW"] == 0 and p2["counts"]["CHANGE"] == 0 and p2["counts"]["SAME"] == 10,
+        "template": not pt["errors"] and pt["counts"]["NEW"] == 0 and pt["counts"]["CHANGE"] == 0 and all(f"[{t}]" in tpl for t in DC.ENG_ORDER),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DB1 one sheet carries the engineering - the survey program, a plan, the pore-pressure settings and a leak-off test, the torque-and-drag string, "
+       "the hydraulics (string, hole, mud, viscometer, nozzles), a frac stage table and its monitored well, production and the decline terms: ten rows "
+       "planned NEW, written through each tab's own function, SAME on a second import; the template lists every table and carries what is declared, "
+       "so importing it writes nothing" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- DB2 every malformed row refused, nothing written ---------------------------------------------------------------------
+    bad = {
+        "survey_program": ["", "HY-1", "0-1000:NO-SUCH-TOOL", "x"], "plans": ["", "HY-1", "missing.csv", "true", "ft", "x"],
+        "pore_pressure": ["", "HY-1", "dexponent", "99", "1300", "2000", "x"], "pressures": ["", "HY-1", "2100", "tvd", "13.5", "ppg", "guess", "x"],
+        "torque_drag": ["", "HY-1", "BHA:350", "11", "0.2", "0.28", "x"],
+        "hydraulics": ["", "HY-1", "", "", "11", "600:60", "500", "40 40", "8.75", "400", "9.5", "14.5", "x"],
+        "frac_stages": ["", "HY-1", "stages.csv", "yards", "x"], "decline_terms": ["", "HY-1", "0.08", "spot", "70", "3", "9000", "x"],
+    }
+    errs = {}
+    for t, r in bad.items():
+        hdr = next(x for x in rows if x[0] == f"[{t}]")
+        b_ = _io.StringIO(); _csv.writer(b_, lineterminator="\n").writerows([hdr, r]); bp = DC.apply(ws, b_.getvalue(), "tester", str(sheet_dir), write=True)
+        errs[t] = (len(bp["errors"]) == 1 and not bp["written"] and not bp["applied"])
+    mixed = rows[:2] + [["[pressures]", "well", "depth_m", "value", "kind", "source"], ["", "HY-1", "-5", "13", "pore", "x"]]
+    b_ = _io.StringIO(); _csv.writer(b_, lineterminator="\n").writerows(mixed); mp = DC.apply(ws, b_.getvalue(), "tester", str(sheet_dir), write=True)
+    ok(all(errs.values()) and len(mp["errors"]) == 1 and not mp["written"],
+       "DB2 a tool model that does not exist, a plan file that is not there, a bit size out of range, a pressure of no known kind, a string section "
+       "short of its figures, a viscometer pair without '=' and nozzles over 32/32, a depth unit of yards, a price basis of 'spot' - each refused with "
+       "its row named; a sheet with one bad row writes none of its good rows"
+       + (f" [failed: {', '.join(k for k, v in errs.items() if not v)}]" if not all(errs.values()) else ""))
+
+    # -- DB3 the sheet as an Excel workbook --------------------------------------------------------------------------------
+    xp = str(d / "declarations.xlsx")
+    DC.template_xlsx(ws, xp)
+    xb = Path(xp).read_bytes()
+    px = DC.apply(ws, XR.text_of(xb), "tester", str(sheet_dir))
+    cli_t = _sp.run([sys.executable, "-m", "gea", "declare", "--workspace", wsp, "--template", str(d / "t2.xlsx")], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_p = _sp.run([sys.executable, "-m", "gea", "declare", "--workspace", wsp, "--file", str(d / "t2.xlsx")], capture_output=True, text=True, cwd=str(pkg.parent))
+    ok(XR.is_xlsx(xb) and not px["errors"] and px["counts"]["NEW"] == 0 and px["counts"]["CHANGE"] == 0 and px["counts"]["SAME"] >= 10
+       and cli_t.returncode == 0 and XR.is_xlsx(Path(d / "t2.xlsx").read_bytes()) and cli_p.returncode == 0 and "nothing to write" in cli_p.stdout,
+       "DB3 the template as an Excel workbook (gea declare --template declarations.xlsx, and the Download on the Setup page): a workbook the import "
+       "reads back to the same plan - nothing new to write")
+
+    # -- DB4 no survey: the recorder's own TVD -------------------------------------------------------------------------------
+    st = E.read(hy["record"])
+    out = Path(ws.reports_dir, "wells", w1); out.mkdir(parents=True, exist_ok=True)
+    E.write_record(st, str(out), _ver)
+    rp = HY.recorder_path(ws, w1)
+    r_h = HY.page(ws, "workspace", w1)["result"]
+    TND.set_well(ws, "tester", w1, "BHA report (test)", TND.parse_string("BHA:350:6.75:95:6.75; drill pipe::5:22.6:6.625"), 11)
+    r_t = TND.page(ws, "workspace", w1)["result"]
+    from . import well3d as W
+    W.attach_trajectory(ws, w1, "s.csv", Path(hy["survey"]).read_bytes(), "tester", "true", "ft", None, None, None, "test survey")
+    r_s = HY.page(ws, "workspace", w1)["result"]
+    help_txt = H.page("declare") or ""
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c4 = {
+        "path": rp and rp["md_ft"][0] == 0.0 and abs(max(rp["tvd_ft"]) - 7480.0) < 30.0 and max(rp["inc_deg"]) <= 61.0 and "not a survey" in rp["source"],
+        "hydraulics": r_h and r_h["path_from"] == "recorder" and "Interpolated TVD" in r_h["how"] and abs(r_h["record"]["median_difference_psi"] - hy["offset_psi"]) <= 10.0
+                      and abs(r_h["tvd_td_ft"] - r_s["tvd_td_ft"]) < 30.0,
+        "torque_drag": r_t and r_t["path_from"] == "recorder" and "one vertical plane" in r_t["how"] and 55.0 <= r_t["max_inc_deg"] <= 61.0,
+        "survey_first": r_s["path_from"] == "survey",
+        "help": not H.check("declare") and all(f"[{t}]" in help_txt for t in DC.ENG_ORDER) and "Interpolated TVD" in (H.page("hydraulics") or "")
+                and "/api/declare/template?format=xlsx" in page_src,
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "DB4 a well with no survey attached is read on the drilling recorder's own Interpolated TVD, labelled as the recorder's interpolation and not a "
+       "survey: the hydraulics' TVDs within 30 ft of the survey's and the standpipe offset recovered the same; torque and drag on an inclination-only path "
+       "in one vertical plane, said so; a survey, once attached, is used instead; the help names every table"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
+def section_dc_every_tab(tmp: str) -> None:
+    """Section DC - every tab and button answers: the Verification tab reads the site reports itself; the Rig time
+    tab and the charts with a live well whose stream has not arrived; a catalogue well only from a gauge series, its
+    well and its gauge depth; one well that cannot be read never stops the refresh or the month-end, and is shown
+    with why; a live seismic station with no recording yet is a state, not a failure; a field left empty is answered
+    in the form's words."""
+    import http.cookiejar
+    import urllib.error
+    import urllib.request
+    from . import dashboard as D
+    from . import hydraulics as HY
+    from . import month_end as ME
+    from .service import Service, Users, friendly_error
+    from .workspace import Workspace, WorkspaceError, catalog_gauge_wells, gauge_entries
+    pkg = Path(__file__).parent
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    d = Path(tmp, "every_tab"); d.mkdir()
+    hy = HY.selftest_files(str(d / "hy"))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w_edr = ws.add_well_file(hy["record"], display="HY-1", actor="tester")["id"]
+    w_cat = ws.add_well_catalog("volve_f12_f14_production_excerpt", "15/9-F-12", 10000.0, actor="tester")["id"]
+
+    # -- DC1 a catalogue well: a gauge series, a well inside it, a gauge depth -------------------------------------------
+    def answer(*a):
+        try:
+            ws.add_well_catalog(*a, actor="tester")
+            return ""
+        except WorkspaceError as e:
+            return str(e)
+    other = next(k for k in __import__("gea").CATALOG if k not in gauge_entries())
+    m_series, m_empty = answer(other, "", 10000.0), answer("volve_f12_f14_production_excerpt", "", 10000.0)
+    m_wrong, m_md0 = answer("volve_f12_f14_production_excerpt", "15/9-F-99", 10000.0), answer("volve_f12_f14_production_excerpt", "15/9-F-14", 0)
+    m_none = answer("volve_f12_f14_production_excerpt", "15/9-F-14", None)
+    n_wells = len(ws.wells())
+    c1 = {
+        "gauges": gauge_entries() == ["volve_f12_f14_production_excerpt"] and catalog_gauge_wells("volve_f12_f14_production_excerpt") == ["15/9-F-12", "15/9-F-14"]
+                  and catalog_gauge_wells(other) == [],
+        "answered": "is not a downhole gauge series" in m_series and "volve_f12_f14_production_excerpt" in m_series
+                   and "choose the well inside" in m_empty and "15/9-F-14" in m_empty and "has no well '15/9-F-99'" in m_wrong
+                   and "greater than zero" in m_md0 and "the station MD is needed" in m_none,
+        "nothing_added": n_wells == 2,
+        "form": "entries.filter(e => (e.gauge_wells || []).length)" in page_src and '<select id="cWell">' in page_src
+                and "Enter the station MD in feet" in page_src,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DC1 a catalogue well is added only from an entry that carries a downhole gauge series, naming a well inside it and a gauge depth above zero: "
+       "an entry that is not a series, a well left empty or not in the entry, and a depth of zero or none are each answered with what to choose, and "
+       "nothing is added; the form lists only the series and their wells" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- DC2 one well that cannot be read: the refresh and the month-end go on, and say which and why ----------------------
+    bad = ws._register({"id": "old_entry__", "display": "old entry", "kind": "catalog", "files": [],
+                        "source": {"entry": other, "well": ""}, "station_md_ft": 10000.0}, "tester")["id"]   # as an older version could add it
+    res = ws.refresh_dashboard(actor="tester")
+    rep = res.get("reports") or {}
+    data = D.collect(ws.reports_dir)
+    failed_row = next((w for w in data["wells"] if w["slug"].startswith(other)), {})
+    me = ME.assemble(ws, "2026-09", actor="tester")
+    me_err = " | ".join(me.get("errors") or [])
+    cat_name = f"volve_f12_f14_production_excerpt__15/9-F-12".replace("/", "-")
+    c2 = {
+        "others_reported": "drift" in rep.get(cat_name, []) and "drilling_record" in rep.get(w_edr, []),
+        "failed_named": any("refresh_failed" in v for k, v in rep.items() if k.startswith(other))
+                        and os.path.isfile(os.path.join(ws.reports_dir, "wells", f"{other}__", "refresh_failed.json")),
+        "shown": bool(failed_row.get("failed")) and D._drift_status(failed_row)[1].startswith("NOT REPORTED"),
+        "month_end": me.get("included", 0) > 0 and f"well {other}__" in me_err and "dashboard refresh" not in me_err,
+        "page": "w.failed ? statusPill('serious', 'not reported')" in page_src,
+    }
+    ws.remove_well(bad, actor="tester")
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "DC2 a well that cannot be read (a catalogue entry an older version accepted) never stops the refresh: every other well is reported, the "
+       "failed one is written down with why and shown NOT REPORTED on the overview; the month-end packet is assembled and names that one well"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- DC3 a live well with no stream yet, a live station with no recording yet ------------------------------------------
+    from .wits0 import EXAMPLE_CONFIG as _WITS
+    wits_cfg = d / "wits0.json"
+    wits_cfg.write_text(json.dumps(_WITS), encoding="utf-8")
+    w_live = ws.add_well_live("Rig feed", "wits0", str(wits_cfg), actor="tester")["id"]
+    st = ws.add_live_station("Pad 3 seismometer", {"host": "127.0.0.1", "port": 18000, "streams": [{"network": "XX", "station": "PAD3"}]}, actor="tester")
+    try:
+        ws.refresh_seismic(st["id"], actor="tester")
+        m_seis = ""
+    except WorkspaceError as e:
+        m_seis = str(e)
+    me2 = ME.assemble(ws, "2026-09", actor="tester", refresh=True)
+    with open(os.path.splitext(me2["index"])[0] + ".json", encoding="utf-8") as fh_:
+        me2_items = json.load(fh_).get("items") or []
+    seis_item = next((i for i in me2_items if i["kind"] == "seismic" and i["id"] == st["id"]), {})
+
+    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("/")
+    o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+    def call(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))
+        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:
+        call("POST", "/api/login", {"name": "op", "password": "op-pass-123"})
+        st_rig, rig = call("GET", "/api/rig-time")
+        st_cm, cm = call("GET", f"/api/wells/{w_live}/chart/meta")
+        st_cx, _ = call("GET", "/api/wells/no-such-well/chart/meta")
+        st_cat, cat = call("GET", "/api/catalog")
+        st_add, add = call("POST", "/api/wells/catalog", {"entry": other, "well": "", "station_md": 10000})
+        st_pp, pp = call("POST", "/api/pore-pressure/measure", {"well_id": w_edr, "depth_m": "", "value": "", "unit": "psi", "kind": "pore", "source": "x"})
+        st_cf, cf = call("GET", "/api/config/")
+        st_cd, cd = call("GET", "/api/config/defaults/")
+        st_fw, fw = call("POST", "/api/files/watch", {"root": ""})
+        st_sl, sl = call("GET", "/api/seismic")
+        st_tp, tp = call("POST", f"/api/wells/{w_edr}/transient-params", {"params": {"mu_cp": 0.8}})
+        st_tp0, tp0 = call("POST", f"/api/wells/{w_edr}/transient-params", {"params": {}})
+    finally:
+        svc.stop()
+    gauges_api = {e["entry"]: e["gauge_wells"] for e in cat.get("entries", []) if e.get("gauge_wells")}
+    c3 = {
+        "seismic": "has no recording yet" in m_seis and seis_item.get("status") == "NOT AVAILABLE" and "no recording yet" in seis_item.get("reason", "")
+                   and not any(st["id"] in e for e in me2.get("errors") or []),
+        "rig_time": st_rig == 200 and isinstance(rig, dict),
+        "chart": st_cm == 200 and cm.get("available") is False and bool(cm.get("reason")) and st_cx == 404
+                 and "meta.available === false" in page_src,
+        "catalog_api": st_cat == 200 and gauges_api == {"volve_f12_f14_production_excerpt": ["15/9-F-12", "15/9-F-14"]}
+                       and st_add == 400 and "is not a downhole gauge series" in add.get("error", ""),
+        "site_reports": st_sl == 200 and "site_reports" in sl,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "DC3 a live seismic station whose feed has written nothing is answered as having no recording yet and is NOT AVAILABLE in the month-end, not "
+       "a failure; the Rig time tab answers with a live well whose stream has not arrived; that well's chart says there is nothing to chart yet "
+       "(an unknown well is still not found); the catalogue API names each series' wells and answers a well that is not one with what to choose"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- DC4 the form's words, and the Verification tab's own data -------------------------------------------------------------
+    def _tls_msg():
+        from . import tls as TLS
+        try:
+            TLS.use_site_certificate(ws, "tester", "", "")
+            return ""
+        except ValueError as e:
+            return str(e)
+    verify = page_src[page_src.index("VIEWS.verify = async"):]
+    verify = verify[:verify.index("\nVIEWS.", 10)] if "\nVIEWS." in verify[10:] else verify
+    c4 = {
+        "words": friendly_error("could not convert string to float: ''") == "a number is needed: a field was left empty"
+                 and friendly_error("could not convert string to float: 'abc'") == "'abc' is not a number"
+                 and friendly_error("no such well") == "no such well",
+        "pore": st_pp == 400 and pp.get("error") == "a number is needed: a field was left empty",
+        "config": st_cf == 404 and "choose a configuration by name first" in cf.get("error", "")
+                  and st_cd == 404 and "choose a configuration by name first" in cd.get("error", "")
+                  and page_src.count("if (!$('#cfgName').value.trim()) return toast('Choose a configuration by name first', 'err');") == 3,
+        "watch": st_fw == 400 and "add an import root under Administration first" in fw.get("error", "")
+                 and "w.title = 'Add an import root under Administration first'" in page_src,
+        "params": st_tp == 200 and st_tp0 == 200 and "unknown parameter" not in json.dumps(tp0),
+        "tls_path": _tls_msg().startswith("give the certificate file's full path"),
+        "verify": "let siteReports = {}; try { siteReports = (await get('/api/seismic')).site_reports || {}; }" in verify
+                  and verify.index("let siteReports") < verify.index("siteReports.seismic_dataset_report"),
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "DC4 a field left empty, or text where a number goes, is answered in the form's words rather than the program's; a configuration button with "
+       "no name chosen, a folder watch with no import root and the site's certificate with no path given say what to do first; a well's transient "
+       "parameters saved empty are cleared; the Verification tab reads the site reports itself"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
 def PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -13118,6 +13426,8 @@ def main() -> int:
         section_cy_company_sign_in(tmp)
         section_cz_it_review(tmp)
         section_da_hydraulics(tmp)
+        section_db_declarations_engineering(tmp)
+        section_dc_every_tab(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: