gea-program 0.23.0__tar.gz → 0.25.0__tar.gz

{gea_program-0.23.0/gea_program.egg-info → gea_program-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.23.0
+Version: 0.25.0
 Summary: GEA-Program: downhole gauge monitoring - canonical measurement records, quality rules, drift evaluation with a re-fit change log, well-test validation, alarm management, model cards, store-and-forward, monthly SLA measurement, FAT/SAT protocols and a dashboard, generated from live objects in the client's reporting outline.
 Author: Daniel T. Murphy
 License: MPL-2.0
@@ -125,7 +125,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (356 checks)
+gea accept                     # the product gate (362 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -648,6 +648,37 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### The catalogue accounted for
+
+`gea catalog --list` is the register of the 52 shipped public datasets: for
+each, what in this program reads it, or CARRIED, NO BAND with the reason;
+the gate holds the register to the code both ways and reads every entry.
+`gea survey --catalog <entry>` runs the strata survey on any catalogue log
+with its provenance; `gea catalog --friction` reads seven laboratory
+datasets on natural fault and sediment samples as the measured friction
+envelope (0.21-0.90 on 70 measurements, none from the Permian) against
+Byerlee's 0.6; `gea catalog --core` checks the published sandstone range
+against the Volve core (65 of 70 plugs inside), an evaluation on the rock
+inventory model card. `gea help catalog`.
+
+### The log as delivered, and the historian
+
+A well log arrives as DLIS (API RP66 V1); `gea/dlis.py` reads the container
+as the standard lays it out, with no dependency - the storage unit label,
+visible records, logical record segments and trailers, the sets of objects
+with every representation code, the frames and channels, the frame data -
+and hands the strata survey the same stream the LAS port does: `gea dlis
+--file log.dlis --info` describes it, `--to-las` exports a frame, `gea survey
+--file log.dlis` reads it directly, and the Files page detects it by its
+label. Encrypted records are skipped and named, never decrypted or guessed.
+Proven on a real Schlumberger station log (104 channels, two frames, 3,252
+records in a tenth of a second). The operator's gauge history in a PI System
+comes out through PI Web API (`gea piwebapi`, protocol `piwebapi` on the
+Patch panel): GET only, the archive between two times with its paging
+followed, every value with the archive's timestamp and flags, credentials
+from environment variables the map names. `gea help dlis`, `gea help
+historian`.
+
 ### The field ports
 
 The three links a gauge panel on a pad actually offers, each read-only in

{gea_program-0.23.0 → gea_program-0.25.0}/README.md

@@ -86,7 +86,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (356 checks)
+gea accept                     # the product gate (362 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -609,6 +609,37 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### The catalogue accounted for
+
+`gea catalog --list` is the register of the 52 shipped public datasets: for
+each, what in this program reads it, or CARRIED, NO BAND with the reason;
+the gate holds the register to the code both ways and reads every entry.
+`gea survey --catalog <entry>` runs the strata survey on any catalogue log
+with its provenance; `gea catalog --friction` reads seven laboratory
+datasets on natural fault and sediment samples as the measured friction
+envelope (0.21-0.90 on 70 measurements, none from the Permian) against
+Byerlee's 0.6; `gea catalog --core` checks the published sandstone range
+against the Volve core (65 of 70 plugs inside), an evaluation on the rock
+inventory model card. `gea help catalog`.
+
+### The log as delivered, and the historian
+
+A well log arrives as DLIS (API RP66 V1); `gea/dlis.py` reads the container
+as the standard lays it out, with no dependency - the storage unit label,
+visible records, logical record segments and trailers, the sets of objects
+with every representation code, the frames and channels, the frame data -
+and hands the strata survey the same stream the LAS port does: `gea dlis
+--file log.dlis --info` describes it, `--to-las` exports a frame, `gea survey
+--file log.dlis` reads it directly, and the Files page detects it by its
+label. Encrypted records are skipped and named, never decrypted or guessed.
+Proven on a real Schlumberger station log (104 channels, two frames, 3,252
+records in a tenth of a second). The operator's gauge history in a PI System
+comes out through PI Web API (`gea piwebapi`, protocol `piwebapi` on the
+Patch panel): GET only, the archive between two times with its paging
+followed, every value with the archive's timestamp and flags, credentials
+from environment variables the map names. `gea help dlis`, `gea help
+historian`.
+
 ### The field ports
 
 The three links a gauge panel on a pad actually offers, each read-only in

{gea_program-0.23.0 → gea_program-0.25.0}/gea/__init__.py

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

{gea_program-0.23.0 → gea_program-0.25.0}/gea/__main__.py

@@ -278,6 +278,26 @@ def main(argv=None) -> int:
         p_lp.add_argument("--stream-csv", type=str, default=None, help="also write a historian-style CSV the other commands ingest")
         p_lp.add_argument("--selftest", action="store_true", help="etp: the codec round-trip and a session against the simulated store on the loopback")
 
+    p_cat = sub.add_parser("catalog", help="the shipped catalogue: --list every entry with what reads it; --unused the carried ones; --check reads every entry; --friction the measured friction envelope; --core the core check; --entry X --info | --stream-csv")
+    p_cat.add_argument("--list", action="store_true"); p_cat.add_argument("--unused", action="store_true"); p_cat.add_argument("--check", action="store_true")
+    p_cat.add_argument("--friction", action="store_true"); p_cat.add_argument("--core", action="store_true")
+    p_cat.add_argument("--entry", type=str, default=None); p_cat.add_argument("--info", action="store_true"); p_cat.add_argument("--stream-csv", type=str, default=None)
+    p_cat.add_argument("--json", action="store_true")
+    p_dl = sub.add_parser("dlis", help="a DLIS (RP66 V1) well log: --info describes it (origin, channels, frames, what was skipped); --frame --out writes the frame as a historian-style CSV; --to-las writes LAS 2.0")
+    p_dl.add_argument("--file", type=str, required=True)
+    p_dl.add_argument("--info", action="store_true")
+    p_dl.add_argument("--frame", type=str, default=None, help="the frame to read when the file holds several")
+    p_dl.add_argument("--out", type=str, default=None, help="write the frame's channels as CSV (index first)")
+    p_dl.add_argument("--to-las", type=str, default=None, help="write the frame as a LAS 2.0 file")
+    p_dl.add_argument("--json", action="store_true")
+    p_pi = sub.add_parser("piwebapi", help="the PI Web API historian pull, read-only: --config (base_url, auth by environment variable names, tags with paths); --selftest against the stand-in")
+    p_pi.add_argument("--config", type=str, default=None)
+    p_pi.add_argument("--write-example-config", type=str, default=None)
+    p_pi.add_argument("--out", type=str, default=None, help="write the records CSV here")
+    p_pi.add_argument("--stream-csv", type=str, default=None)
+    p_pi.add_argument("--seconds", type=float, default=None, help="ignored: a pull is one request per tag (kept so the live tap's call shape is the same)")
+    p_pi.add_argument("--record", type=str, default=None, help="write the pull's summary as one JSON line here")
+    p_pi.add_argument("--selftest", action="store_true")
     for name, helptxt in (("modbus-rtu", "Modbus RTU port, read-only: the serial line (pyserial) or RTU over TCP; functions 03/04 only; the stand-in slave with --selftest"),
                           ("dnp3", "DNP3 (IEEE 1815) master, read-only: integrity and event polls over TCP; analog inputs, binaries, counters with flags and event times; the stand-in outstation with --selftest"),
                           ("hartip", "HART-IP client, read-only: session, command 0, 3 and 9; the variables with their unit codes and status; the stand-in device with --selftest")):
@@ -671,8 +691,10 @@ def main(argv=None) -> int:
     p_fl.add_argument("--station-md", type=float, default=None)
     p_fl.add_argument("--actor", type=str, default="cli")
 
-    p_sy = sub.add_parser("survey", help="a LAS file in, one strata report out (--demo: the bundled public KTB excerpt); --out writes report.txt + survey.json")
-    p_sy.add_argument("--file", type=str, default=None, help="LAS 2.0 file")
+    p_sy = sub.add_parser("survey", help="a LAS or DLIS file in, one strata report out (--demo: the bundled public KTB excerpt); --out writes report.txt + survey.json")
+    p_sy.add_argument("--file", type=str, default=None, help="LAS 2.0 or DLIS (RP66 V1) file")
+    p_sy.add_argument("--frame", type=str, default=None, help="DLIS: the frame to read when the file holds several (gea dlis --file X --info lists them)")
+    p_sy.add_argument("--catalog", type=str, default=None, help="a catalogue LAS entry instead of a file (gea catalog --list names them)")
     p_sy.add_argument("--demo", action="store_true")
     p_sy.add_argument("--family", type=str, default="continental_crystalline", help="prior family for the estimator")
     p_sy.add_argument("--lat", type=float, default=None)
@@ -807,9 +829,9 @@ def main(argv=None) -> int:
     elif a.cmd == "survey":
         import json as _json
         from .survey_cmd import run_survey
-        if not (a.file or a.demo):
-            raise SystemExit("survey needs --file <LAS> or --demo")
-        txt, machine = run_survey(path=a.file, demo=a.demo, family=a.family, lat=a.lat, elev=a.elev)
+        if not (a.file or a.demo or a.catalog):
+            raise SystemExit("survey needs --file <LAS or DLIS>, --catalog <entry> or --demo")
+        txt, machine = run_survey(path=a.file, demo=a.demo, family=a.family, lat=a.lat, elev=a.elev, frame=a.frame, catalog=a.catalog)
         print(txt)
         if a.out:
             os.makedirs(a.out, exist_ok=True)
@@ -2282,6 +2304,163 @@ def main(argv=None) -> int:
             stop.set()
             print("etp-sim: stopped")
         return 0
+    elif a.cmd == "catalog":
+        import json as _json
+        from . import catalog_register as _CR
+        if a.friction:
+            from . import friction_priors as _FP
+            print(_json.dumps({"measured": _FP.measured(), "envelope": _FP.envelope()}, indent=1, default=str) if a.json else _FP.text()); return 0
+        if a.core:
+            from .rock_inventory import core_check
+            c = core_check()
+            print(_json.dumps(c, indent=1) if a.json else (f"core check ({c.get('entry')}): {c.get('how')}\n  grain density {c['grain_density']['min']}-{c['grain_density']['max']} g/cc, porosity "
+                  f"{c['porosity_frac']['min']:.3f}-{c['porosity_frac']['max']:.3f}, bulk {c['bulk_density']['min']}-{c['bulk_density']['max']} g/cc; {c['outside']} plug(s) outside the range\n  source: {c['source']} [{c['license']}]" if c.get('status') == 'OK' else str(c)))
+            return 0
+        if a.check:
+            rows = _CR.check_all()
+            bad = [r for r in rows if not r["ok"]]
+            for r in rows:
+                print(f"  {'ok ' if r['ok'] else 'BAD'} {r['entry']:<40s} {r['shape']}")
+            print(f"catalog: {len(rows) - len(bad)} of {len(rows)} entries read through their own readers" + (f"; {len(bad)} did not" if bad else ""))
+            return 0 if not bad else 1
+        if a.entry:
+            from .profile_catalog import CATALOG as _CAT
+            e = _CAT.get(a.entry)
+            if e is None:
+                raise SystemExit(f"catalog: no entry {a.entry!r} (gea catalog --list)")
+            if a.stream_csv:
+                st = e.stream()
+                import csv as _csv
+                with open(a.stream_csv, "w", newline="", encoding="utf-8") as f:
+                    wr = _csv.writer(f)
+                    wr.writerow([st.index_kind] + list(st.channels)); wr.writerow([""] + [st.channels[c].unit for c in st.channels])
+                    for i in range(len(st.index)):
+                        wr.writerow([float(st.index[i])] + ["" if st.channels[c].values[i] != st.channels[c].values[i] else float(st.channels[c].values[i]) for c in st.channels])
+                print(f"{a.entry}: {len(st.index)} rows x {len(st.channels)} channels -> {a.stream_csv}")
+            reg = next(r for r in _CR.register() if r["entry"] == a.entry)
+            if a.json:
+                print(_json.dumps({"register": reg, "provenance": e.provenance}, indent=1, default=str))
+            else:
+                print(f"{a.entry}: {reg['kind']} ({reg['tier']}), {reg['file']} {reg['bytes']:,} bytes, {reg['status']}")
+                for u in reg["used_by"]:
+                    print("  used by:", u)
+                for k in ("well", "source_database", "source_url", "license", "fetch_date", "coverage", "purpose"):
+                    if e.provenance.get(k):
+                        print(f"  {k}: {str(e.provenance[k])[:300]}")
+                print("  reads as:", _CR.check_entry(e)["shape"])
+            return 0
+        rows = _CR.register()
+        if a.json:
+            print(_json.dumps({"entries": rows, "audit": _CR.audit()}, indent=1, default=str)); return 0
+        print(_CR.text(rows, unused_only=a.unused))
+        if a.unused:
+            print(f"\n  {_CR.NO_BAND_REASON}")
+        return 0
+    elif a.cmd == "dlis":
+        import json as _json
+        from .dlis import DlisError, DlisFile, read as _read_dlis
+        try:
+            if a.info or not (a.out or a.to_las):
+                with open(a.file, "rb") as f:
+                    info = DlisFile(f.read(), os.path.basename(a.file)).describe()
+                if a.json:
+                    print(_json.dumps(info, indent=1, default=str)); return 0
+                o = info["origin"]
+                print(f"dlis: {a.file}")
+                print(f"  storage set: {info['storage_unit']['storage_set_id']}; file {info['file_header'].get('ID', '').strip()} seq {info['file_header'].get('SEQUENCE-NUMBER', '').strip()}")
+                print(f"  well: {o.get('WELL-NAME', '').strip() or '?'}  field: {o.get('FIELD-NAME', '').strip() or '?'}  company: {o.get('COMPANY', '').strip() or '?'}  producer: {o.get('PRODUCER-NAME', '').strip() or '?'}  created: {o.get('CREATION-TIME', '?')}")
+                print(f"  {info['n_records']} logical records; sets: " + ", ".join(f"{t}{'(' + n + ')' if n else ''} x{k}" for t, n, k in info["eflr_sets"]))
+                if info.get("encrypted_records"):
+                    print("  encrypted records skipped: " + ", ".join(f"{k} x{n}" for k, n in info["encrypted_records"].items()))
+                for u in info["unparsed"]:
+                    print("  not parsed: " + u)
+                print(f"  {len(info['channels'])} channels:")
+                for c in info["channels"]:
+                    print(f"    {c['name']:<12s} {c['units']:<10s} {c['code']:<7s} dim {c['dimension']}  {c['long_name']}")
+                for fr in info["frames"]:
+                    print(f"  frame {fr['name']}: index {fr['index_type']} {fr['direction']}, spacing {fr['spacing']} {fr['spacing_units']}, {fr['index_min']}..{fr['index_max']}; {len(fr['channels'])} channels: {', '.join(fr['channels'][:12])}{' ...' if len(fr['channels']) > 12 else ''}")
+                return 0
+            st = _read_dlis(a.file, frame=a.frame)
+        except (DlisError, OSError) as e:
+            raise SystemExit(f"dlis: {e}")
+        print(f"dlis: frame {st.meta['frame']}: {len(st.index)} rows, index {st.meta['index_channel']} ({st.meta['index_units']}) {float(st.index[0]):g}..{float(st.index[-1]):g}, {len(st.channels)} channels"
+              + (f"; {st.meta['notes']}" if st.meta.get("notes") else ""))
+        if a.out:
+            import csv as _csv
+            with open(a.out, "w", newline="", encoding="utf-8") as f:
+                w = _csv.writer(f)
+                w.writerow([st.meta["index_channel"]] + list(st.channels))
+                w.writerow([st.meta["index_units"]] + [st.channels[c].unit for c in st.channels])
+                for i in range(len(st.index)):
+                    w.writerow([float(st.index[i])] + ["" if st.channels[c].values[i] != st.channels[c].values[i] else float(st.channels[c].values[i]) for c in st.channels])
+            print("  csv:", a.out)
+        if a.to_las:
+            with open(a.to_las, "w", encoding="utf-8") as f:
+                f.write("~VERSION INFORMATION\n VERS.   2.0 : CWLS LOG ASCII STANDARD - VERSION 2.0\n WRAP.   NO  : ONE LINE PER DEPTH STEP\n")
+                f.write("~WELL INFORMATION\n")
+                f.write(f" STRT.{st.meta['index_units']:<6s} {float(st.index[0]):.4f} : START\n STOP.{st.meta['index_units']:<6s} {float(st.index[-1]):.4f} : STOP\n")
+                f.write(f" STEP.{st.meta['index_units']:<6s} {(float(st.index[1]) - float(st.index[0])) if len(st.index) > 1 else 0.0:.4f} : STEP\n NULL.       -999.25 : NULL VALUE\n")
+                f.write(f" WELL.       {st.meta.get('WELL-NAME', '').strip()} : WELL\n FLD .       {st.meta.get('FIELD-NAME', '').strip()} : FIELD\n COMP.       {st.meta.get('COMPANY', '').strip()} : COMPANY\n SRVC.       {st.meta.get('PRODUCER-NAME', '').strip()} : SERVICE COMPANY\n")
+                f.write(f" SRC .       DLIS {os.path.basename(a.file)} frame {st.meta['frame']} : SOURCE (gea dlis --to-las)\n")
+                f.write("~CURVE INFORMATION\n")
+                f.write(f" {st.meta['index_channel']:<8s}.{st.meta['index_units']:<8s} : INDEX\n")
+                for c in st.channels:
+                    f.write(f" {c:<8s}.{st.channels[c].unit:<8s} : {c}\n")
+                f.write("~A\n")
+                for i in range(len(st.index)):
+                    f.write(f"{float(st.index[i]):.4f}" + "".join(f" {(-999.25 if st.channels[c].values[i] != st.channels[c].values[i] else float(st.channels[c].values[i])):.4f}" for c in st.channels) + "\n")
+            print("  las:", a.to_las)
+        return 0
+    elif a.cmd == "piwebapi":
+        import json as _json
+        from .live_ports import records_to_stream, summarize, write_records_csv
+        from . import piwebapi as _PI
+        if a.selftest:
+            r = _PI.selftest()
+            print(f"piwebapi selftest: {'OK' if r['ok'] else 'FAILED'}")
+            for k, v in r.items():
+                if k != "ok":
+                    print(f"  {'ok ' if v else 'BAD'} {k}")
+            return 0 if r["ok"] else 1
+        if a.write_example_config:
+            with open(a.write_example_config, "w", encoding="utf-8") as f:
+                _json.dump(_PI.EXAMPLE_CONFIG, f, indent=1)
+            print("config:", a.write_example_config); return 0
+        if not a.config:
+            raise SystemExit("piwebapi needs --config (or --write-example-config to start one)")
+        cfg = _PI.load_config(a.config)
+        sim_h = None
+        try:
+            if cfg.get("base_url") == "sim":
+                sim = _PI.SimServer(); sim_h, port_ = sim.serve(); cfg = {**cfg, "base_url": f"http://127.0.0.1:{port_}/piwebapi", "auth": "none"}
+            try:
+                port = _PI.PiPort(cfg)
+                r = port.pull()
+            except (_PI.PiError, ValueError) as e:
+                raise SystemExit(f"piwebapi: {e}")
+        finally:
+            if sim_h is not None:
+                sim_h.close()
+        recs = port.records
+        print(f"piwebapi: {_json.dumps(port.summary(), default=str)}")
+        print(_json.dumps(summarize(recs), indent=1))
+        if a.record:
+            with open(a.record, "w", encoding="utf-8") as f:
+                f.write(_json.dumps({"pull": r, "summary": port.summary()}, default=str) + "\n")
+        if a.out:
+            print("  records:", write_records_csv(recs, a.out))
+        if a.stream_csv and recs:
+            st = records_to_stream(recs, name="piwebapi")
+            import csv as _csv
+            from datetime import datetime as _dt, timedelta as _td
+            t0 = _dt.fromisoformat(st.meta["start_time"])
+            with open(a.stream_csv, "w", newline="", encoding="utf-8") as f:
+                w = _csv.writer(f)
+                w.writerow(["timestamp"] + list(st.channels))
+                for i, t in enumerate(st.index):
+                    w.writerow([(t0 + _td(seconds=float(t))).isoformat()] + ["" if st.channels[c].values[i] != st.channels[c].values[i] else round(float(st.channels[c].values[i]), 4) for c in st.channels])
+            print("  stream:", a.stream_csv)
+        return 0 if not port.faults else 1
     elif a.cmd in ("modbus-rtu", "dnp3", "hartip"):
         import json as _json
         from .live_ports import records_to_stream, summarize, write_records_csv