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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.59.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
@@ -673,6 +673,16 @@ 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.59.0 → gea_program-0.60.0}/README.md

@@ -634,6 +634,16 @@ 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.59.0 → gea_program-0.60.0}/gea/__init__.py

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

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

@@ -3226,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.59.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)
@@ -13138,6 +13139,177 @@ 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 PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -13255,6 +13427,7 @@ def main() -> int:
         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:

{gea_program-0.59.0 → gea_program-0.60.0}/gea/dashboard.py

@@ -63,6 +63,9 @@ def collect(out_dir: str) -> dict:
                 continue
             meta = _load(os.path.join(d, 'well.json')) or {}
             w = {'name': meta.get('display', name), 'slug': name, 'dir': d, 'source': meta.get('source', '')}
+            rf = _load(os.path.join(d, 'refresh_failed.json'))
+            if rf or meta.get('ingest_failed'):                   # a well whose reports could not be written is shown, with why
+                w['failed'] = (rf or {}).get('reason') or meta.get('ingest_failed')
             gd = _load(os.path.join(d, 'gauge_drift_report.json'))
             if gd:
                 ev = gd.get('evaluation', {})
@@ -157,6 +160,8 @@ def _sev(cls: str) -> int:
 
 def _drift_status(w: dict) -> tuple:
     d = w.get('drift')
+    if not d and w.get('failed'):
+        return 'critical', 'NOT REPORTED - ' + str(w['failed'])[:160]
     if not d:
         if w.get('drilling'):
             dl = w['drilling']
@@ -369,142 +374,158 @@ def orchestrate(out_dir: str, catalog_wells: List[dict], file_wells: List[dict],
         name = f"{cw['entry']}__{cw['well']}".replace('/', '-')
         d = os.path.join(out_dir, 'wells', name)
         os.makedirs(d, exist_ok=True)
-        stream, smap = production_live_stream(cw['entry'], cw['well'], cw['md_ft'])
-        with open(os.path.join(d, 'well.json'), 'w', encoding='utf-8') as f:
-            json.dump({'display': cw['well'], 'source': f"{cw['entry']} (station MD {cw['md_ft']:g} ft, caller-supplied)"}, f)
-        ms = None
-        if monitor_root:
-            mon = DriftMonitor(cfg, os.path.join(monitor_root, name), well_name=cw['well'])
-            r = mon.run_scheduled(stream, station_map=smap, force=True)
-            ev = r['evaluation']
-            ms = mon.status(); ms['history'] = mon.history(); ms['change_log'] = mon.change_log()
-        else:
-            ev = Reconciler(cfg).reconcile(stream, station_map=smap)
-        write(gauge_drift_report(ev, stream, well_name=cw['well'], program_version=_v, gauge_spec=gauge_spec, monitor_status=ms), d)
-        made.setdefault(name, []).append('drift')
-        crit = load_criteria(criteria_path)
-        src = CATALOG[cw['entry']].stream()
-        det = WellTestValidator(crit, volve_channel_map(cw['well'])).detect(src)
-        trail = ApprovalTrail(os.path.join(d, 'well_test_records'), levels=crit.get('approval_levels'))
-        write(well_test_report(det, approvals=trail, well_name=cw['well'], program_version=_v), d, basename='well_test_validation')
-        made[name].append('well_tests')
+        if os.path.exists(os.path.join(d, 'refresh_failed.json')):
+            os.remove(os.path.join(d, 'refresh_failed.json'))
+        try:
+            stream, smap = production_live_stream(cw['entry'], cw['well'], cw['md_ft'])
+            with open(os.path.join(d, 'well.json'), 'w', encoding='utf-8') as f:
+                json.dump({'display': cw['well'], 'source': f"{cw['entry']} (station MD {cw['md_ft']:g} ft, caller-supplied)"}, f)
+            ms = None
+            if monitor_root:
+                mon = DriftMonitor(cfg, os.path.join(monitor_root, name), well_name=cw['well'])
+                r = mon.run_scheduled(stream, station_map=smap, force=True)
+                ev = r['evaluation']
+                ms = mon.status(); ms['history'] = mon.history(); ms['change_log'] = mon.change_log()
+            else:
+                ev = Reconciler(cfg).reconcile(stream, station_map=smap)
+            write(gauge_drift_report(ev, stream, well_name=cw['well'], program_version=_v, gauge_spec=gauge_spec, monitor_status=ms), d)
+            made.setdefault(name, []).append('drift')
+            crit = load_criteria(criteria_path)
+            src = CATALOG[cw['entry']].stream()
+            det = WellTestValidator(crit, volve_channel_map(cw['well'])).detect(src)
+            trail = ApprovalTrail(os.path.join(d, 'well_test_records'), levels=crit.get('approval_levels'))
+            write(well_test_report(det, approvals=trail, well_name=cw['well'], program_version=_v), d, basename='well_test_validation')
+            made[name].append('well_tests')
+        except Exception as ex:                                   # one well that cannot be read never blocks the other wells' reports
+            with open(os.path.join(d, 'refresh_failed.json'), 'w', encoding='utf-8') as f:
+                json.dump({'well': name, 'entry': cw.get('entry'), 'reason': f'{type(ex).__name__}: {ex}',
+                           'evaluated_at_utc': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}, f, indent=1)
+            made.setdefault(name, []).append('refresh_failed')
     for fw in file_wells:
         name = fw.get('name') or os.path.splitext(os.path.basename(fw['path']))[0]
         d = os.path.join(out_dir, 'wells', name)
         os.makedirs(d, exist_ok=True)
-        from .files import read_any
+        if os.path.exists(os.path.join(d, 'refresh_failed.json')):
+            os.remove(os.path.join(d, 'refresh_failed.json'))
         try:
-            stream = read_any(fw['path'])
-        except Exception as ex:                                   # one unreadable file never blocks the other wells' reports
-            with open(os.path.join(d, 'well.json'), 'w', encoding='utf-8') as f:
-                json.dump({'display': name, 'source': fw['path'], 'ingest_failed': f'{type(ex).__name__}: {ex}'}, f)
-            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, 'source_format': stream.source_format}, f)
-        cache_dir = os.path.join(series_cache_root, name) if series_cache_root else None
-        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, cache_dir=cache_dir)
-                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 cache_dir:
+            from .files import read_any
             try:
-                from . import series_cache as _SCH
-                _SCH.build(stream, cache_dir)
-            except Exception:
-                pass                                              # the cache is a convenience; the page builds it on first view
-        if stream.index_kind != 'time_s':                      # a depth log is a survey input: run the strata survey, not the gauge pipeline
+                stream = read_any(fw['path'])
+            except Exception as ex:                                   # one unreadable file never blocks the other wells' reports
+                with open(os.path.join(d, 'well.json'), 'w', encoding='utf-8') as f:
+                    json.dump({'display': name, 'source': fw['path'], 'ingest_failed': f'{type(ex).__name__}: {ex}'}, f)
+                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, 'source_format': stream.source_format}, f)
+            cache_dir = os.path.join(series_cache_root, name) if series_cache_root else None
+            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, cache_dir=cache_dir)
+                    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 cache_dir:
+                try:
+                    from . import series_cache as _SCH
+                    _SCH.build(stream, cache_dir)
+                except Exception:
+                    pass                                              # the cache is a convenience; the page builds it on first view
+            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
+                    txt, machine = run_survey(path=fw['path'])
+                    with open(os.path.join(d, 'survey_report.txt'), 'w', encoding='utf-8') as f:
+                        f.write(txt)
+                    with open(os.path.join(d, 'survey.json'), 'w', encoding='utf-8') as f:
+                        json.dump(machine, f, indent=1, default=str)
+                    made.setdefault(name, []).append('survey')
+                except Exception as ex:
+                    with open(os.path.join(d, 'survey_not_run.json'), 'w', encoding='utf-8') as f:
+                        json.dump({'well': name, 'reason': f'{type(ex).__name__}: {ex}', 'index_kind': stream.index_kind}, f, indent=1)
+                    made.setdefault(name, []).append('survey_not_run')
+                continue
+            cat = TagCatalogue.from_stream(stream, gauge_spec=gauge_spec)
+            # instruments: swaps segment the fit; certificates print beside the bias (Band 2)
+            inst = None
+            rdir = fw.get('records_dir')
+            fit_stream = stream
+            if rdir and os.path.isdir(rdir):
+                from .sensor_swap import SwapRegister, segment_mask, detect_swaps
+                from .certificates import CertificateRegister
+                reg = SwapRegister(os.path.join(rdir, 'sensor_swaps.jsonl'))
+                fit_stream, notes = segment_mask(stream, reg)
+                latest = reg.latest_by_tag()
+                certs = CertificateRegister(os.path.join(rdir, 'certificates.jsonl'))
+                ptags = [c for c in stream.channels if c.lower().startswith('p_')]
+                cert_rows = certs.status(ptags, serial_by_tag={k: v['new_serial'] for k, v in latest.items()}) if certs.list() else []
+                try:
+                    def _unrecorded(c):
+                        for tg in [c['tag_id']] + [x.strip() for x in (c.get('ambiguous_with') or '').split(',') if x.strip()]:
+                            e = latest.get(tg)
+                            if e and abs(_epoch_s(e['swap_utc']) - _epoch_s(c.get('swap_utc'))) <= 2 * 3600 * 24:
+                                return False                       # this step is explained by a recorded swap (on it or on its ambiguous peer)
+                        return True
+                    cands = [c for c in detect_swaps(stream) if _unrecorded(c)]
+                except Exception:
+                    cands = []
+                inst = {'swaps': reg.list(), 'swap_notes': notes, 'certificates': cert_rows, 'candidates': cands[:10],
+                        'certificate_summary': CertificateRegister.summary(cert_rows) if cert_rows else None}
+                with open(os.path.join(d, 'instruments.json'), 'w', encoding='utf-8') as f:
+                    json.dump(inst, f, indent=1, default=str)
             try:
