gea-program 0.59.0__tar.gz → 0.61.0__tar.gz

{gea_program-0.59.0 → gea_program-0.61.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.59.0
+Version: 0.61.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
@@ -673,6 +673,27 @@ 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.
+
+### Casing design and kick tolerance
+
+Each casing string's burst, collapse and tension ratings by API TR 5C3,
+from its size, weight and grade, against the loads the hole can put on it
+- gas to the surface held by the shoe, an emptied string, the buoyed
+weight with overpull - with the smallest safety factor and where, and the
+gas kick each open hole below a shoe can take and still be shut in. `gea
+casing --example`; declared on the **Casing & kick tolerance** tab, with
+`gea casing --workspace C:\site --well SWD-1 --strings ...`, or in the
+declarations sheet. `gea help casing`.
+
 ### Hydraulics and ECD
 
 The pressures the mud makes while it circulates, from the six-speed

{gea_program-0.59.0 → gea_program-0.61.0}/README.md

@@ -634,6 +634,27 @@ 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.
+
+### Casing design and kick tolerance
+
+Each casing string's burst, collapse and tension ratings by API TR 5C3,
+from its size, weight and grade, against the loads the hole can put on it
+- gas to the surface held by the shoe, an emptied string, the buoyed
+weight with overpull - with the smallest safety factor and where, and the
+gas kick each open hole below a shoe can take and still be shut in. `gea
+casing --example`; declared on the **Casing & kick tolerance** tab, with
+`gea casing --workspace C:\site --well SWD-1 --strings ...`, or in the
+declarations sheet. `gea help casing`.
+
 ### Hydraulics and ECD
 
 The pressures the mud makes while it circulates, from the six-speed

{gea_program-0.59.0 → gea_program-0.61.0}/gea/__init__.py

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

{gea_program-0.59.0 → gea_program-0.61.0}/gea/__main__.py

@@ -646,6 +646,23 @@ def main(argv=None) -> int:
     p_dc.add_argument("--actor", type=str, default="cli")
     p_dc.add_argument("--json", action="store_true")
 
+    p_cs = sub.add_parser("casing", help="casing design and kick tolerance: each string's burst, collapse and tension against the loads the hole can put on it (API TR 5C3 ratings), and the gas kick each open hole can take")
+    p_cs.add_argument("--workspace", type=str, default=None)
+    p_cs.add_argument("--well", type=str, default=None)
+    p_cs.add_argument("--example", action="store_true", help="the worked example (a vertical 10,000 ft well with three strings, declared for the example)")
+    p_cs.add_argument("--strings", type=str, default=None, help="shallowest shoe first: 'surface:13-3/8:54.5:J55:0-1500:17.5:9.0; intermediate:9-5/8:47:N80:0-7000:12.25:9.8' (what:od:lb_ft:grade:top-shoe:hole_in:mud_ppg[:wall_in])")
+    for k_, h_ in (("td", "the well's TD below the deepest string, ft MD"), ("td-hole", "the hole below the deepest string, in"), ("td-mw", "the mud below the deepest string, ppg"),
+                   ("pp", "a pore pressure for the well when the Pore pressure tab has none, ppg"), ("fg", "a fracture gradient for the well when the Pore pressure tab has none, ppg"),
+                   ("kick", "kick intensity above the mud, ppg (0.5)"), ("gas", "gas gradient, psi/ft (0.1)"), ("backup", "burst backup gradient outside, psi/ft (0.465)"),
+                   ("evacuation", "how far the string is emptied for collapse, 0 to 1 (1: to the shoe)"), ("df-burst", "burst design factor (1.1)"),
+                   ("df-collapse", "collapse design factor (1.125)"), ("df-tension", "tension design factor (1.6)"), ("overpull", "overpull, klbf (100)"),
+                   ("bha-od", "BHA outside diameter, in"), ("bha-length", "BHA length, ft"), ("dp-od", "drill pipe outside diameter, in")):
+        p_cs.add_argument("--" + k_, type=str, default=None, help=h_)
+    p_cs.add_argument("--source", type=str, default="", help="where the casing program came from")
+    p_cs.add_argument("--write", action="store_true")
+    p_cs.add_argument("--actor", type=str, default="cli")
+    p_cs.add_argument("--json", action="store_true")
+
     p_hy = sub.add_parser("hydraulics", help="the pressures the mud makes while it circulates - the standpipe, the bit, the annulus, the ECD against the pore pressure and fracture gradient, surge and swab - and the standpipe pressure the rig measured")
     p_hy.add_argument("--workspace", type=str, default=None)
     p_hy.add_argument("--well", type=str, default=None)
@@ -2598,6 +2615,39 @@ def main(argv=None) -> int:
             raise SystemExit(f"decline: {e.args[0] if e.args else e}")
         print(_json.dumps(r, default=str) if a.json else _DCA.text(r))
         return 0
+    elif a.cmd == "casing":
+        import json as _json
+        from . import casing_design as _CSG
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace) if a.workspace else None
+            scene = "example" if (a.example or ws is None) else "workspace"
+            keys_ = {"td": "td_md_ft", "td_hole": "td_hole_in", "td_mw": "td_mw_ppg", "pp": "pp_ppg", "fg": "fg_ppg", "kick": "kick_intensity_ppg",
+                     "gas": "gas_gradient_psi_ft", "backup": "backup_gradient_psi_ft", "evacuation": "evacuation", "df_burst": "df_burst",
+                     "df_collapse": "df_collapse", "df_tension": "df_tension", "overpull": "overpull_klbf", "bha_od": "bha_od_in",
+                     "bha_length": "bha_length_ft", "dp_od": "dp_od_in"}
+            vals_ = {v: getattr(a, k) for k, v in keys_.items() if getattr(a, k) is not None}
+            if ws is not None and (vals_ or a.strings is not None):
+                if not a.well:
+                    raise ValueError("--well is needed")
+                c_ = _CSG.set_well(ws, a.actor, a.well, a.source, a.strings, **vals_)
+                print(f"{a.well}: {len(c_.get('strings') or [])} string(s): {_CSG.strings_text(c_.get('strings') or []) or 'none declared'}")
+                return 0
+            if a.write:
+                if ws is None:
+                    raise ValueError("--write needs --workspace")
+                r_ = _CSG.write_report(ws, __version__, a.well, a.actor, scene)
+                print(f"wrote {r_['report_id']}: {r_['paths']['html']}")
+                if r_['paths'].get('pdf'):
+                    print(f"  printable: {r_['paths']['pdf']}")
+                return 0
+            r = _CSG.page(ws, scene, a.well)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"casing: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _CSG.text(r))
+        return 0
     elif a.cmd == "hydraulics":
         import json as _json
         from . import hydraulics as _HYD