-                from .survey_cmd import run_survey
-                txt, machine = run_survey(path=fw['path'])
-                with open(os.path.join(d, 'survey_report.txt'), 'w', encoding='utf-8') as f:
-                    f.write(txt)
-                with open(os.path.join(d, 'survey.json'), 'w', encoding='utf-8') as f:
-                    json.dump(machine, f, indent=1, default=str)
-                made.setdefault(name, []).append('survey')
-            except Exception as ex:
-                with open(os.path.join(d, 'survey_not_run.json'), 'w', encoding='utf-8') as f:
-                    json.dump({'well': name, 'reason': f'{type(ex).__name__}: {ex}', 'index_kind': stream.index_kind}, f, indent=1)
-                made.setdefault(name, []).append('survey_not_run')
-            continue
-        cat = TagCatalogue.from_stream(stream, gauge_spec=gauge_spec)
-        # instruments: swaps segment the fit; certificates print beside the bias (Band 2)
-        inst = None
-        rdir = fw.get('records_dir')
-        fit_stream = stream
-        if rdir and os.path.isdir(rdir):
-            from .sensor_swap import SwapRegister, segment_mask, detect_swaps
-            from .certificates import CertificateRegister
-            reg = SwapRegister(os.path.join(rdir, 'sensor_swaps.jsonl'))
-            fit_stream, notes = segment_mask(stream, reg)
-            latest = reg.latest_by_tag()
-            certs = CertificateRegister(os.path.join(rdir, 'certificates.jsonl'))
-            ptags = [c for c in stream.channels if c.lower().startswith('p_')]
-            cert_rows = certs.status(ptags, serial_by_tag={k: v['new_serial'] for k, v in latest.items()}) if certs.list() else []
+                ev = Reconciler(cfg).reconcile(fit_stream)
+                write(gauge_drift_report(ev, stream, catalogue=cat, well_name=name, program_version=_v, gauge_spec=gauge_spec, instruments=inst), d)
+                made.setdefault(name, []).append('drift')
+            except ValueError as e:                                  # a stream with no downhole gauge stations (a drill-floor feed): drift does not apply
+                with open(os.path.join(d, 'drift_not_applicable.json'), 'w', encoding='utf-8') as f:
+                    json.dump({'well': name, 'reason': str(e), 'channels': list(stream.channels), 'evaluated_at_utc': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}, f, indent=1)
+                made.setdefault(name, []).append('drift_not_applicable')
+            # shut-ins and the build-up analyses (Band 2): criteria and parameters from the records folder when present
             try:
-                def _unrecorded(c):
-                    for tg in [c['tag_id']] + [x.strip() for x in (c.get('ambiguous_with') or '').split(',') if x.strip()]:
-                        e = latest.get(tg)
-                        if e and abs(_epoch_s(e['swap_utc']) - _epoch_s(c.get('swap_utc'))) <= 2 * 3600 * 24:
-                            return False                       # this step is explained by a recorded swap (on it or on its ambiguous peer)
-                    return True
-                cands = [c for c in detect_swaps(stream) if _unrecorded(c)]
-            except Exception:
-                cands = []
-            inst = {'swaps': reg.list(), 'swap_notes': notes, 'certificates': cert_rows, 'candidates': cands[:10],
-                    'certificate_summary': CertificateRegister.summary(cert_rows) if cert_rows else None}
-            with open(os.path.join(d, 'instruments.json'), 'w', encoding='utf-8') as f:
-                json.dump(inst, f, indent=1, default=str)
-        try:
-            ev = Reconciler(cfg).reconcile(fit_stream)
-            write(gauge_drift_report(ev, stream, catalogue=cat, well_name=name, program_version=_v, gauge_spec=gauge_spec, instruments=inst), d)
-            made.setdefault(name, []).append('drift')
-        except ValueError as e:                                  # a stream with no downhole gauge stations (a drill-floor feed): drift does not apply
-            with open(os.path.join(d, 'drift_not_applicable.json'), 'w', encoding='utf-8') as f:
-                json.dump({'well': name, 'reason': str(e), 'channels': list(stream.channels), 'evaluated_at_utc': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}, f, indent=1)
-            made.setdefault(name, []).append('drift_not_applicable')
-        # shut-ins and the build-up analyses (Band 2): criteria and parameters from the records folder when present
-        try:
-            from .shut_in import detect_shut_ins, extract_buildup, load_criteria as _si_crit
-            from .transient import analyze_buildup
-            from .client_reports import transient_report
-            si_c = _si_crit(os.path.join(rdir, 'shut_in.json') if rdir else None)
-            det = detect_shut_ins(stream, criteria=si_c)
-            prm = None
-            if rdir and os.path.isfile(os.path.join(rdir, 'transient_params.json')):
-                with open(os.path.join(rdir, 'transient_params.json'), encoding='utf-8') as f:
-                    prm = json.load(f)
-            analyses = []
-            for si in [x for x in det['shut_ins'] if x['qualified']][:6]:
-                b = extract_buildup(stream, si)
-                a = analyze_buildup(b['dt_h'], b['p_ws'], b['tp_h'], b['p_wf'], prm)
-                a['shut_in_id'] = si['shut_in_id']
-                analyses.append(a)
-            if det['shut_ins']:
-                write(transient_report(det, analyses, well_name=name, program_version=_v), d, basename='pressure_transient_report')
-                made.setdefault(name, []).append('transient')
-            else:
-                with open(os.path.join(d, 'shut_ins.json'), 'w', encoding='utf-8') as f:
-                    json.dump(det, f, indent=1, default=str)
-        except Exception as ex:                                      # the transient look is additional; it never blocks the alarms
-            with open(os.path.join(d, 'transient_not_run.json'), 'w', encoding='utf-8') as f:
-                json.dump({'well': name, 'reason': f'{type(ex).__name__}: {ex}'}, f, indent=1)
-        recs = records_from_stream(stream, cat)
-        eng = AlarmEngine(defaults_from_catalogue(cat), event_log_path=os.path.join(d, 'alarm_events.jsonl'))
-        eng.process(recs)
-        write(alarm_event_report(eng, well_name=name, program_version=_v), d, basename='alarm_event_report')
-        made[name].append('alarms')
-        if outages:
-            cad = next((t.cadence_s for t in cat.tags.values() if t.cadence_s), 60.0)
-            sim = simulate([r for r in recs if r.tag_id.startswith('P_raw')], parse_outages(outages), BufferConfig(cadence_s=cad))
-            write(data_resilience_report(sim, site_name=name, program_version=_v), d, basename='data_resilience_report')
-            made[name].append('resilience')
+                from .shut_in import detect_shut_ins, extract_buildup, load_criteria as _si_crit
+                from .transient import analyze_buildup
+                from .client_reports import transient_report
+                si_c = _si_crit(os.path.join(rdir, 'shut_in.json') if rdir else None)
+                det = detect_shut_ins(stream, criteria=si_c)
+                prm = None
+                if rdir and os.path.isfile(os.path.join(rdir, 'transient_params.json')):
+                    with open(os.path.join(rdir, 'transient_params.json'), encoding='utf-8') as f:
+                        prm = json.load(f)
+                analyses = []
+                for si in [x for x in det['shut_ins'] if x['qualified']][:6]:
+                    b = extract_buildup(stream, si)
+                    a = analyze_buildup(b['dt_h'], b['p_ws'], b['tp_h'], b['p_wf'], prm)
+                    a['shut_in_id'] = si['shut_in_id']
+                    analyses.append(a)
+                if det['shut_ins']:
+                    write(transient_report(det, analyses, well_name=name, program_version=_v), d, basename='pressure_transient_report')
+                    made.setdefault(name, []).append('transient')
+                else:
+                    with open(os.path.join(d, 'shut_ins.json'), 'w', encoding='utf-8') as f:
+                        json.dump(det, f, indent=1, default=str)
+            except Exception as ex:                                      # the transient look is additional; it never blocks the alarms
+                with open(os.path.join(d, 'transient_not_run.json'), 'w', encoding='utf-8') as f:
+                    json.dump({'well': name, 'reason': f'{type(ex).__name__}: {ex}'}, f, indent=1)
+            recs = records_from_stream(stream, cat)
+            eng = AlarmEngine(defaults_from_catalogue(cat), event_log_path=os.path.join(d, 'alarm_events.jsonl'))
+            eng.process(recs)
+            write(alarm_event_report(eng, well_name=name, program_version=_v), d, basename='alarm_event_report')
+            made[name].append('alarms')
+            if outages:
+                cad = next((t.cadence_s for t in cat.tags.values() if t.cadence_s), 60.0)
+                sim = simulate([r for r in recs if r.tag_id.startswith('P_raw')], parse_outages(outages), BufferConfig(cadence_s=cad))
+                write(data_resilience_report(sim, site_name=name, program_version=_v), d, basename='data_resilience_report')
+                made[name].append('resilience')
+        except Exception as ex:                                   # one well that cannot be reported never blocks the other wells' reports
+            with open(os.path.join(d, 'refresh_failed.json'), 'w', encoding='utf-8') as f:
+                json.dump({'well': name, 'source': fw.get('path'), 'reason': f'{type(ex).__name__}: {ex}',
+                           'evaluated_at_utc': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}, f, indent=1)
+            made.setdefault(name, []).append('refresh_failed')
     write(accuracy_statement_report(library_backtest(), program_version=_v), out_dir, basename='accuracy_statement')
     cards = build_cards()
     for c in cards:

{gea_program-0.59.0 → gea_program-0.60.0}/gea/files.py

@@ -232,6 +232,8 @@ class Roots:
         """An absolute path inside the named root, or WorkspaceError when it would leave it."""
         root = next((r for r in self.list(which) if r['name'] == name), None)
         if root is None:
+            if not name:
+                raise WorkspaceError(f'no {which} root chosen' + ('' if self.list(which) else f': add an {which} root under Administration first'))
             raise WorkspaceError(f'no {which} root named {name}')
         base = os.path.realpath(root['path'])
         full = os.path.realpath(os.path.join(base, rel or ''))

{gea_program-0.59.0 → gea_program-0.60.0}/gea/help/catalog.md

@@ -2,7 +2,7 @@
 
 > The program ships 52 public datasets, each with a provenance sidecar saying where it came from, under what licence, and what it covers. A sidecar does not say what in this program reads the entry; the register does. `gea catalog --list` prints every entry with the bands, commands and reports that take it, or the plain statement that nothing does yet - CARRIED, NO BAND - and the gate holds that register to the code. The Catalogue tab on the dashboard is the world map of them: where each entry was drilled, taken from the entry's own file (a PANGAEA event line, a LAS header, a KTB Gauss-Krueger grid reference unprojected and shifted to WGS84) or from the sidecar's source record, or NO POSITION - nothing is looked up or guessed. 44 of the 52 are positioned, on 33 marks; the 8 that are not are listed with what their files do say. The entries with a use: every LAS log runs through the strata survey; seven measured-friction and strength datasets become the envelope a slip statement discloses its coefficient against; the Volve core checks the published sandstone range.
 
-**The command**: `gea catalog --list` (the register), `--unused` (the carried entries, with the reason), `--check` (every entry read through its own reader, the shape or the error), `--entry volve_f12_f14_production_excerpt --info` (the provenance in full and how it reads), `--entry volve_f12_f14_production_excerpt --stream-csv out.csv` (the entry as a stream file any other command ingests), `--friction` (the measured friction and strength, each with its source, and the envelope against Byerlee's 0.6), `--core` (the Volve 15/9-19 A core plugs against the published sandstone range). `--positions` (where every entry was drilled, how that is known, or NO POSITION), `--map catalogue.svg` (the world map as a file: the Natural Earth 1:110m coastline, one numbered mark per position, the key, the NO POSITION list), `--check-positions` (the sidecars' recorded positions against a fresh read of the files - the gate's check; `tools/catalog_positions.py` rewrites them after a catalogue change). `gea survey --catalog collingwood_1_28_ks_complete` runs the strata survey on any LAS entry - Scorpio E1 (South Australia), University 6-17 (Texas), Kennetcook #2 (Nova Scotia), Collingwood 1-28 (Kansas), L07-01 (Dutch North Sea), 15/9-19 SR (Volve) - and says what it found or why it did not estimate.
+**The command**: `gea catalog --list` (the register), `--unused` (the carried entries, with the reason), `--check` (every entry read through its own reader, the shape or the error), `--entry volve_f12_f14_production_excerpt --info` (the provenance in full and how it reads), `--entry volve_f12_f14_production_excerpt --stream-csv out.csv` (the entry as a stream file any other command ingests), `--friction` (the measured friction and strength, each with its source, and the envelope against Byerlee's 0.6), `--core` (the Volve 15/9-19 A core plugs against the published sandstone range). `--positions` (where every entry was drilled, how that is known, or NO POSITION), `--map catalogue.svg` (the world map as a file: the Natural Earth 1:110m coastline, one numbered mark per position, the key, the NO POSITION list), `--check-positions` (the sidecars' recorded positions against a fresh read of the files - the gate's check; `tools/catalog_positions.py` rewrites them after a catalogue change). `gea survey --catalog collingwood_1_28_ks_complete` runs the strata survey on any LAS entry - Scorpio E1 (South Australia), University 6-17 (Texas), Kennetcook #2 (Nova Scotia), Collingwood 1-28 (Kansas), L07-01 (Dutch North Sea), 15/9-19 SR (Volve) - and says what it found or why it did not estimate. A catalogue well (Wells -> Add a catalogue well, or `gea workspace --path C:\site --action add-catalog --entry volve_f12_f14_production_excerpt --well 15/9-F-12 --station-md 10000`) is added only from an entry that carries a downhole gauge series, naming a well inside it and the gauge depth from the completion records; the form lists only those entries.
 
 **What it writes**: each sidecar's `position` block - status, latitude, longitude, datum, the source line it was read from, and for a Gauss-Krueger reference the grid values, the DHDN position and the shift applied; the map SVG; the register - entry, kind, tier, file size, USED or CARRIED, and each use in the user's terms; the check - 52 of 52 entries read; the friction envelope - friction coefficients 0.21 to 0.90 on 70 measurements from three datasets (ODP Costa Rica, IODP Hikurangi, IODP Nankai), cohesion 188-990 kPa (Sumatra), vane shear 19.5-290 kPa (Barbados), fault-zone peak shear strength 1.7-1.9 MPa at slow slip (JFAST), uniaxial compressive strength 3-265 MPa on crystalline cores (KTB pilot hole) - none from the Permian, and the page says so; the core check - bulk density per plug as grain density x (1 - porosity) + brine x porosity, the brine stated, 65 of 70 Volve plugs inside the published 2.05-2.55 g/cc sandstone range, written into the rock inventory model card's evaluation.