@@ -3226,7 +3276,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.59.0 → gea_program-0.61.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)
@@ -13057,7 +13058,7 @@ def section_db_declarations_engineering(tmp: str) -> None:
     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),
+        "planned": not p1["errors"] and p1["counts"]["NEW"] == 10 and p1["counts"]["CHANGE"] == 0 and sorted({s["table"] for s in p1["steps"]}) == sorted(set(DC.ENG_ORDER) - {"casing_design", "casing_loads"}),   # the casing tables: section DD
         "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
@@ -13138,6 +13139,393 @@ def section_db_declarations_engineering(tmp: str) -> None:
        + (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 section_dd_casing_design(tmp: str) -> None:
+    """Section DD - casing design and kick tolerance: each string's ratings by API TR 5C3 as API's tables give them, in
+    every collapse regime and reduced under tension; the burst, collapse and tension loads and the smallest safety factor
+    against the design factor, worked by hand on the example; the kick tolerance below each shoe; the program declared
+    from the tab, the command line and the declarations sheet, read on the survey or the recorder's own TVD, written,
+    in the dossier; an interval declared in measured depth converted on the survey or the recorder's TVD."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.error
+    import urllib.request
+    import zipfile as _zf
+    from . import __version__ as _ver
+    from . import casing_design as CSG
+    from . import declarations as DC
+    from . import dossier as DZ
+    from . import edr as E
+    from . import helplib as H
+    from . import hydraulics as HY
+    from . import interval as IV
+    from . import well3d as W
+    from .service import Service, Users
+    from .workspace import Workspace
+    pkg = Path(__file__).parent
+
+    # -- DD1 the ratings -------------------------------------------------------------------------------------------------------
+    def one(od, ppf, grade, **kw):
+        return CSG.check_strings([{"what": "x", "od_in": od, "weight_lbft": ppf, "grade": grade, "top_md_ft": 0, "shoe_md_ft": 1000, "hole_in": 26, "mw_ppg": 9, **kw}])[0]
+    table = [("9-5/8", 47, "N80", 6870, 4750, "plastic", 1086), (7, 29, "P110", 11220, 8530, "plastic", 929), ("13-3/8", 54.5, "J55", 2730, 1130, "transition", 853),
+             (20, 94, "J55", 2110, 520, "elastic", 1481), ("9-5/8", 40, "N80", 5750, 3090, "transition", 916)]
+    rated = [(one(od, w_, g), b, c, reg, by) for od, w_, g, b, c, reg, by in table]
+    thick = CSG.collapse(5.0, 0.5, 110000.0)                     # D/t 10: the yield regime, 2 Yp (D/t - 1) / (D/t)^2
+    ya0, ya1, ya2 = CSG.reduced_yield(80000.0, 0.0), CSG.reduced_yield(80000.0, 20000.0), CSG.reduced_yield(80000.0, 40000.0)
+
+    def refused(rows):
+        try:
+            CSG.check_strings(rows)
+            return ""
+        except ValueError as e:
+            return str(e)
+    base = {"what": "s", "od_in": "9-5/8", "weight_lbft": 47, "grade": "N80", "top_md_ft": 0, "shoe_md_ft": 5000, "hole_in": 12.25, "mw_ppg": 10}
+    m_grade = refused([{**base, "grade": "X99"}])
+    m_size = refused([{**base, "weight_lbft": 41.3}])
+    m_wall = refused([{**base, "wall_in": 0.3}])
+    m_drift = refused([{**base, "what": "a", "od_in": 7, "weight_lbft": 29, "shoe_md_ft": 3000, "hole_in": 8.5}, {**base, "what": "b"}])
+    try:
+        CSG.parse_strings("surface:13-3/8:54.5:J55")
+        m_parse = ""
+    except ValueError as e:
+        m_parse = str(e)
+    c1 = {
+        "api_tables": all(s["burst_psi"] == b and s["collapse_psi"] == c and s["collapse_regime"] == reg and abs(s["body_yield_klbf"] - by) <= 1.0
+                          for s, b, c, reg, by in rated),
+        "yield_regime": thick[1] == "yield" and abs(thick[0] - 2 * 110000.0 * 9.0 / 100.0) < 1e-6,
+        "sizes": CSG.size_in("9-5/8") == 9.625 and CSG.size_in("13 3/8") == 13.375 and CSG.size_in(7) == 7.0 and rated[0][0]["wall_in"] == 0.472
+                 and rated[0][0]["id_in"] == 8.681,
+        "tension": ya0 == 80000.0 and ya0 > ya1 > ya2 and CSG.collapse_with_tension(9.625, 0.472, 80000.0, 20000.0) < 4750.0
+                   and CSG.reduced_yield(80000.0, -20000.0) == 80000.0,
+        "answered": "the grade is one of" in m_grade and "not in the program's table" in m_size and "weighs about" in m_wall
+                    and "does not pass through" in m_drift and "what:od:weight:grade:top-shoe:hole:mw" in m_parse,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DD1 the ratings by API TR 5C3 as API's tables give them - 9-5/8 in 47 lb/ft N80 6,870 psi burst, 4,750 collapse, 1,086 klbf body; 7 in 29 "
+       "P110 11,220 and 8,530; 13-3/8 in 54.5 J55 2,730 and 1,130 (transition); 20 in 94 J55 520 (elastic); 9-5/8 in 40 N80 3,090 (transition); a "
+       "D/t of 10 in the yield regime - the collapse reduced under tension and not raised by compression; a grade, a size, a wall that does not "
+       "match its weight, a string that does not pass through the one above and a short line each answered" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- DD2 the loads and the kick tolerance, by hand on the example -------------------------------------------------------------------
+    ex = CSG.example()
+    sv, iv_, pv = ex["strings"]
+    win = CSG.EXAMPLE_WINDOW
+
+    def at(key, z):
+        return float(np.interp(z, win["tvd_ft"], win[key]))
+    # surface string: gas from the pore pressure at the intermediate shoe (7,000 ft), held by the fracture pressure at 1,500 ft
+    p_res, p_frac = 0.052 * at("pp_ppg", 7000.0) * 7000.0, 0.052 * at("fg_ppg", 1500.0) * 1500.0
+    top_in = min(p_res - 0.1 * 7000.0, p_frac - 0.1 * 1500.0)
+    sf_b_top = 2730.0 / top_in
+    sf_c_shoe = 1130.0 / (0.052 * 9.0 * 1500.0)
+    sf_t = 853.2 / ((1 - 9.0 / 65.5) * 54.5 * 1500.0 / 1000.0)
+    k0 = ex["kicks"][0]
+    maasp = 0.052 * (at("fg_ppg", 1500.0) - 9.8) * 1500.0
+    sidpp = 0.052 * 0.5 * 7000.0
+    hgt = (maasp - sidpp) / (0.052 * 9.8 - 0.1)
+    v_bot = hgt * (12.25 ** 2 - 6.5 ** 2) / 1029.4
+    v_shoe = hgt * (12.25 ** 2 - 5.0 ** 2) / 1029.4 * p_frac / (0.052 * 10.3 * 7000.0)
+    weak = {**CSG.DEFAULTS, "strings": CSG.check_strings([{**base, "what": "9-5/8 in J55 36 lb/ft", "weight_lbft": 36, "grade": "J55", "shoe_md_ft": 7000, "mw_ppg": 10}]),
+            "td_md_ft": 10000.0, "td_hole_in": 8.5, "td_mw_ppg": 12.0, "bha_od_in": 6.5, "bha_length_ft": 600.0, "dp_od_in": 5.0}
+    rw = CSG.analyse(weak, lambda md: float(md), win)
+    no_fg = CSG.analyse({**weak, "strings": weak["strings"]}, lambda md: float(md), {"pp_const": 9.0, "fg_const": None})
+    c2 = {
+        "burst": abs(sv["rows"][0]["burst_net_psi"] - top_in) <= 1.0 and sv["rows"][0]["burst_limited_by_shoe"] and abs(sv["rows"][0]["sf_burst"] - sf_b_top) < 0.005,
+        "collapse": abs(sv["rows"][-1]["sf_collapse"] - sf_c_shoe) < 0.005 and sv["rows"][-1]["collapse_rating_psi"] == 1130,
+        "tension": abs(sv["checks"]["tension"]["sf"] - sf_t) < 0.01 and sv["checks"]["tension"]["ok"],
+        "least": sv["checks"]["burst"]["sf"] == min(r_["sf_burst"] for r_ in sv["rows"] if r_["sf_burst"]) and ex["ok"],
+        "kick": abs(k0["maasp_psi"] - maasp) <= 1 and abs(k0["height_ft"] - hgt) < 0.5 and abs(k0["volume_at_bottom_bbl"] - v_bot) < 0.15
+                and abs(k0["volume_shoe_as_bottom_bbl"] - v_shoe) < 0.15 and k0["volume_bbl"] == min(k0["volume_at_bottom_bbl"], k0["volume_shoe_as_bottom_bbl"]),
+        "weak": not rw["ok"] and not rw["strings"][0]["checks"]["burst"]["ok"] and not rw["strings"][0]["checks"]["collapse"]["ok"],
+        "no_fg": no_fg["kicks"][0]["status"] == "NOT KNOWN" and "fracture gradient at the shoe" in no_fg["kicks"][0]["detail"],
+        "production": pv["below"] is None and "at the shoe" in pv["burst_case"],
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "DD2 the worked example by hand: the surface string's burst load at the top is gas from the pore pressure at the next shoe held to the fracture "
+       "pressure at its own shoe, the collapse at its shoe the 9.0 ppg mud against an empty string, the tension its buoyed weight; the smallest "
+       "safety factor where it falls; the kick tolerance below it MAASP, SIDPP, the bubble's height and its volume at the bottom and at the shoe "
+       "carried back by Boyle's law, the smaller; a 36 lb/ft J55 string at 7,000 ft below its design factors in burst and collapse; no fracture "
+       "gradient, no kick tolerance - said so" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- DD3 a well: declared three ways, read on its survey or the recorder's TVD, written, in the dossier ----------------------------------
+    d = Path(tmp, "casing"); d.mkdir()
+    hy = HY.selftest_files(str(d / "hy"))
+    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(hy["record"], display="HY-2", actor="tester")["id"]
+    W.attach_trajectory(ws, w1, "s.csv", Path(hy["survey"]).read_bytes(), "tester", "true", "ft", None, None, None, "test survey")
+    for wid in (w2,):
+        out = Path(ws.reports_dir, "wells", wid); out.mkdir(parents=True, exist_ok=True)
+        E.write_record(E.read(hy["record"]), str(out), _ver)
+    prog = "surface:13-3/8:54.5:J55:0-1500:17.5:9.0; intermediate:9-5/8:47:N80:0-6000:12.25:10"
+    cli = _sp.run([sys.executable, "-m", "gea", "casing", "--workspace", wsp, "--well", w1, "--strings", prog, "--td", "10000", "--td-hole", "8-1/2", "--td-mw", "11",
+                   "--pp", "9.5", "--fg", "14.5", "--bha-od", "6.75", "--bha-length", "400", "--dp-od", "5", "--source", "drilling program (test)"],
+                  capture_output=True, text=True, cwd=str(pkg.parent))
+    p1 = CSG.page(ws, "workspace", w1)
+    r1 = p1["result"]
+    sheet = d / "sheet.csv"
+    cols_d, cols_l = DC.TABLES["casing_design"]["cols"], DC.TABLES["casing_loads"]["cols"]
+    rows = [["[casing_design]", *cols_d], ["", "HY-2", "surface", "13-3/8", "54.5", "J55", "0", "1500", "17.5", "9.0", "", "casing tally (test)"],
+            ["", "HY-2", "intermediate", "9.625", "47", "N80", "0", "6000", "12.25", "10", "", "casing tally (test)"],
+            ["[casing_loads]", *cols_l], ["", "HY-2", "10000", "8.5", "11", "9.5", "14.5", "0.5", "", "", "", "", "", "", "", "6.75", "400", "5", "drilling program (test)"]]
+    import csv as _csv
+    import io as _io
+    buf = _io.StringIO(); _csv.writer(buf).writerows(rows); sheet.write_text(buf.getvalue(), encoding="utf-8")
+    pl = DC.apply(ws, sheet.read_text(encoding="utf-8"), "tester", str(d))
+    pw = DC.apply(ws, sheet.read_text(encoding="utf-8"), "tester", str(d), write=True)
+    again = DC.apply(ws, sheet.read_text(encoding="utf-8"), "tester", str(d))
+    tmpl = DC.apply(ws, DC.template(ws), "tester", str(d))
+    bad = sheet.read_text(encoding="utf-8").replace(",N80,", ",X99,")
+    pb = DC.apply(ws, bad, "tester", str(d), write=True)
+    p2 = CSG.page(ws, "workspace", w2)
+    r2 = p2["result"]
+    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_g, g = call("GET", f"/api/casing-design?well={w1}")
+        st_ex, gx = call("GET", "/api/casing-design?scene=example")
+        st_s, sset = call("POST", "/api/casing-design/settings", {"well_id": w1, "df_burst": "1.2", "source": "drilling program rev 2 (test)"})
+        st_bad, sbad = call("POST", "/api/casing-design/settings", {"well_id": w1, "strings": "surface:13-3/8:54.5:X99:0-1500:17.5:9", "source": "x"})
+        st_w, wr = call("POST", "/api/casing-design/write", {"well_id": w1})
+    finally:
+        svc.stop()
+    cli_ex = _sp.run([sys.executable, "-m", "gea", "casing", "--example"], capture_output=True, text=True, cwd=str(pkg.parent))
+    dz = DZ.build(ws, "tester", _ver, None)
+    with _zf.ZipFile(Path(ws.reports_dir, dz["path"])) as z_:
+        names = set(z_.namelist())
+    rep_json = json.loads(Path(ws.reports_dir, "wells", w1, "casing_design.json").read_text(encoding="utf-8"))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c3 = {
+        "cli": cli.returncode == 0 and "2 string(s)" in cli.stdout,
+        "survey": r1 and r1["path_from"] == "survey" and r1["strings"][1]["shoe_tvd_ft"] < 6000.0 - 100.0 and len(r1["kicks"]) == 2
+                  and r1["kicks"][1]["bottom_md_ft"] == 10000.0 and r1["kicks"][1].get("volume_bbl") is not None,
+        "sheet": not pl["errors"] and [s_["action"] for s_ in pl["steps"] if s_["table"] in ("casing_design", "casing_loads")] == ["NEW", "NEW"]
+                 and pw["applied"] and not again["errors"] and again["counts"]["NEW"] == 0 and again["counts"]["CHANGE"] == 0
+                 and not tmpl["errors"] and tmpl["counts"]["NEW"] == 0 and tmpl["counts"]["CHANGE"] == 0,
+        "sheet_bad": bool(pb["errors"]) and any("[casing_design]" in e and "the grade is one of" in e for e in pb["errors"]) and not pb["written"],
+        "recorder": r2 and r2["path_from"] == "recorder" and "not a survey" in r2["path_how"] and abs(r2["strings"][1]["shoe_tvd_ft"] - r1["strings"][1]["shoe_tvd_ft"]) < 40.0,
+        "api": st_g == 200 and g["result"]["well"] == w1 and st_ex == 200 and gx["scene"] == "example" and st_s == 200 and sset["df_burst"] == 1.2
+               and st_bad == 400 and "the grade is one of" in sbad.get("error", "") and st_w == 200 and wr["report_id"].startswith("CSG-")
+               and rep_json["config"]["df_burst"] == 1.2,
+        "example_cli": cli_ex.returncode == 0 and "6,870 psi" in cli_ex.stdout and "kick tolerance below" in cli_ex.stdout,
+        "dossier": "declarations/drillstring/casing_design.json" in names and f"results/casing_design/{w1}.json" in names,
+        "page_help": "['#/casing', 'Casing & kick tolerance']" in page_src and "VIEWS.casing = async" in page_src and not H.check("casing")
+                     and any(t["topic"] == "casing" for t in H.topics()) and "[casing_design]" in (H.page("declare") or ""),
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "DD3 a well's casing program declared from the command line, the API and the declarations sheet (planned NEW, written, then SAME, and from "
+       "the template; a bad grade answered with its row, nothing written); read on its survey, or on the drilling recorder's own TVD for a well with "
+       "none, said so; the kick tolerance of each open hole to TD; the report written (CSG-...); the dossier carries the declarations and the "
+       "result; the tab, the help and the sheet's tables" + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- DD4 an interval declared in measured depth -----------------------------------------------------------------------------------------
+    base_w = {"id": "w", "surface": {"lat": 1.0, "lon": 1.0, "elevation": {"ft": 2950.0, "datum": "KB", "source": "report"}},
+              "disposal": {"top_interval_ft": 7000.0, "base_interval_ft": 7600.0, "depth_reference": "MD"}}
+    path1, path2 = HY.depth_path(ws, w1), HY.depth_path(ws, w2)
+    s1 = IV.statement(base_w, {"status": "OK", "layers": []}, [], None, path1)
+    s2 = IV.statement(base_w, {"status": "OK", "layers": []}, [], None, path2)
+    s3 = IV.statement({**base_w, "disposal": {**base_w["disposal"], "base_interval_ft": 30000.0}}, {"status": "OK", "layers": []}, [], None, path1)
+    tv_top = HY.tvd_at(path1, 7000.0)
+    c4 = {
+        "survey": path1["from"] == "survey" and s1["declared"]["depth_reference"] == "TVD" and abs(s1["declared"]["top_ft"] - tv_top) < 0.2
+                  and s1["declared"]["top_ft"] < 7000.0 - 500.0 and s1["declared"]["converted_from_md"]["top_md_ft"] == 7000.0
+                  and any("converted to" in n and "survey" in n for n in s1["notes"]) and abs(s1["declared"]["top_subsea_ft"] - (2950.0 - s1["declared"]["top_ft"])) < 0.2,
+        "recorder": path2["from"] == "recorder" and abs(s2["declared"]["top_ft"] - s1["declared"]["top_ft"]) < 40.0 and any("not a survey" in n for n in s2["notes"]),
+        "beyond": s3["status"] == "NOT RESOLVED" and "reaches" in s3["lines"][0],
+        "help": "converted on the well's survey" in (H.page("interval") or ""),
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "DD4 an interval declared in measured depth is converted to true vertical depth on the well's survey, or the drilling recorder's own TVD for a "
+       "well with none (within 40 ft of the survey's), each said so in the statement; an interval deeper than the depth table reaches stays NOT "
+       "RESOLVED and says how far it reaches" + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
 def PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -13255,6 +13643,8 @@ def main() -> int:
         section_cz_it_review(tmp)
         section_da_hydraulics(tmp)
         section_db_declarations_engineering(tmp)
+        section_dc_every_tab(tmp)
+        section_dd_casing_design(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: